diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 159c3647f..90c6cfe50 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -9,6 +9,7 @@ on: - "*" # new tag version, like `0.8.4` or else branches: - master + - flatbuffers-64 pull_request: branches: - master diff --git a/BUILD.bazel b/BUILD.bazel index de910bc53..0ff3b234e 100644 --- a/BUILD.bazel +++ b/BUILD.bazel @@ -47,6 +47,7 @@ filegroup( "include/flatbuffers/code_generators.h", "include/flatbuffers/default_allocator.h", "include/flatbuffers/detached_buffer.h", + "include/flatbuffers/file_manager.h", "include/flatbuffers/flatbuffer_builder.h", "include/flatbuffers/flatbuffers.h", "include/flatbuffers/flex_flat_util.h", diff --git a/CMakeLists.txt b/CMakeLists.txt index 27d80859f..2b65c20e5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -127,6 +127,7 @@ set(FlatBuffers_Library_SRCS include/flatbuffers/default_allocator.h include/flatbuffers/detached_buffer.h include/flatbuffers/code_generator.h + include/flatbuffers/file_manager.h include/flatbuffers/flatbuffer_builder.h include/flatbuffers/flatbuffers.h include/flatbuffers/flexbuffers.h @@ -171,6 +172,9 @@ set(FlatBuffers_Compiler_SRCS src/idl_gen_grpc.cpp src/idl_gen_json_schema.cpp src/idl_gen_swift.cpp + src/file_name_saving_file_manager.cpp + src/file_binary_writer.cpp + src/file_writer.cpp src/idl_namer.h src/namer.h src/flatc.cpp diff --git a/README.md b/README.md index 7f528cdad..1fb2fe0c6 100644 --- a/README.md +++ b/README.md @@ -31,14 +31,14 @@ Code generation and runtime libraries for many popular languages. 1. C++ - [snapcraft.io](https://snapcraft.io/flatbuffers) 1. C# - [nuget.org](https://www.nuget.org/packages/Google.FlatBuffers) 1. Dart - [pub.dev](https://pub.dev/packages/flat_buffers) -1. Go - [go.dev](https://pkg.go.dev/github.com/google/flatbuffers/go) +1. Go - [go.dev](https://pkg.go.dev/github.com/google/flatbuffers) 1. Java - [Maven](https://search.maven.org/artifact/com.google.flatbuffers/flatbuffers-java) 1. JavaScript - [NPM](https://www.npmjs.com/package/flatbuffers) 1. Kotlin 1. Lobster 1. Lua 1. PHP -1. Python - [PyPi](https://pypi.org/project/flatbuffers/) +1. Python - [PyPI](https://pypi.org/project/flatbuffers/) 1. Rust - [crates.io](https://crates.io/crates/flatbuffers) 1. Swift - [swiftpackageindex](https://swiftpackageindex.com/google/flatbuffers) 1. TypeScript - [NPM](https://www.npmjs.com/package/flatbuffers) diff --git a/docs/source/CsharpUsage.md b/docs/source/CsharpUsage.md index da36fa8b5..b0acc77d8 100644 --- a/docs/source/CsharpUsage.md +++ b/docs/source/CsharpUsage.md @@ -142,6 +142,47 @@ To use it: `ByKey` only works if the vector has been sorted, it will likely not find elements if it hasn't been sorted. +## Buffer verification + +As mentioned in [C++ Usage](@ref flatbuffers_guide_use_cpp) buffer +accessor functions do not verify buffer offsets at run-time. +If it is necessary, you can optionally use a buffer verifier before you +access the data. This verifier will check all offsets, all sizes of +fields, and null termination of strings to ensure that when a buffer +is accessed, all reads will end up inside the buffer. + +Each root type will have a verification function generated for it, +e.g. `Monster.VerifyMonster`. This can be called as shown: +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cs} + var ok = Monster.VerifyMonster(buf); +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +if `ok` is true, the buffer is safe to read. + +For a more detailed control of verification `MonsterVerify.Verify` +for `Monster` type can be used: +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cs} + # Sequence of calls + FlatBuffers.Verifier verifier = new FlatBuffers.Verifier(buf); + var ok = verifier.VerifyBuffer("MONS", false, MonsterVerify.Verify); + + # Or single line call + var ok = new FlatBuffers.Verifier(bb).setStringCheck(true).\ + VerifyBuffer("MONS", false, MonsterVerify.Verify); + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +if `ok` is true, the buffer is safe to read. + +A second parameter of `verifyBuffer` specifies whether buffer content is +size prefixed or not. In the example above, the buffer is assumed to not include +size prefix (`false`). + +Verifier supports options that can be set using appropriate fluent methods: +* SetMaxDepth - limit the nesting depth. Default: 1000000 +* SetMaxTables - total amount of tables the verifier may encounter. Default: 64 +* SetAlignmentCheck - check content alignment. Default: True +* SetStringCheck - check if strings contain termination '0' character. Default: true + + ## Text parsing There currently is no support for parsing text (Schema's and JSON) directly diff --git a/docs/source/Tutorial.md b/docs/source/Tutorial.md index 752b3e23c..70196fd29 100644 --- a/docs/source/Tutorial.md +++ b/docs/source/Tutorial.md @@ -529,7 +529,7 @@ The first step is to import/include the library, generated files, etc. #[allow(dead_code, unused_imports)] #[path = "./monster_generated.rs"] mod monster_generated; - pub use monster_generated::my_game::sample::{get_root_as_monster, + pub use monster_generated::my_game::sample::{root_as_monster, Color, Equipment, Monster, MonsterArgs, Vec3, @@ -652,7 +652,7 @@ which will grow automatically if needed: ~~~{.rs} // Build up a serialized buffer algorithmically. // Initialize it with a capacity of 1024 bytes. - let mut builder = flatbuffers::FlatBufferBuilder::new_with_capacity(1024); + let mut builder = flatbuffers::FlatBufferBuilder::with_capacity(1024); ~~~
@@ -2309,7 +2309,7 @@ import './monster_my_game.sample_generated.dart' as myGame; #[allow(dead_code, unused_imports)] #[path = "./monster_generated.rs"] mod monster_generated; - pub use monster_generated::my_game::sample::{get_root_as_monster, + pub use monster_generated::my_game::sample::{root_as_monster, Color, Equipment, Monster, MonsterArgs, Vec3, @@ -2465,7 +2465,7 @@ myGame.Monster monster = new myGame.Monster(data); let buf = /* the data you just read, in a &[u8] */ // Get an accessor to the root object inside the buffer. - let monster = get_root_as_monster(buf); + let monster = root_as_monster(buf).unwrap(); ~~~
diff --git a/docs/source/doxyfile b/docs/source/doxyfile index 8cf9000da..9541aaff7 100644 --- a/docs/source/doxyfile +++ b/docs/source/doxyfile @@ -779,7 +779,8 @@ INPUT = "FlatBuffers.md" \ "../../python/flatbuffers/builder.py" \ "../../js/flatbuffers.js" \ "../../php/FlatbufferBuilder.php" \ - "../../net/FlatBuffers/FlatBufferBuilder.cs" \ + "../../net/FlatBuffers/FlatBufferBuilder.cs" + "../../net/FlatBuffers/FlatBufferVerify.cs" \ "../../include/flatbuffers/flatbuffers.h" \ "../../go/builder.go" \ "../../rust/flatbuffers/src/builder.rs" diff --git a/examples/go-echo/hero/Warrior.go b/examples/go-echo/hero/Warrior.go index 857697e16..0e9802c18 100644 --- a/examples/go-echo/hero/Warrior.go +++ b/examples/go-echo/hero/Warrior.go @@ -12,8 +12,13 @@ type WarriorT struct { } func (t *WarriorT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } - nameOffset := builder.CreateString(t.Name) + if t == nil { + return 0 + } + nameOffset := flatbuffers.UOffsetT(0) + if t.Name != "" { + nameOffset = builder.CreateString(t.Name) + } WarriorStart(builder) WarriorAddName(builder, nameOffset) WarriorAddHp(builder, t.Hp) @@ -26,7 +31,9 @@ func (rcv *Warrior) UnPackTo(t *WarriorT) { } func (rcv *Warrior) UnPack() *WarriorT { - if rcv == nil { return nil } + if rcv == nil { + return nil + } t := &WarriorT{} rcv.UnPackTo(t) return t diff --git a/examples/go-echo/net/Request.go b/examples/go-echo/net/Request.go index b2449c1ca..4c8336265 100644 --- a/examples/go-echo/net/Request.go +++ b/examples/go-echo/net/Request.go @@ -13,7 +13,9 @@ type RequestT struct { } func (t *RequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } + if t == nil { + return 0 + } playerOffset := t.Player.Pack(builder) RequestStart(builder) RequestAddPlayer(builder, playerOffset) @@ -25,7 +27,9 @@ func (rcv *Request) UnPackTo(t *RequestT) { } func (rcv *Request) UnPack() *RequestT { - if rcv == nil { return nil } + if rcv == nil { + return nil + } t := &RequestT{} rcv.UnPackTo(t) return t diff --git a/examples/go-echo/net/Response.go b/examples/go-echo/net/Response.go index 57e6b3535..a9d1f4378 100644 --- a/examples/go-echo/net/Response.go +++ b/examples/go-echo/net/Response.go @@ -13,7 +13,9 @@ type ResponseT struct { } func (t *ResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } + if t == nil { + return 0 + } playerOffset := t.Player.Pack(builder) ResponseStart(builder) ResponseAddPlayer(builder, playerOffset) @@ -25,7 +27,9 @@ func (rcv *Response) UnPackTo(t *ResponseT) { } func (rcv *Response) UnPack() *ResponseT { - if rcv == nil { return nil } + if rcv == nil { + return nil + } t := &ResponseT{} rcv.UnPackTo(t) return t diff --git a/go/lib.go b/go/lib.go index 9333d8bd3..a4e99de10 100644 --- a/go/lib.go +++ b/go/lib.go @@ -28,3 +28,23 @@ func GetSizePrefix(buf []byte, offset UOffsetT) uint32 { func GetIndirectOffset(buf []byte, offset UOffsetT) UOffsetT { return offset + GetUOffsetT(buf[offset:]) } + +// GetBufferIdentifier returns the file identifier as string +func GetBufferIdentifier(buf []byte) string { + return string(buf[SizeUOffsetT:][:fileIdentifierLength]) +} + +// GetBufferIdentifier returns the file identifier as string for a size-prefixed buffer +func GetSizePrefixedBufferIdentifier(buf []byte) string { + return string(buf[SizeUOffsetT+sizePrefixLength:][:fileIdentifierLength]) +} + +// BufferHasIdentifier checks if the identifier in a buffer has the expected value +func BufferHasIdentifier(buf []byte, identifier string) bool { + return GetBufferIdentifier(buf) == identifier +} + +// BufferHasIdentifier checks if the identifier in a buffer has the expected value for a size-prefixed buffer +func SizePrefixedBufferHasIdentifier(buf []byte, identifier string) bool { + return GetSizePrefixedBufferIdentifier(buf) == identifier +} diff --git a/grpc/examples/go/greeter/models/HelloReply.go b/grpc/examples/go/greeter/models/HelloReply.go index bb5db4078..747db2d87 100644 --- a/grpc/examples/go/greeter/models/HelloReply.go +++ b/grpc/examples/go/greeter/models/HelloReply.go @@ -17,6 +17,10 @@ func GetRootAsHelloReply(buf []byte, offset flatbuffers.UOffsetT) *HelloReply { return x } +func FinishHelloReplyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + func GetSizePrefixedRootAsHelloReply(buf []byte, offset flatbuffers.UOffsetT) *HelloReply { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) x := &HelloReply{} @@ -24,6 +28,10 @@ func GetSizePrefixedRootAsHelloReply(buf []byte, offset flatbuffers.UOffsetT) *H return x } +func FinishSizePrefixedHelloReplyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + func (rcv *HelloReply) Init(buf []byte, i flatbuffers.UOffsetT) { rcv._tab.Bytes = buf rcv._tab.Pos = i diff --git a/grpc/examples/go/greeter/models/HelloRequest.go b/grpc/examples/go/greeter/models/HelloRequest.go index 52feab976..3710cf5aa 100644 --- a/grpc/examples/go/greeter/models/HelloRequest.go +++ b/grpc/examples/go/greeter/models/HelloRequest.go @@ -17,6 +17,10 @@ func GetRootAsHelloRequest(buf []byte, offset flatbuffers.UOffsetT) *HelloReques return x } +func FinishHelloRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + func GetSizePrefixedRootAsHelloRequest(buf []byte, offset flatbuffers.UOffsetT) *HelloRequest { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) x := &HelloRequest{} @@ -24,6 +28,10 @@ func GetSizePrefixedRootAsHelloRequest(buf []byte, offset flatbuffers.UOffsetT) return x } +func FinishSizePrefixedHelloRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + func (rcv *HelloRequest) Init(buf []byte, i flatbuffers.UOffsetT) { rcv._tab.Bytes = buf rcv._tab.Pos = i diff --git a/grpc/examples/python/greeter/models/HelloReply.py b/grpc/examples/python/greeter/models/HelloReply.py index 301c84d9c..f1082fa23 100644 --- a/grpc/examples/python/greeter/models/HelloReply.py +++ b/grpc/examples/python/greeter/models/HelloReply.py @@ -31,12 +31,20 @@ class HelloReply(object): return self._tab.String(o + self._tab.Pos) return None -def HelloReplyStart(builder): builder.StartObject(1) +def HelloReplyStart(builder): + return builder.StartObject(1) + def Start(builder): return HelloReplyStart(builder) -def HelloReplyAddMessage(builder, message): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0) + +def HelloReplyAddMessage(builder, message): + return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0) + def AddMessage(builder, message): return HelloReplyAddMessage(builder, message) -def HelloReplyEnd(builder): return builder.EndObject() + +def HelloReplyEnd(builder): + return builder.EndObject() + def End(builder): - return HelloReplyEnd(builder) \ No newline at end of file + return HelloReplyEnd(builder) diff --git a/grpc/examples/python/greeter/models/HelloRequest.py b/grpc/examples/python/greeter/models/HelloRequest.py index 122568fd2..b295369e6 100644 --- a/grpc/examples/python/greeter/models/HelloRequest.py +++ b/grpc/examples/python/greeter/models/HelloRequest.py @@ -31,12 +31,20 @@ class HelloRequest(object): return self._tab.String(o + self._tab.Pos) return None -def HelloRequestStart(builder): builder.StartObject(1) +def HelloRequestStart(builder): + return builder.StartObject(1) + def Start(builder): return HelloRequestStart(builder) -def HelloRequestAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + +def HelloRequestAddName(builder, name): + return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + def AddName(builder, name): return HelloRequestAddName(builder, name) -def HelloRequestEnd(builder): return builder.EndObject() + +def HelloRequestEnd(builder): + return builder.EndObject() + def End(builder): - return HelloRequestEnd(builder) \ No newline at end of file + return HelloRequestEnd(builder) diff --git a/include/flatbuffers/file_manager.h b/include/flatbuffers/file_manager.h new file mode 100644 index 000000000..069df5b88 --- /dev/null +++ b/include/flatbuffers/file_manager.h @@ -0,0 +1,48 @@ +/* + * Copyright 2023 Google Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef FLATBUFFERS_FILE_MANAGER_H_ +#define FLATBUFFERS_FILE_MANAGER_H_ + +#include +#include + +#include "flatbuffers/util.h" + +namespace flatbuffers { + +// A File interface to write data to file by default or +// save only file names +class FileManager { + public: + FileManager() = default; + virtual ~FileManager() = default; + + virtual bool SaveFile(const std::string &absolute_file_name, + const std::string &content) = 0; + + virtual bool LoadFile(const std::string &absolute_file_name, + std::string *buf) = 0; + + private: + // Copying is not supported. + FileManager(const FileManager &) = delete; + FileManager &operator=(const FileManager &) = delete; +}; + +} // namespace flatbuffers + +#endif // FLATBUFFERS_FILE_MANAGER_H_ diff --git a/include/flatbuffers/flatbuffer_builder.h b/include/flatbuffers/flatbuffer_builder.h index a1d3d60a7..b9015d850 100644 --- a/include/flatbuffers/flatbuffer_builder.h +++ b/include/flatbuffers/flatbuffer_builder.h @@ -1184,7 +1184,8 @@ class FlatBufferBuilder { // Allocates space for a vector of structures. // Must be completed with EndVectorOfStructs(). template T *StartVectorOfStructs(size_t vector_size) { - StartVector(vector_size * sizeof(T) / AlignOf(), sizeof(T), AlignOf()); + StartVector(vector_size * sizeof(T) / AlignOf(), sizeof(T), + AlignOf()); return reinterpret_cast(buf_.make_space(vector_size * sizeof(T))); } diff --git a/include/flatbuffers/flatc.h b/include/flatbuffers/flatc.h index e6227d640..e98eb80d7 100644 --- a/include/flatbuffers/flatc.h +++ b/include/flatbuffers/flatc.h @@ -56,6 +56,7 @@ struct FlatCOptions { bool schema_binary = false; bool grpc_enabled = false; bool requires_bfbs = false; + bool file_names_only = false; std::vector> generators; }; diff --git a/include/flatbuffers/flexbuffers.h b/include/flatbuffers/flexbuffers.h index a0ee67003..8e8cac144 100644 --- a/include/flatbuffers/flexbuffers.h +++ b/include/flatbuffers/flexbuffers.h @@ -1424,12 +1424,10 @@ class Builder FLATBUFFERS_FINAL_CLASS { template static Type GetScalarType() { static_assert(flatbuffers::is_scalar::value, "Unrelated types"); - return flatbuffers::is_floating_point::value - ? FBT_FLOAT - : flatbuffers::is_same::value - ? FBT_BOOL - : (flatbuffers::is_unsigned::value ? FBT_UINT - : FBT_INT); + return flatbuffers::is_floating_point::value ? FBT_FLOAT + : flatbuffers::is_same::value + ? FBT_BOOL + : (flatbuffers::is_unsigned::value ? FBT_UINT : FBT_INT); } public: diff --git a/include/flatbuffers/idl.h b/include/flatbuffers/idl.h index 8f08003d2..bee672740 100644 --- a/include/flatbuffers/idl.h +++ b/include/flatbuffers/idl.h @@ -697,6 +697,7 @@ struct IDLOptions { bool no_leak_private_annotations; bool require_json_eof; bool keep_proto_id; + bool python_no_type_prefix_suffix; ProtoIdGapAction proto_id_gap_action; // Possible options for the more general generator below. @@ -806,6 +807,7 @@ struct IDLOptions { no_leak_private_annotations(false), require_json_eof(true), keep_proto_id(false), + python_no_type_prefix_suffix(false), proto_id_gap_action(ProtoIdGapAction::WARNING), mini_reflect(IDLOptions::kNone), require_explicit_ids(false), diff --git a/include/flatbuffers/minireflect.h b/include/flatbuffers/minireflect.h index 22f43fbab..1e04bfff0 100644 --- a/include/flatbuffers/minireflect.h +++ b/include/flatbuffers/minireflect.h @@ -408,7 +408,7 @@ inline std::string FlatBufferToString(const uint8_t *buffer, const TypeTable *type_table, bool multi_line = false, bool vector_delimited = true, - const std::string& indent = "") { + const std::string &indent = "") { ToStringVisitor tostring_visitor(multi_line ? "\n" : " ", false, indent, vector_delimited); IterateFlatBuffer(buffer, type_table, &tostring_visitor); diff --git a/include/flatbuffers/util.h b/include/flatbuffers/util.h index 6d0cd2c0c..a6bcf34b6 100644 --- a/include/flatbuffers/util.h +++ b/include/flatbuffers/util.h @@ -722,9 +722,10 @@ enum class Case { kSnake2 = 9, }; -// Convert the `input` string of case `input_case` to the specified `output_case`. +// Convert the `input` string of case `input_case` to the specified +// `output_case`. std::string ConvertCase(const std::string &input, Case output_case, - Case input_case = Case::kSnake); + Case input_case = Case::kSnake); } // namespace flatbuffers diff --git a/net/FlatBuffers/FlatBufferBuilder.cs b/net/FlatBuffers/FlatBufferBuilder.cs index e550f90f8..e08db847b 100644 --- a/net/FlatBuffers/FlatBufferBuilder.cs +++ b/net/FlatBuffers/FlatBufferBuilder.cs @@ -438,7 +438,8 @@ namespace Google.FlatBuffers if (off > Offset) throw new ArgumentException(); - off = Offset - off + sizeof(int); + if (off != 0) + off = Offset - off + sizeof(int); PutInt(off); } diff --git a/net/FlatBuffers/FlatBufferVerify.cs b/net/FlatBuffers/FlatBufferVerify.cs new file mode 100644 index 000000000..15064e8a5 --- /dev/null +++ b/net/FlatBuffers/FlatBufferVerify.cs @@ -0,0 +1,822 @@ +/* + * Copyright 2014 Google Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +using System; +using System.Reflection;using System.Collections.Generic; +using System.IO; + +namespace Google.FlatBuffers +{ + + /// + /// The Class of the Verifier Options + /// + public class Options + { + public const int DEFAULT_MAX_DEPTH = 64; + public const int DEFAULT_MAX_TABLES = 1000000; + + private int max_depth = 0; + private int max_tables = 0; + private bool string_end_check = false; + private bool alignment_check = false; + + public Options() + { + max_depth = DEFAULT_MAX_DEPTH; + max_tables = DEFAULT_MAX_TABLES; + string_end_check = true; + alignment_check = true; + } + + public Options(int maxDepth, int maxTables, bool stringEndCheck, bool alignmentCheck) + { + max_depth = maxDepth; + max_tables = maxTables; + string_end_check = stringEndCheck; + alignment_check = alignmentCheck; + } + /// Maximum depth of nested tables allowed in a valid flatbuffer. + public int maxDepth + { + get { return max_depth; } + set { max_depth = value; } + } + /// Maximum number of tables allowed in a valid flatbuffer. + public int maxTables + { + get { return max_tables; } + set { max_tables = value; } + } + /// Check that string contains its null terminator + public bool stringEndCheck + { + get { return string_end_check; } + set { string_end_check = value; } + } + /// Check alignment of elements + public bool alignmentCheck + { + get { return alignment_check; } + set { alignment_check = value; } + } + } + + public struct checkElementStruct + { + public bool elementValid; + public uint elementOffset; + } + + public delegate bool VerifyTableAction(Verifier verifier, uint tablePos); + public delegate bool VerifyUnionAction(Verifier verifier, byte typeId, uint tablePos); + + /// + /// The Main Class of the FlatBuffer Verifier + /// + public class Verifier + { + private ByteBuffer verifier_buffer = null; + private Options verifier_options = null; + private int depth_cnt = 0; + private int num_tables_cnt = 0; + + public const int SIZE_BYTE = 1; + public const int SIZE_INT = 4; + public const int SIZE_U_OFFSET = 4; + public const int SIZE_S_OFFSET = 4; + public const int SIZE_V_OFFSET = 2; + public const int SIZE_PREFIX_LENGTH = FlatBufferConstants.SizePrefixLength; // default size = 4 + public const int FLATBUFFERS_MAX_BUFFER_SIZE = System.Int32.MaxValue; // default size = 2147483647 + public const int FILE_IDENTIFIER_LENGTH = FlatBufferConstants.FileIdentifierLength; // default size = 4 + + /// The Base Constructor of the Verifier object + public Verifier() + { + // Verifier buffer + verifier_buffer = null; + // Verifier settings + verifier_options = null; + // Depth counter + depth_cnt = 0; + // Tables counter + num_tables_cnt = 0; + } + + /// The Constructor of the Verifier object with input parameters: ByteBuffer and/or Options + /// Input flat byte buffer defined as ByteBuffer type + /// Options object with settings for the coniguration the Verifier + public Verifier(ByteBuffer buf, Options options = null) + { + verifier_buffer = buf; + verifier_options = options ?? new Options(); + depth_cnt = 0; + num_tables_cnt = 0; + } + + /// Bytes Buffer for Verify + public ByteBuffer Buf + { + get { return verifier_buffer; } + set { verifier_buffer = value; } + } + /// Options of the Verifier + public Options options + { + get { return verifier_options; } + set { verifier_options = value; } + } + /// Counter of tables depth in a tested flatbuffer + public int depth + { + get { return depth_cnt; } + set { depth_cnt = value; } + } + /// Counter of tables in a tested flatbuffer + public int numTables + { + get { return num_tables_cnt; } + set { num_tables_cnt = value; } + } + + + /// Method set maximum tables depth of valid structure + /// Specify Value of the maximum depth of the structure + public Verifier SetMaxDepth(int value) + { + verifier_options.maxDepth = value; + return this; + } + /// Specify maximum number of tables in structure + /// Specify Value of the maximum number of the tables in the structure + public Verifier SetMaxTables(int value) + { + verifier_options.maxTables = value; + return this; + } + /// Enable/disable buffer content alignment check + /// Value of the State for buffer content alignment check (Enable = true) + public Verifier SetAlignmentCheck(bool value) + { + verifier_options.alignmentCheck = value; + return this; + } + /// Enable/disable checking of string termination '0' character + /// Value of the option for string termination '0' character check (Enable = true) + public Verifier SetStringCheck(bool value) + { + verifier_options.stringEndCheck = value; + return this; + } + + /// Check if there is identifier in buffer + /// Input flat byte buffer defined as ByteBuffer type + /// Start position of data in the Byte Buffer + /// Identifier for the Byte Buffer + /// Return True when the Byte Buffer Identifier is present + private bool BufferHasIdentifier(ByteBuffer buf, uint startPos, string identifier) + { + if (identifier.Length != FILE_IDENTIFIER_LENGTH) + { + throw new ArgumentException("FlatBuffers: file identifier must be length" + Convert.ToString(FILE_IDENTIFIER_LENGTH)); + } + for (int i = 0; i < FILE_IDENTIFIER_LENGTH; i++) + { + if ((sbyte)identifier[i] != verifier_buffer.GetSbyte(Convert.ToInt32(SIZE_S_OFFSET + i + startPos))) + { + return false; + } + } + + return true; + } + + /// Get UOffsetT from buffer at given position - it must be verified before read + /// Input flat byte buffer defined as ByteBuffer type + /// Position of data in the Byte Buffer + /// Return the UOffset Value (Unsigned Integer type - 4 bytes) in pos + private uint ReadUOffsetT(ByteBuffer buf, uint pos) + { + return buf.GetUint(Convert.ToInt32(pos)); + } + /// Get SOffsetT from buffer at given position - it must be verified before read + /// Input flat byte buffer defined as ByteBuffer type + /// Position of data in the Byte Buffer + /// Return the SOffset Value (Signed Integer type - 4 bytes) in pos + private int ReadSOffsetT(ByteBuffer buf, int pos) + { + return buf.GetInt(pos); + } + /// Get VOffsetT from buffer at given position - it must be verified before read + /// Input flat byte buffer defined as ByteBuffer type + /// Position of data in the Byte Buffer + /// Return the VOffset Value (Short type - 2 bytes) in pos + private short ReadVOffsetT(ByteBuffer buf, int pos) + { + return buf.GetShort(pos); + } + + /// Get table data area relative offset from vtable. Result is relative to table start + /// Fields which are deprecated are ignored by checking against the vtable's length. + /// Position of data in the Byte Buffer + /// offset of value in the Table + /// Return the relative VOffset Value (Short type - 2 bytes) in calculated offset + private short GetVRelOffset(int pos, short vtableOffset) + { + short VOffset = 0; + // Used try/catch because pos typa as int 32bit + try + { + // First, get vtable offset + short vtable = Convert.ToInt16(pos - ReadSOffsetT(verifier_buffer, pos)); + // Check that offset points to vtable area (is smaller than vtable size) + if (vtableOffset < ReadVOffsetT(verifier_buffer, vtable)) + { + // Now, we can read offset value - TODO check this value against size of table data + VOffset = ReadVOffsetT(verifier_buffer, vtable + vtableOffset); + } + else + { + VOffset = 0; + } + } + catch (Exception e) + { + Console.WriteLine("Exception: {0}", e); + return VOffset; + } + return VOffset; + + } + /// Get table data area absolute offset from vtable. Result is the absolute buffer offset. + /// The result value offset cannot be '0' (pointing to itself) so after validation this method returnes '0' + /// value as a marker for missing optional entry + /// Table Position value in the Byte Buffer + /// offset value in the Table + /// Return the absolute UOffset Value + private uint GetVOffset(uint tablePos, short vtableOffset) + { + uint UOffset = 0; + // First, get vtable relative offset + short relPos = GetVRelOffset(Convert.ToInt32(tablePos), vtableOffset); + if (relPos != 0) + { + // Calculate offset based on table postion + UOffset = Convert.ToUInt32(tablePos + relPos); + } + else + { + UOffset = 0; + } + return UOffset; + } + + /// Check flatbuffer complexity (tables depth, elements counter and so on) + /// If complexity is too high function returns false as verification error + private bool CheckComplexity() + { + return ((depth <= options.maxDepth) && (numTables <= options.maxTables)); + } + + /// Check alignment of element. + /// Return True when alignment of the element is correct + private bool CheckAlignment(uint element, ulong align) + { + return (((element & (align - 1)) == 0) || (!options.alignmentCheck)); + } + + /// Check if element is valid in buffer area. + /// Value defines the offset/position to element + /// Size of element + /// Return True when Element is correct + private bool CheckElement(uint pos, ulong elementSize) + { + return ((elementSize < Convert.ToUInt64(verifier_buffer.Length)) && (pos <= (Convert.ToUInt32(verifier_buffer.Length) - elementSize))); + } + /// Check if element is a valid scalar. + /// Value defines the offset to scalar + /// Size of element + /// Return True when Scalar Element is correct + private bool CheckScalar(uint pos, ulong elementSize) + { + return ((CheckAlignment(pos, elementSize)) && (CheckElement(pos, elementSize))); + } + /// Check offset. It is a scalar with size of UOffsetT. + private bool CheckOffset(uint offset) + { + return (CheckScalar(offset, SIZE_U_OFFSET)); + } + + private checkElementStruct CheckVectorOrString(uint pos, ulong elementSize) + { + var result = new checkElementStruct + { + elementValid = false, + elementOffset = 0 + }; + + uint vectorPos = pos; + // Check we can read the vector/string size field (it is of uoffset size) + if (!CheckScalar(vectorPos, SIZE_U_OFFSET)) + { + // result.elementValid = false; result.elementOffset = 0; + return result; + } + // Check the whole array. If this is a string, the byte past the array + // must be 0. + uint size = ReadUOffsetT(verifier_buffer, vectorPos); + ulong max_elements = (FLATBUFFERS_MAX_BUFFER_SIZE / elementSize); + if (size >= max_elements) + { + // Protect against byte_size overflowing. + // result.elementValid = false; result.elementOffset = 0; + return result; + } + + uint bytes_size = SIZE_U_OFFSET + (Convert.ToUInt32(elementSize) * size); + uint buffer_end_pos = vectorPos + bytes_size; + result.elementValid = CheckElement(vectorPos, bytes_size); + result.elementOffset = buffer_end_pos; + return (result); + } + + /// Verify a string at given position. + private bool CheckString(uint pos) + { + var result = CheckVectorOrString(pos, SIZE_BYTE); + if (options.stringEndCheck) + { + result.elementValid = result.elementValid && CheckScalar(result.elementOffset, 1); // Must have terminator + result.elementValid = result.elementValid && (verifier_buffer.GetSbyte(Convert.ToInt32(result.elementOffset)) == 0); // Terminating byte must be 0. + } + return result.elementValid; + } + + /// Verify the vector of elements of given size + private bool CheckVector(uint pos, ulong elementSize) + { + var result = CheckVectorOrString(pos, elementSize); + return result.elementValid; + } + /// Verify table content using structure dependent generated function + private bool CheckTable(uint tablePos, VerifyTableAction verifyAction) + { + return verifyAction(this, tablePos); + } + + /// String check wrapper function to be used in vector of strings check + private bool CheckStringFunc(Verifier verifier, uint pos) + { + return verifier.CheckString(pos); + } + + /// Check vector of objects. Use generated object verification function + private bool CheckVectorOfObjects(uint pos, VerifyTableAction verifyAction) + { + if (!CheckVector(pos, SIZE_U_OFFSET)) + { + return false; + } + uint size = ReadUOffsetT(verifier_buffer, pos); + // Vector data starts just after vector size/length + uint vecStart = pos + SIZE_U_OFFSET; + uint vecOff = 0; + // Iterate offsets and verify referenced objects + for (uint i = 0; i < size; i++) + { + vecOff = vecStart + (i * SIZE_U_OFFSET); + if (!CheckIndirectOffset(vecOff)) + { + return false; + } + uint objOffset = GetIndirectOffset(vecOff); + if (!verifyAction(this, objOffset)) + { + return false; + } + } + return true; + } + + /// Check if the offset referenced by offsetPos is the valid offset pointing to buffer + // offsetPos - offset to offset data + private bool CheckIndirectOffset(uint pos) + { + // Check the input offset is valid + if(!CheckScalar(pos, SIZE_U_OFFSET)) + { + return false; + } + // Get indirect offset + uint offset = ReadUOffsetT(verifier_buffer, pos); + // May not point to itself neither wrap around (buffers are max 2GB) + if ((offset == 0) || (offset >= FLATBUFFERS_MAX_BUFFER_SIZE)) + { + return false; + } + // Must be inside the buffer + return CheckElement(pos + offset, 1); + } + + /// Check flatbuffer content using generated object verification function + private bool CheckBufferFromStart(string identifier, uint startPos, VerifyTableAction verifyAction) + { + if ((identifier != null) && + (identifier.Length == 0) && + ((verifier_buffer.Length < (SIZE_U_OFFSET + FILE_IDENTIFIER_LENGTH)) || (!BufferHasIdentifier(verifier_buffer, startPos, identifier)))) + { + return false; + } + if(!CheckIndirectOffset(startPos)) + { + return false; + } + uint offset = GetIndirectOffset(startPos); + return CheckTable(offset, verifyAction); // && GetComputedSize() + } + + /// Get indirect offset. It is an offset referenced by offset Pos + private uint GetIndirectOffset(uint pos) + { + // Get indirect offset referenced by offsetPos + uint offset = pos + ReadUOffsetT(verifier_buffer, pos); + return offset; + } + + /// Verify beginning of table + /// Position in the Table + /// Return True when the verification of the beginning of the table is passed + // (this method is used internally by generated verification functions) + public bool VerifyTableStart(uint tablePos) + { + // Starting new table verification increases complexity of structure + depth_cnt++; + num_tables_cnt++; + + if (!CheckScalar(tablePos, SIZE_S_OFFSET)) + { + return false; + } + uint vtable = (uint)(tablePos - ReadSOffsetT(verifier_buffer, Convert.ToInt32(tablePos))); + return ((CheckComplexity()) && (CheckScalar(vtable, SIZE_V_OFFSET)) && (CheckAlignment(Convert.ToUInt32(ReadVOffsetT(verifier_buffer, Convert.ToInt32(vtable))), SIZE_V_OFFSET)) && (CheckElement(vtable, Convert.ToUInt64(ReadVOffsetT(verifier_buffer, Convert.ToInt32(vtable)))))); + } + + /// Verify end of table. In practice, this function does not check buffer but handles + /// verification statistics update + // (this method is used internally by generated verification functions) + public bool VerifyTableEnd(uint tablePos) + { + depth--; + return true; + } + + /// Verifiy static/inlined data area field + /// Position in the Table + /// Offset to the static/inlined data element + /// Size of the element + /// Alignment bool value + /// Required Value when the offset == 0 + /// Return True when the verification of the static/inlined data element is passed + // (this method is used internally by generated verification functions) + public bool VerifyField(uint tablePos, short offsetId, ulong elementSize, ulong align, bool required) + { + uint offset = GetVOffset(tablePos, offsetId); + if (offset != 0) + { + return ((CheckAlignment(offset, align)) && (CheckElement(offset, elementSize))); + } + return !required; // it is OK if field is not required + } + + /// Verify string + /// Position in the Table + /// Offset to the String element + /// Required Value when the offset == 0 + /// Return True when the verification of the String is passed + // (this method is used internally by generated verification functions) + public bool VerifyString(uint tablePos, short vOffset, bool required) + { + var offset = GetVOffset(tablePos, vOffset); + if (offset == 0) + { + return !required; + } + if (!CheckIndirectOffset(offset)) + { + return false; + } + var strOffset = GetIndirectOffset(offset); + return CheckString(strOffset); + } + + /// Verify vector of fixed size structures and scalars + /// Position in the Table + /// Offset to the Vector of Data + /// Size of the element + /// Required Value when the offset == 0 + /// Return True when the verification of the Vector of Data passed + // (this method is used internally by generated verification functions) + public bool VerifyVectorOfData(uint tablePos, short vOffset, ulong elementSize, bool required) + { + var offset = GetVOffset(tablePos, vOffset); + if (offset == 0) + { + return !required; + } + if (!CheckIndirectOffset(offset)) + { + return false; + } + var vecOffset = GetIndirectOffset(offset); + return CheckVector(vecOffset, elementSize); + } + + /// Verify array of strings + /// Position in the Table + /// Offset to the Vector of String + /// Required Value when the offset == 0 + /// Return True when the verification of the Vector of String passed + // (this method is used internally by generated verification functions) + public bool VerifyVectorOfStrings(uint tablePos, short offsetId, bool required) + { + var offset = GetVOffset(tablePos, offsetId); + if (offset == 0) + { + return !required; + } + if (!CheckIndirectOffset(offset)) + { + return false; + } + var vecOffset = GetIndirectOffset(offset); + return CheckVectorOfObjects(vecOffset, CheckStringFunc); + } + + /// Verify vector of tables (objects). Tables are verified using generated verifyObjFunc + /// Position in the Table + /// Offset to the Vector of Table + /// Method used to the verification Table + /// Required Value when the offset == 0 + /// Return True when the verification of the Vector of Table passed + // (this method is used internally by generated verification functions) + public bool VerifyVectorOfTables(uint tablePos, short offsetId, VerifyTableAction verifyAction, bool required) + { + var offset = GetVOffset(tablePos, offsetId); + if (offset == 0) + { + return !required; + } + if (!CheckIndirectOffset(offset)) + { + return false; + } + var vecOffset = GetIndirectOffset(offset); + return CheckVectorOfObjects(vecOffset, verifyAction); + } + + /// Verify table object using generated verification function. + /// Position in the Table + /// Offset to the Table + /// Method used to the verification Table + /// Required Value when the offset == 0 + /// Return True when the verification of the Table passed + // (this method is used internally by generated verification functions) + public bool VerifyTable(uint tablePos, short offsetId, VerifyTableAction verifyAction, bool required) + { + var offset = GetVOffset(tablePos, offsetId); + if (offset == 0) + { + return !required; + } + if (!CheckIndirectOffset(offset)) + { + return false; + } + var tabOffset = GetIndirectOffset(offset); + return CheckTable(tabOffset, verifyAction); + } + + /// Verify nested buffer object. When verifyObjFunc is provided, it is used to verify object structure. + /// Position in the Table + /// Offset to the Table + /// Method used to the verification Table + /// Required Value when the offset == 0 + // (this method is used internally by generated verification functions) + public bool VerifyNestedBuffer(uint tablePos, short offsetId, VerifyTableAction verifyAction, bool required) + { + var offset = GetVOffset(tablePos, offsetId); + if (offset == 0) + { + return !required; + } + uint vecOffset = GetIndirectOffset(offset); + if (!CheckVector(vecOffset, SIZE_BYTE)) + { + return false; + } + if (verifyAction != null) + { + var vecLength = ReadUOffsetT(verifier_buffer, vecOffset); + // Buffer begins after vector length + var vecStart = vecOffset + SIZE_U_OFFSET; + // Create and Copy nested buffer bytes from part of Verify Buffer + var nestedByteBuffer = new ByteBuffer(verifier_buffer.ToArray(Convert.ToInt32(vecStart), Convert.ToInt32(vecLength))); + var nestedVerifyier = new Verifier(nestedByteBuffer, options); + // There is no internal identifier - use empty one + if (!nestedVerifyier.CheckBufferFromStart("", 0, verifyAction)) + { + return false; + } + } + return true; + } + + /// Verifiy static/inlined data area at absolute offset + /// Position of static/inlined data area in the Byte Buffer + /// Size of the union data + /// Alignment bool value + /// Return True when the verification of the Union Data is passed + // (this method is used internally by generated verification functions) + public bool VerifyUnionData(uint pos, ulong elementSize, ulong align) + { + bool result = ((CheckAlignment(pos, align)) && (CheckElement(pos, elementSize))); + return result; + } + + /// Verify string referenced by absolute offset value + /// Position of Union String in the Byte Buffer + /// Return True when the verification of the Union String is passed + // (this method is used internally by generated verification functions) + public bool VerifyUnionString(uint pos) + { + bool result = CheckString(pos); + return result; + } + + /// Method verifies union object using generated verification function + /// Position in the Table + /// Offset in the Table + /// Offset to Element + /// Verification Method used for Union + /// Required Value when the offset == 0 + // (this method is used internally by generated verification functions) + public bool VerifyUnion(uint tablePos, short typeIdVOffset, short valueVOffset, VerifyUnionAction verifyAction, bool required) + { + // Check the union type index + var offset = GetVOffset(tablePos, typeIdVOffset); + if (offset == 0) + { + return !required; + } + if (!((CheckAlignment(offset, SIZE_BYTE)) && (CheckElement(offset, SIZE_BYTE)))) + { + return false; + } + // Check union data + offset = GetVOffset(tablePos, valueVOffset); + // Take type id + var typeId = verifier_buffer.Get(Convert.ToInt32(offset)); + if (offset == 0) + { + // When value data is not present, allow union verification function to deal with illegal offset + return verifyAction(this, typeId, Convert.ToUInt32(verifier_buffer.Length)); + } + if (!CheckIndirectOffset(offset)) + { + return false; + } + // Take value offset and validate union structure + uint unionOffset = GetIndirectOffset(offset); + return verifyAction(this, typeId, unionOffset); + } + + /// Verify vector of unions (objects). Unions are verified using generated verifyObjFunc + /// Position of the Table + /// Offset in the Table (Union type id) + /// Offset to vector of Data Stucture offset + /// Verification Method used for Union + /// Required Value when the offset == 0 + /// Return True when the verification of the Vector of Unions passed + // (this method is used internally by generated verification functions) + public bool VerifyVectorOfUnion(uint tablePos, short typeOffsetId, short offsetId, VerifyUnionAction verifyAction, bool required) + { + // type id offset must be valid + var offset = GetVOffset(tablePos, typeOffsetId); + if (offset == 0) + { + return !required; + } + if (!CheckIndirectOffset(offset)) + { + return false; + } + // Get type id table absolute offset + var typeIdVectorOffset = GetIndirectOffset(offset); + // values offset must be valid + offset = GetVOffset(tablePos, offsetId); + if (!CheckIndirectOffset(offset)) + { + return false; + } + var valueVectorOffset = GetIndirectOffset(offset); + // validate referenced vectors + if(!CheckVector(typeIdVectorOffset, SIZE_BYTE) || + !CheckVector(valueVectorOffset, SIZE_U_OFFSET)) + { + return false; + } + // Both vectors should have the same length + var typeIdVectorLength = ReadUOffsetT(verifier_buffer, typeIdVectorOffset); + var valueVectorLength = ReadUOffsetT(verifier_buffer, valueVectorOffset); + if (typeIdVectorLength != valueVectorLength) + { + return false; + } + // Verify each union from vectors + var typeIdStart = typeIdVectorOffset + SIZE_U_OFFSET; + var valueStart = valueVectorOffset + SIZE_U_OFFSET; + for (uint i = 0; i < typeIdVectorLength; i++) + { + // Get type id + byte typeId = verifier_buffer.Get(Convert.ToInt32(typeIdStart + i * SIZE_U_OFFSET)); + // get offset to vector item + uint off = valueStart + i * SIZE_U_OFFSET; + // Check the vector item has a proper offset + if (!CheckIndirectOffset(off)) + { + return false; + } + uint valueOffset = GetIndirectOffset(off); + // Verify object + if (!verifyAction(this, typeId, valueOffset)) + { + return false; + } + } + return true; + } + + // Method verifies flatbuffer data using generated Table verification function. + // The data buffer is already provided when creating [Verifier] object (see [NewVerifier]) + // + // - identifier - the expected identifier of buffer data. + // When empty identifier is provided the identifier validation is skipped. + // - sizePrefixed - this flag should be true when buffer is prefixed with content size + // - verifyObjFunc - function to be used for verification. This function is generated by compiler and included in each table definition file with name "Verify" + // + // Example: + // + // /* Verify Monster table. Ignore buffer name and assume buffer does not contain data length prefix */ + // isValid = verifier.verifyBuffer(bb, false, MonsterVerify) + // + // /* Verify Monster table. Buffer name is 'MONS' and contains data length prefix */ + // isValid = verifier.verifyBuffer("MONS", true, MonsterVerify) + /// Method verifies flatbuffer data using generated Table verification function + /// + /// The expected identifier of buffer data + /// Flag should be true when buffer is prefixed with content size + /// Function to be used for verification. This function is generated by compiler and included in each table definition file + /// Return True when verification of FlatBuffer passed + /// + /// Example 1. Verify Monster table. Ignore buffer name and assume buffer does not contain data length prefix + /// isValid = verifier.VerifyBuffer(bb, false, MonsterVerify) + /// Example 2. Verify Monster table. Buffer name is 'MONS' and contains data length prefix + /// isValid = verifier.VerifyBuffer("MONS", true, MonsterVerify) + /// + public bool VerifyBuffer(string identifier, bool sizePrefixed, VerifyTableAction verifyAction) + { + // Reset counters - starting verification from beginning + depth = 0; + numTables = 0; + + var start = (uint)(verifier_buffer.Position); + if (sizePrefixed) + { + start = (uint)(verifier_buffer.Position) + SIZE_PREFIX_LENGTH; + if(!CheckScalar((uint)(verifier_buffer.Position), SIZE_PREFIX_LENGTH)) + { + return false; + } + uint size = ReadUOffsetT(verifier_buffer, (uint)(verifier_buffer.Position)); + if (size != ((uint)(verifier_buffer.Length) - start)) + { + return false; + } + } + return CheckBufferFromStart(identifier, start, verifyAction); + } + } + +} diff --git a/net/FlatBuffers/FlatBuffers.net35.csproj b/net/FlatBuffers/FlatBuffers.net35.csproj index 574580e37..9c64d006e 100644 --- a/net/FlatBuffers/FlatBuffers.net35.csproj +++ b/net/FlatBuffers/FlatBuffers.net35.csproj @@ -40,9 +40,9 @@ + - diff --git a/net/FlatBuffers/Table.cs b/net/FlatBuffers/Table.cs index 21ef7dc8b..2aaa86e99 100644 --- a/net/FlatBuffers/Table.cs +++ b/net/FlatBuffers/Table.cs @@ -65,7 +65,11 @@ namespace Google.FlatBuffers // Create a .NET String from UTF-8 data stored inside the flatbuffer. public string __string(int offset) { - offset += bb.GetInt(offset); + int stringOffset = bb.GetInt(offset); + if (stringOffset == 0) + return null; + + offset += stringOffset; var len = bb.GetInt(offset); var startPos = offset + sizeof(int); return bb.GetStringUTF8(startPos, len); diff --git a/package.json b/package.json index 680ea02a4..505648fc8 100644 --- a/package.json +++ b/package.json @@ -37,11 +37,11 @@ "dependencies": {}, "devDependencies": { "@bazel/typescript": "5.2.0", - "@types/node": "18.7.16", - "@typescript-eslint/eslint-plugin": "^5.46.0", - "@typescript-eslint/parser": "^5.46.0", - "esbuild": "^0.16.4", - "eslint": "^8.29.0", - "typescript": "^4.8.3" + "@types/node": "18.15.11", + "@typescript-eslint/eslint-plugin": "^5.57.0", + "@typescript-eslint/parser": "^5.57.0", + "esbuild": "^0.17.14", + "eslint": "^8.37.0", + "typescript": "^5.0.3" } } diff --git a/python/flatbuffers/reflection/Enum.py b/python/flatbuffers/reflection/Enum.py index b27e4102c..bd2a7b336 100644 --- a/python/flatbuffers/reflection/Enum.py +++ b/python/flatbuffers/reflection/Enum.py @@ -131,39 +131,74 @@ class Enum(object): return self._tab.String(o + self._tab.Pos) return None -def EnumStart(builder): builder.StartObject(7) +def EnumStart(builder): + return builder.StartObject(7) + def Start(builder): return EnumStart(builder) -def EnumAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + +def EnumAddName(builder, name): + return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + def AddName(builder, name): return EnumAddName(builder, name) -def EnumAddValues(builder, values): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0) + +def EnumAddValues(builder, values): + return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0) + def AddValues(builder, values): return EnumAddValues(builder, values) -def EnumStartValuesVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def EnumStartValuesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartValuesVector(builder, numElems): return EnumStartValuesVector(builder, numElems) -def EnumAddIsUnion(builder, isUnion): builder.PrependBoolSlot(2, isUnion, 0) + +def EnumAddIsUnion(builder, isUnion): + return builder.PrependBoolSlot(2, isUnion, 0) + def AddIsUnion(builder, isUnion): return EnumAddIsUnion(builder, isUnion) -def EnumAddUnderlyingType(builder, underlyingType): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(underlyingType), 0) + +def EnumAddUnderlyingType(builder, underlyingType): + return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(underlyingType), 0) + def AddUnderlyingType(builder, underlyingType): return EnumAddUnderlyingType(builder, underlyingType) -def EnumAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) + +def EnumAddAttributes(builder, attributes): + return builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) + def AddAttributes(builder, attributes): return EnumAddAttributes(builder, attributes) -def EnumStartAttributesVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def EnumStartAttributesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartAttributesVector(builder, numElems): return EnumStartAttributesVector(builder, numElems) -def EnumAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) + +def EnumAddDocumentation(builder, documentation): + return builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) + def AddDocumentation(builder, documentation): return EnumAddDocumentation(builder, documentation) -def EnumStartDocumentationVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def EnumStartDocumentationVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartDocumentationVector(builder, numElems): return EnumStartDocumentationVector(builder, numElems) -def EnumAddDeclarationFile(builder, declarationFile): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0) + +def EnumAddDeclarationFile(builder, declarationFile): + return builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0) + def AddDeclarationFile(builder, declarationFile): return EnumAddDeclarationFile(builder, declarationFile) -def EnumEnd(builder): return builder.EndObject() + +def EnumEnd(builder): + return builder.EndObject() + def End(builder): - return EnumEnd(builder) \ No newline at end of file + return EnumEnd(builder) diff --git a/python/flatbuffers/reflection/EnumVal.py b/python/flatbuffers/reflection/EnumVal.py index 3592de08c..7019ec46d 100644 --- a/python/flatbuffers/reflection/EnumVal.py +++ b/python/flatbuffers/reflection/EnumVal.py @@ -98,30 +98,56 @@ class EnumVal(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) return o == 0 -def EnumValStart(builder): builder.StartObject(6) +def EnumValStart(builder): + return builder.StartObject(6) + def Start(builder): return EnumValStart(builder) -def EnumValAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + +def EnumValAddName(builder, name): + return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + def AddName(builder, name): return EnumValAddName(builder, name) -def EnumValAddValue(builder, value): builder.PrependInt64Slot(1, value, 0) + +def EnumValAddValue(builder, value): + return builder.PrependInt64Slot(1, value, 0) + def AddValue(builder, value): return EnumValAddValue(builder, value) -def EnumValAddUnionType(builder, unionType): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(unionType), 0) + +def EnumValAddUnionType(builder, unionType): + return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(unionType), 0) + def AddUnionType(builder, unionType): return EnumValAddUnionType(builder, unionType) -def EnumValAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) + +def EnumValAddDocumentation(builder, documentation): + return builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) + def AddDocumentation(builder, documentation): return EnumValAddDocumentation(builder, documentation) -def EnumValStartDocumentationVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def EnumValStartDocumentationVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartDocumentationVector(builder, numElems): return EnumValStartDocumentationVector(builder, numElems) -def EnumValAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) + +def EnumValAddAttributes(builder, attributes): + return builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) + def AddAttributes(builder, attributes): return EnumValAddAttributes(builder, attributes) -def EnumValStartAttributesVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def EnumValStartAttributesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartAttributesVector(builder, numElems): return EnumValStartAttributesVector(builder, numElems) -def EnumValEnd(builder): return builder.EndObject() + +def EnumValEnd(builder): + return builder.EndObject() + def End(builder): - return EnumValEnd(builder) \ No newline at end of file + return EnumValEnd(builder) diff --git a/python/flatbuffers/reflection/Field.py b/python/flatbuffers/reflection/Field.py index 01b52808a..a0e660fd6 100644 --- a/python/flatbuffers/reflection/Field.py +++ b/python/flatbuffers/reflection/Field.py @@ -155,54 +155,104 @@ class Field(object): return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) return 0 -def FieldStart(builder): builder.StartObject(13) +def FieldStart(builder): + return builder.StartObject(13) + def Start(builder): return FieldStart(builder) -def FieldAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + +def FieldAddName(builder, name): + return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + def AddName(builder, name): return FieldAddName(builder, name) -def FieldAddType(builder, type): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(type), 0) + +def FieldAddType(builder, type): + return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(type), 0) + def AddType(builder, type): return FieldAddType(builder, type) -def FieldAddId(builder, id): builder.PrependUint16Slot(2, id, 0) + +def FieldAddId(builder, id): + return builder.PrependUint16Slot(2, id, 0) + def AddId(builder, id): return FieldAddId(builder, id) -def FieldAddOffset(builder, offset): builder.PrependUint16Slot(3, offset, 0) + +def FieldAddOffset(builder, offset): + return builder.PrependUint16Slot(3, offset, 0) + def AddOffset(builder, offset): return FieldAddOffset(builder, offset) -def FieldAddDefaultInteger(builder, defaultInteger): builder.PrependInt64Slot(4, defaultInteger, 0) + +def FieldAddDefaultInteger(builder, defaultInteger): + return builder.PrependInt64Slot(4, defaultInteger, 0) + def AddDefaultInteger(builder, defaultInteger): return FieldAddDefaultInteger(builder, defaultInteger) -def FieldAddDefaultReal(builder, defaultReal): builder.PrependFloat64Slot(5, defaultReal, 0.0) + +def FieldAddDefaultReal(builder, defaultReal): + return builder.PrependFloat64Slot(5, defaultReal, 0.0) + def AddDefaultReal(builder, defaultReal): return FieldAddDefaultReal(builder, defaultReal) -def FieldAddDeprecated(builder, deprecated): builder.PrependBoolSlot(6, deprecated, 0) + +def FieldAddDeprecated(builder, deprecated): + return builder.PrependBoolSlot(6, deprecated, 0) + def AddDeprecated(builder, deprecated): return FieldAddDeprecated(builder, deprecated) -def FieldAddRequired(builder, required): builder.PrependBoolSlot(7, required, 0) + +def FieldAddRequired(builder, required): + return builder.PrependBoolSlot(7, required, 0) + def AddRequired(builder, required): return FieldAddRequired(builder, required) -def FieldAddKey(builder, key): builder.PrependBoolSlot(8, key, 0) + +def FieldAddKey(builder, key): + return builder.PrependBoolSlot(8, key, 0) + def AddKey(builder, key): return FieldAddKey(builder, key) -def FieldAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) + +def FieldAddAttributes(builder, attributes): + return builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) + def AddAttributes(builder, attributes): return FieldAddAttributes(builder, attributes) -def FieldStartAttributesVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def FieldStartAttributesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartAttributesVector(builder, numElems): return FieldStartAttributesVector(builder, numElems) -def FieldAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) + +def FieldAddDocumentation(builder, documentation): + return builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) + def AddDocumentation(builder, documentation): return FieldAddDocumentation(builder, documentation) -def FieldStartDocumentationVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def FieldStartDocumentationVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartDocumentationVector(builder, numElems): return FieldStartDocumentationVector(builder, numElems) -def FieldAddOptional(builder, optional): builder.PrependBoolSlot(11, optional, 0) + +def FieldAddOptional(builder, optional): + return builder.PrependBoolSlot(11, optional, 0) + def AddOptional(builder, optional): return FieldAddOptional(builder, optional) -def FieldAddPadding(builder, padding): builder.PrependUint16Slot(12, padding, 0) + +def FieldAddPadding(builder, padding): + return builder.PrependUint16Slot(12, padding, 0) + def AddPadding(builder, padding): return FieldAddPadding(builder, padding) -def FieldEnd(builder): return builder.EndObject() + +def FieldEnd(builder): + return builder.EndObject() + def End(builder): - return FieldEnd(builder) \ No newline at end of file + return FieldEnd(builder) diff --git a/python/flatbuffers/reflection/KeyValue.py b/python/flatbuffers/reflection/KeyValue.py index dde37dff8..7b24a76e5 100644 --- a/python/flatbuffers/reflection/KeyValue.py +++ b/python/flatbuffers/reflection/KeyValue.py @@ -42,15 +42,26 @@ class KeyValue(object): return self._tab.String(o + self._tab.Pos) return None -def KeyValueStart(builder): builder.StartObject(2) +def KeyValueStart(builder): + return builder.StartObject(2) + def Start(builder): return KeyValueStart(builder) -def KeyValueAddKey(builder, key): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0) + +def KeyValueAddKey(builder, key): + return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0) + def AddKey(builder, key): return KeyValueAddKey(builder, key) -def KeyValueAddValue(builder, value): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(value), 0) + +def KeyValueAddValue(builder, value): + return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(value), 0) + def AddValue(builder, value): return KeyValueAddValue(builder, value) -def KeyValueEnd(builder): return builder.EndObject() + +def KeyValueEnd(builder): + return builder.EndObject() + def End(builder): - return KeyValueEnd(builder) \ No newline at end of file + return KeyValueEnd(builder) diff --git a/python/flatbuffers/reflection/Object.py b/python/flatbuffers/reflection/Object.py index 598927c8a..f890ffbc1 100644 --- a/python/flatbuffers/reflection/Object.py +++ b/python/flatbuffers/reflection/Object.py @@ -134,42 +134,80 @@ class Object(object): return self._tab.String(o + self._tab.Pos) return None -def ObjectStart(builder): builder.StartObject(8) +def ObjectStart(builder): + return builder.StartObject(8) + def Start(builder): return ObjectStart(builder) -def ObjectAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + +def ObjectAddName(builder, name): + return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + def AddName(builder, name): return ObjectAddName(builder, name) -def ObjectAddFields(builder, fields): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(fields), 0) + +def ObjectAddFields(builder, fields): + return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(fields), 0) + def AddFields(builder, fields): return ObjectAddFields(builder, fields) -def ObjectStartFieldsVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def ObjectStartFieldsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartFieldsVector(builder, numElems): return ObjectStartFieldsVector(builder, numElems) -def ObjectAddIsStruct(builder, isStruct): builder.PrependBoolSlot(2, isStruct, 0) + +def ObjectAddIsStruct(builder, isStruct): + return builder.PrependBoolSlot(2, isStruct, 0) + def AddIsStruct(builder, isStruct): return ObjectAddIsStruct(builder, isStruct) -def ObjectAddMinalign(builder, minalign): builder.PrependInt32Slot(3, minalign, 0) + +def ObjectAddMinalign(builder, minalign): + return builder.PrependInt32Slot(3, minalign, 0) + def AddMinalign(builder, minalign): return ObjectAddMinalign(builder, minalign) -def ObjectAddBytesize(builder, bytesize): builder.PrependInt32Slot(4, bytesize, 0) + +def ObjectAddBytesize(builder, bytesize): + return builder.PrependInt32Slot(4, bytesize, 0) + def AddBytesize(builder, bytesize): return ObjectAddBytesize(builder, bytesize) -def ObjectAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) + +def ObjectAddAttributes(builder, attributes): + return builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) + def AddAttributes(builder, attributes): return ObjectAddAttributes(builder, attributes) -def ObjectStartAttributesVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def ObjectStartAttributesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartAttributesVector(builder, numElems): return ObjectStartAttributesVector(builder, numElems) -def ObjectAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) + +def ObjectAddDocumentation(builder, documentation): + return builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) + def AddDocumentation(builder, documentation): return ObjectAddDocumentation(builder, documentation) -def ObjectStartDocumentationVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def ObjectStartDocumentationVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartDocumentationVector(builder, numElems): return ObjectStartDocumentationVector(builder, numElems) -def ObjectAddDeclarationFile(builder, declarationFile): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0) + +def ObjectAddDeclarationFile(builder, declarationFile): + return builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0) + def AddDeclarationFile(builder, declarationFile): return ObjectAddDeclarationFile(builder, declarationFile) -def ObjectEnd(builder): return builder.EndObject() + +def ObjectEnd(builder): + return builder.EndObject() + def End(builder): - return ObjectEnd(builder) \ No newline at end of file + return ObjectEnd(builder) diff --git a/python/flatbuffers/reflection/RPCCall.py b/python/flatbuffers/reflection/RPCCall.py index 9fdbf468b..b126f04e4 100644 --- a/python/flatbuffers/reflection/RPCCall.py +++ b/python/flatbuffers/reflection/RPCCall.py @@ -102,30 +102,56 @@ class RPCCall(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) return o == 0 -def RPCCallStart(builder): builder.StartObject(5) +def RPCCallStart(builder): + return builder.StartObject(5) + def Start(builder): return RPCCallStart(builder) -def RPCCallAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + +def RPCCallAddName(builder, name): + return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + def AddName(builder, name): return RPCCallAddName(builder, name) -def RPCCallAddRequest(builder, request): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(request), 0) + +def RPCCallAddRequest(builder, request): + return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(request), 0) + def AddRequest(builder, request): return RPCCallAddRequest(builder, request) -def RPCCallAddResponse(builder, response): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(response), 0) + +def RPCCallAddResponse(builder, response): + return builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(response), 0) + def AddResponse(builder, response): return RPCCallAddResponse(builder, response) -def RPCCallAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) + +def RPCCallAddAttributes(builder, attributes): + return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) + def AddAttributes(builder, attributes): return RPCCallAddAttributes(builder, attributes) -def RPCCallStartAttributesVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def RPCCallStartAttributesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartAttributesVector(builder, numElems): return RPCCallStartAttributesVector(builder, numElems) -def RPCCallAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) + +def RPCCallAddDocumentation(builder, documentation): + return builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) + def AddDocumentation(builder, documentation): return RPCCallAddDocumentation(builder, documentation) -def RPCCallStartDocumentationVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def RPCCallStartDocumentationVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartDocumentationVector(builder, numElems): return RPCCallStartDocumentationVector(builder, numElems) -def RPCCallEnd(builder): return builder.EndObject() + +def RPCCallEnd(builder): + return builder.EndObject() + def End(builder): - return RPCCallEnd(builder) \ No newline at end of file + return RPCCallEnd(builder) diff --git a/python/flatbuffers/reflection/Schema.py b/python/flatbuffers/reflection/Schema.py index df2f072f9..d7929a49b 100644 --- a/python/flatbuffers/reflection/Schema.py +++ b/python/flatbuffers/reflection/Schema.py @@ -162,45 +162,86 @@ class Schema(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) return o == 0 -def SchemaStart(builder): builder.StartObject(8) +def SchemaStart(builder): + return builder.StartObject(8) + def Start(builder): return SchemaStart(builder) -def SchemaAddObjects(builder, objects): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(objects), 0) + +def SchemaAddObjects(builder, objects): + return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(objects), 0) + def AddObjects(builder, objects): return SchemaAddObjects(builder, objects) -def SchemaStartObjectsVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def SchemaStartObjectsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartObjectsVector(builder, numElems): return SchemaStartObjectsVector(builder, numElems) -def SchemaAddEnums(builder, enums): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(enums), 0) + +def SchemaAddEnums(builder, enums): + return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(enums), 0) + def AddEnums(builder, enums): return SchemaAddEnums(builder, enums) -def SchemaStartEnumsVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def SchemaStartEnumsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartEnumsVector(builder, numElems): return SchemaStartEnumsVector(builder, numElems) -def SchemaAddFileIdent(builder, fileIdent): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(fileIdent), 0) + +def SchemaAddFileIdent(builder, fileIdent): + return builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(fileIdent), 0) + def AddFileIdent(builder, fileIdent): return SchemaAddFileIdent(builder, fileIdent) -def SchemaAddFileExt(builder, fileExt): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(fileExt), 0) + +def SchemaAddFileExt(builder, fileExt): + return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(fileExt), 0) + def AddFileExt(builder, fileExt): return SchemaAddFileExt(builder, fileExt) -def SchemaAddRootTable(builder, rootTable): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(rootTable), 0) + +def SchemaAddRootTable(builder, rootTable): + return builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(rootTable), 0) + def AddRootTable(builder, rootTable): return SchemaAddRootTable(builder, rootTable) -def SchemaAddServices(builder, services): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(services), 0) + +def SchemaAddServices(builder, services): + return builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(services), 0) + def AddServices(builder, services): return SchemaAddServices(builder, services) -def SchemaStartServicesVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def SchemaStartServicesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartServicesVector(builder, numElems): return SchemaStartServicesVector(builder, numElems) -def SchemaAddAdvancedFeatures(builder, advancedFeatures): builder.PrependUint64Slot(6, advancedFeatures, 0) + +def SchemaAddAdvancedFeatures(builder, advancedFeatures): + return builder.PrependUint64Slot(6, advancedFeatures, 0) + def AddAdvancedFeatures(builder, advancedFeatures): return SchemaAddAdvancedFeatures(builder, advancedFeatures) -def SchemaAddFbsFiles(builder, fbsFiles): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(fbsFiles), 0) + +def SchemaAddFbsFiles(builder, fbsFiles): + return builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(fbsFiles), 0) + def AddFbsFiles(builder, fbsFiles): return SchemaAddFbsFiles(builder, fbsFiles) -def SchemaStartFbsFilesVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def SchemaStartFbsFilesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartFbsFilesVector(builder, numElems): return SchemaStartFbsFilesVector(builder, numElems) -def SchemaEnd(builder): return builder.EndObject() + +def SchemaEnd(builder): + return builder.EndObject() + def End(builder): - return SchemaEnd(builder) \ No newline at end of file + return SchemaEnd(builder) diff --git a/python/flatbuffers/reflection/SchemaFile.py b/python/flatbuffers/reflection/SchemaFile.py index 890fd3b53..d4c817862 100644 --- a/python/flatbuffers/reflection/SchemaFile.py +++ b/python/flatbuffers/reflection/SchemaFile.py @@ -60,18 +60,32 @@ class SchemaFile(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) return o == 0 -def SchemaFileStart(builder): builder.StartObject(2) +def SchemaFileStart(builder): + return builder.StartObject(2) + def Start(builder): return SchemaFileStart(builder) -def SchemaFileAddFilename(builder, filename): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(filename), 0) + +def SchemaFileAddFilename(builder, filename): + return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(filename), 0) + def AddFilename(builder, filename): return SchemaFileAddFilename(builder, filename) -def SchemaFileAddIncludedFilenames(builder, includedFilenames): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(includedFilenames), 0) + +def SchemaFileAddIncludedFilenames(builder, includedFilenames): + return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(includedFilenames), 0) + def AddIncludedFilenames(builder, includedFilenames): return SchemaFileAddIncludedFilenames(builder, includedFilenames) -def SchemaFileStartIncludedFilenamesVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def SchemaFileStartIncludedFilenamesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartIncludedFilenamesVector(builder, numElems): return SchemaFileStartIncludedFilenamesVector(builder, numElems) -def SchemaFileEnd(builder): return builder.EndObject() + +def SchemaFileEnd(builder): + return builder.EndObject() + def End(builder): - return SchemaFileEnd(builder) \ No newline at end of file + return SchemaFileEnd(builder) diff --git a/python/flatbuffers/reflection/Service.py b/python/flatbuffers/reflection/Service.py index d4f1a6a8e..eaec60af1 100644 --- a/python/flatbuffers/reflection/Service.py +++ b/python/flatbuffers/reflection/Service.py @@ -113,33 +113,62 @@ class Service(object): return self._tab.String(o + self._tab.Pos) return None -def ServiceStart(builder): builder.StartObject(5) +def ServiceStart(builder): + return builder.StartObject(5) + def Start(builder): return ServiceStart(builder) -def ServiceAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + +def ServiceAddName(builder, name): + return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + def AddName(builder, name): return ServiceAddName(builder, name) -def ServiceAddCalls(builder, calls): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(calls), 0) + +def ServiceAddCalls(builder, calls): + return builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(calls), 0) + def AddCalls(builder, calls): return ServiceAddCalls(builder, calls) -def ServiceStartCallsVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def ServiceStartCallsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartCallsVector(builder, numElems): return ServiceStartCallsVector(builder, numElems) -def ServiceAddAttributes(builder, attributes): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) + +def ServiceAddAttributes(builder, attributes): + return builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0) + def AddAttributes(builder, attributes): return ServiceAddAttributes(builder, attributes) -def ServiceStartAttributesVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def ServiceStartAttributesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartAttributesVector(builder, numElems): return ServiceStartAttributesVector(builder, numElems) -def ServiceAddDocumentation(builder, documentation): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) + +def ServiceAddDocumentation(builder, documentation): + return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0) + def AddDocumentation(builder, documentation): return ServiceAddDocumentation(builder, documentation) -def ServiceStartDocumentationVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def ServiceStartDocumentationVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartDocumentationVector(builder, numElems): return ServiceStartDocumentationVector(builder, numElems) -def ServiceAddDeclarationFile(builder, declarationFile): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0) + +def ServiceAddDeclarationFile(builder, declarationFile): + return builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0) + def AddDeclarationFile(builder, declarationFile): return ServiceAddDeclarationFile(builder, declarationFile) -def ServiceEnd(builder): return builder.EndObject() + +def ServiceEnd(builder): + return builder.EndObject() + def End(builder): - return ServiceEnd(builder) \ No newline at end of file + return ServiceEnd(builder) diff --git a/python/flatbuffers/reflection/Type.py b/python/flatbuffers/reflection/Type.py index d606ab9ac..eb58dd8a0 100644 --- a/python/flatbuffers/reflection/Type.py +++ b/python/flatbuffers/reflection/Type.py @@ -72,27 +72,50 @@ class Type(object): return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) return 0 -def TypeStart(builder): builder.StartObject(6) +def TypeStart(builder): + return builder.StartObject(6) + def Start(builder): return TypeStart(builder) -def TypeAddBaseType(builder, baseType): builder.PrependInt8Slot(0, baseType, 0) + +def TypeAddBaseType(builder, baseType): + return builder.PrependInt8Slot(0, baseType, 0) + def AddBaseType(builder, baseType): return TypeAddBaseType(builder, baseType) -def TypeAddElement(builder, element): builder.PrependInt8Slot(1, element, 0) + +def TypeAddElement(builder, element): + return builder.PrependInt8Slot(1, element, 0) + def AddElement(builder, element): return TypeAddElement(builder, element) -def TypeAddIndex(builder, index): builder.PrependInt32Slot(2, index, -1) + +def TypeAddIndex(builder, index): + return builder.PrependInt32Slot(2, index, -1) + def AddIndex(builder, index): return TypeAddIndex(builder, index) -def TypeAddFixedLength(builder, fixedLength): builder.PrependUint16Slot(3, fixedLength, 0) + +def TypeAddFixedLength(builder, fixedLength): + return builder.PrependUint16Slot(3, fixedLength, 0) + def AddFixedLength(builder, fixedLength): return TypeAddFixedLength(builder, fixedLength) -def TypeAddBaseSize(builder, baseSize): builder.PrependUint32Slot(4, baseSize, 4) + +def TypeAddBaseSize(builder, baseSize): + return builder.PrependUint32Slot(4, baseSize, 4) + def AddBaseSize(builder, baseSize): return TypeAddBaseSize(builder, baseSize) -def TypeAddElementSize(builder, elementSize): builder.PrependUint32Slot(5, elementSize, 0) + +def TypeAddElementSize(builder, elementSize): + return builder.PrependUint32Slot(5, elementSize, 0) + def AddElementSize(builder, elementSize): return TypeAddElementSize(builder, elementSize) -def TypeEnd(builder): return builder.EndObject() + +def TypeEnd(builder): + return builder.EndObject() + def End(builder): - return TypeEnd(builder) \ No newline at end of file + return TypeEnd(builder) diff --git a/samples/go.mod b/samples/go.mod new file mode 100644 index 000000000..c8f892b81 --- /dev/null +++ b/samples/go.mod @@ -0,0 +1,7 @@ +module github.com/google/flatbuffers/samples + +go 1.20 + +replace github.com/google/flatbuffers/go => ./go_gen + +require github.com/google/flatbuffers/go v0.0.0-00010101000000-000000000000 diff --git a/samples/go_sample.sh b/samples/go_sample.sh index 13a96c129..9ccd48ed1 100755 --- a/samples/go_sample.sh +++ b/samples/go_sample.sh @@ -41,23 +41,18 @@ fi echo Compiling and running the Go sample. -# Go requires a particular layout of files in order to link the necessary -# packages. Copy these files to the respective directores to compile the -# sample. -mkdir -p ${sampledir}/go_gen/src/MyGame/Sample -mkdir -p ${sampledir}/go_gen/src/github.com/google/flatbuffers/go -cp MyGame/Sample/*.go ${sampledir}/go_gen/src/MyGame/Sample/ -cp ${sampledir}/../go/* ${sampledir}/go_gen/src/github.com/google/flatbuffers/go - -# Export the `GOPATH`, so that `go` will know which directories to search for -# the libraries. -export GOPATH=${sampledir}/go_gen/ +# Workaround for https://github.com/google/flatbuffers/issues/7780: +# go mod replace requires a go.mod file in the target directory, +# but there currently isn't one in the ../go directory. +# So we copy the ../go directory to go_gen and manually create go_gen/go.mod +mkdir -p ${sampledir}/go_gen +cp ${sampledir}/../go/* ${sampledir}/go_gen +( cd ${sampledir}/go_gen && go mod init github.com/google/flatbuffers/go ) # Compile and execute the sample. go build -o go_sample sample_binary.go ./go_sample # Clean up the temporary files. -rm -rf MyGame/ rm -rf ${sampledir}/go_gen/ rm go_sample diff --git a/samples/sample_binary.go b/samples/sample_binary.go index e04650be6..7b7efac2e 100644 --- a/samples/sample_binary.go +++ b/samples/sample_binary.go @@ -19,7 +19,7 @@ package main import ( - sample "MyGame/Sample" + sample "github.com/google/flatbuffers/samples/MyGame/Sample" "fmt" flatbuffers "github.com/google/flatbuffers/go" "strconv" diff --git a/src/BUILD.bazel b/src/BUILD.bazel index 66c355d70..28d0868ce 100644 --- a/src/BUILD.bazel +++ b/src/BUILD.bazel @@ -69,6 +69,9 @@ cc_library( "bfbs_gen_nim.cpp", "bfbs_gen_nim.h", "bfbs_namer.h", + "file_binary_writer.cpp", + "file_name_saving_file_manager.cpp", + "file_writer.cpp", "flatc_main.cpp", "idl_gen_binary.cpp", "idl_gen_binary.h", diff --git a/src/file_binary_writer.cpp b/src/file_binary_writer.cpp new file mode 100644 index 000000000..69d83e77c --- /dev/null +++ b/src/file_binary_writer.cpp @@ -0,0 +1,49 @@ +/* + * Copyright 2023 Google Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include + +#include "flatbuffers/file_manager.h" + +namespace flatbuffers { + +class FileBinaryWriter : public FileManager { + public: + bool SaveFile(const std::string &absolute_file_name, + const std::string &content) override { + std::ofstream ofs(absolute_file_name, std::ofstream::binary); + if (!ofs.is_open()) return false; + ofs.write(content.c_str(), content.size()); + return !ofs.bad(); + } + + bool Loadfile(const std::string &absolute_file_name, std::string *output) { + if (DirExists(absolute_file_name.c_str())) return false; + std::ifstream ifs(absolute_file_name, std::ifstream::binary); + if (!ifs.is_open()) return false; + // The fastest way to read a file into a string. + ifs.seekg(0, std::ios::end); + auto size = ifs.tellg(); + (*output).resize(static_cast(size)); + ifs.seekg(0, std::ios::beg); + ifs.read(&(*output)[0], (*output).size()); + return !ifs.bad(); + } +}; + +} // namespace flatbuffers diff --git a/src/file_name_saving_file_manager.cpp b/src/file_name_saving_file_manager.cpp new file mode 100644 index 000000000..fc4a4aa1e --- /dev/null +++ b/src/file_name_saving_file_manager.cpp @@ -0,0 +1,49 @@ +/* + * Copyright 2023 Google Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include + +#include "flatbuffers/file_manager.h" + +namespace flatbuffers { + +class FileNameSavingFileManager : public FileManager { + public: + FileNameSavingFileManager(std::set file_names) + : file_names_(file_names) {} + + bool SaveFile(const std::string &absolute_file_name, + const std::string &content) override { + (void)content; + auto pair = file_names_.insert(absolute_file_name); + // pair.second indicates whether the insertion is + // successful or not. + return pair.second; + } + + bool Loadfile(const std::string &absolute_file_name, std::string *content) { + (void) absolute_file_name; + (void) content; + return false; + } + + private: + std::set file_names_; +}; + +} // namespace flatbuffers diff --git a/src/file_writer.cpp b/src/file_writer.cpp new file mode 100644 index 000000000..bd34545b0 --- /dev/null +++ b/src/file_writer.cpp @@ -0,0 +1,47 @@ +/* + * Copyright 2023 Google Inc. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include + +#include "flatbuffers/file_manager.h" + +namespace flatbuffers { + +class FileWriter : public FileManager { + public: + bool SaveFile(const std::string &absolute_file_name, + const std::string &content) override { + std::ofstream ofs(absolute_file_name, std::ofstream::out); + if (!ofs.is_open()) return false; + ofs.write(content.c_str(), content.size()); + return !ofs.bad(); + } + + bool Loadfile(const std::string &absolute_file_name, std::string *output) { + if (DirExists(absolute_file_name.c_str())) return false; + std::ifstream ifs(absolute_file_name, std::ifstream::in); + if (!ifs.is_open()) return false; + // This is slower, but works correctly on all platforms for text files. + std::ostringstream oss; + oss << ifs.rdbuf(); + *output = oss.str(); + return !ifs.bad(); + } +}; + +} // namespace flatbuffers diff --git a/src/flatc.cpp b/src/flatc.cpp index 1cdfc3c16..0e20a2f7d 100644 --- a/src/flatc.cpp +++ b/src/flatc.cpp @@ -250,6 +250,10 @@ const static FlatCOption flatc_options[] = { { "", "no-leak-private-annotation", "", "Prevents multiple type of annotations within a Fbs SCHEMA file. " "Currently this is required to generate private types in Rust" }, + { "", "python-no-type-prefix-suffix", "", + "Skip emission of Python functions that are prefixed with typenames" }, + { "", "file-names-only", "", + "Print out generated file names without writing to the files"}, }; auto cmp = [](FlatCOption a, FlatCOption b) { return a.long_opt < b.long_opt; }; @@ -648,11 +652,16 @@ FlatCOptions FlatCompiler::ParseFromCommandLineArguments(int argc, opts.ts_no_import_ext = true; } else if (arg == "--no-leak-private-annotation") { opts.no_leak_private_annotations = true; - } else if (arg == "--annotate-sparse-vectors") { + } else if (arg == "--python-no-type-prefix-suffix") { + opts.python_no_type_prefix_suffix = true; + } else if (arg == "--annotate-sparse-vectors") { options.annotate_include_vector_contents = false; } else if (arg == "--annotate") { if (++argi >= argc) Error("missing path following: " + arg, true); options.annotate_schema = flatbuffers::PosixPath(argv[argi]); + } else if(arg == "--file-names-only") { + // TODO (khhn): Provide 2 implementation + options.file_names_only = true; } else { if (arg == "--proto") { opts.proto_mode = true; } diff --git a/src/idl_gen_csharp.cpp b/src/idl_gen_csharp.cpp index a2dc5611e..8b1fafdf5 100644 --- a/src/idl_gen_csharp.cpp +++ b/src/idl_gen_csharp.cpp @@ -169,6 +169,7 @@ class CSharpGenerator : public BaseGenerator { if (!parser_.opts.one_file) cur_name_space_ = struct_def.defined_namespace; GenStruct(struct_def, &declcode, parser_.opts); + GenStructVerifier(struct_def, &declcode); if (parser_.opts.one_file) { one_file_code += declcode; } else { @@ -623,6 +624,173 @@ class CSharpGenerator : public BaseGenerator { ")"; } + // Get the value of a table verification function start + void GetStartOfTableVerifier(const StructDef &struct_def, std::string *code_ptr) { + std::string &code = *code_ptr; + code += "\n"; + code += "static public class " + struct_def.name + "Verify\n"; + code += "{\n"; + code += " static public bool Verify"; + code += "(Google.FlatBuffers.Verifier verifier, uint tablePos)\n"; + code += " {\n"; + code += " return verifier.VerifyTableStart(tablePos)\n"; + } + + // Get the value of a table verification function end + void GetEndOfTableVerifier(std::string *code_ptr) { + std::string &code = *code_ptr; + code += " && verifier.VerifyTableEnd(tablePos);\n"; + code += " }\n"; + code += "}\n"; + } + + std::string GetNestedFlatBufferName(const FieldDef &field) { + std::string name; + if (field.nested_flatbuffer) { + name = NamespacedName(*field.nested_flatbuffer); + } else { + name = ""; + } + return name ; + } + + // Generate the code to call the appropriate Verify function(s) for a field. + void GenVerifyCall(CodeWriter &code_, const FieldDef &field, const char *prefix) { + code_.SetValue("PRE", prefix); + code_.SetValue("NAME", ConvertCase(field.name, Case::kUpperCamel)); + code_.SetValue("REQUIRED", field.IsRequired() ? "Required" : ""); + code_.SetValue("REQUIRED_FLAG", field.IsRequired() ? "true" : "false"); + code_.SetValue("TYPE", GenTypeGet(field.value.type)); + code_.SetValue("INLINESIZE", NumToString(InlineSize(field.value.type))); + code_.SetValue("OFFSET", NumToString(field.value.offset)); + + if (IsScalar(field.value.type.base_type) || IsStruct(field.value.type)) { + code_.SetValue("ALIGN", NumToString(InlineAlignment(field.value.type))); + code_ += + "{{PRE}} && verifier.VerifyField(tablePos, " + "{{OFFSET}} /*{{NAME}}*/, {{INLINESIZE}} /*{{TYPE}}*/, {{ALIGN}}, {{REQUIRED_FLAG}})"; + } else { + // TODO - probably code below should go to this 'else' - code_ += "{{PRE}}VerifyOffset{{REQUIRED}}(verifier, {{OFFSET}})\\"; + } + + switch (field.value.type.base_type) { + case BASE_TYPE_UNION: { + auto union_name = NamespacedName(*field.value.type.enum_def); + code_.SetValue("ENUM_NAME1", field.value.type.enum_def->name); + code_.SetValue("ENUM_NAME", union_name); + code_.SetValue("SUFFIX", UnionTypeFieldSuffix()); + // Caution: This construction assumes, that UNION type id element has been created just before union data and + // its offset precedes union. Such assumption is common in flatbuffer implementation + code_.SetValue("TYPE_ID_OFFSET", NumToString(field.value.offset - sizeof(voffset_t))); + code_ += "{{PRE}} && verifier.VerifyUnion(tablePos, {{TYPE_ID_OFFSET}}, " + "{{OFFSET}} /*{{NAME}}*/, {{ENUM_NAME}}Verify.Verify, {{REQUIRED_FLAG}})"; + break; + } + case BASE_TYPE_STRUCT: { + if (!field.value.type.struct_def->fixed) { + code_ += "{{PRE}} && verifier.VerifyTable(tablePos, " + "{{OFFSET}} /*{{NAME}}*/, {{TYPE}}Verify.Verify, {{REQUIRED_FLAG}})"; + } + break; + } + case BASE_TYPE_STRING: { + code_ += "{{PRE}} && verifier.VerifyString(tablePos, " + "{{OFFSET}} /*{{NAME}}*/, {{REQUIRED_FLAG}})"; + break; + } + case BASE_TYPE_VECTOR: { + + switch (field.value.type.element) { + case BASE_TYPE_STRING: { + code_ += "{{PRE}} && verifier.VerifyVectorOfStrings(tablePos, " + "{{OFFSET}} /*{{NAME}}*/, {{REQUIRED_FLAG}})"; + break; + } + case BASE_TYPE_STRUCT: { + if (!field.value.type.struct_def->fixed) { + code_ += "{{PRE}} && verifier.VerifyVectorOfTables(tablePos, " + "{{OFFSET}} /*{{NAME}}*/, {{TYPE}}Verify.Verify, {{REQUIRED_FLAG}})"; + } else { + code_.SetValue( + "VECTOR_ELEM_INLINESIZE", + NumToString(InlineSize(field.value.type.VectorType()))); + code_ += + "{{PRE}} && " + "verifier.VerifyVectorOfData(tablePos, " + "{{OFFSET}} /*{{NAME}}*/, {{VECTOR_ELEM_INLINESIZE}} " + "/*{{TYPE}}*/, {{REQUIRED_FLAG}})"; + } + break; + } + case BASE_TYPE_UNION: { + // Vectors of unions are not yet supported for go + break; + } + default: + // Generate verifier for vector of data. + // It may be either nested flatbuffer of just vector of bytes + auto nfn = GetNestedFlatBufferName(field); + if (!nfn.empty()) { + code_.SetValue("CPP_NAME", nfn); + // FIXME: file_identifier. + code_ += "{{PRE}} && verifier.VerifyNestedBuffer(tablePos, " + "{{OFFSET}} /*{{NAME}}*/, {{CPP_NAME}}Verify.Verify, {{REQUIRED_FLAG}})"; + } else if (field.flexbuffer) { + code_ += "{{PRE}} && verifier.VerifyNestedBuffer(tablePos, " + "{{OFFSET}} /*{{NAME}}*/, null, {{REQUIRED_FLAG}})"; + } else { + code_.SetValue("VECTOR_ELEM_INLINESIZE", NumToString(InlineSize(field.value.type.VectorType()))); + code_ += + "{{PRE}} && verifier.VerifyVectorOfData(tablePos, " + "{{OFFSET}} /*{{NAME}}*/, {{VECTOR_ELEM_INLINESIZE}} /*{{TYPE}}*/, {{REQUIRED_FLAG}})"; + } + break; + } + + break; + } + default: { + break; + } + } + } + + // Generate table constructors, conditioned on its members' types. + void GenTableVerifier(const StructDef &struct_def, std::string *code_ptr) { + CodeWriter code_; + + GetStartOfTableVerifier(struct_def, code_ptr); + + // Generate struct fields accessors + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + if (field.deprecated) continue; + + GenVerifyCall(code_, field, ""); + } + + *code_ptr += code_.ToString(); + + GetEndOfTableVerifier(code_ptr); + } + + // Generate struct or table methods. + void GenStructVerifier(const StructDef &struct_def, std::string *code_ptr) { + if (struct_def.generated) return; + + // cur_name_space_ = struct_def.defined_namespace; + + // Generate verifiers + if (struct_def.fixed) { + // Fixed size structures do not require table members + // verification - instead structure size is verified using VerifyField + } else { + // Create table verification function + GenTableVerifier(struct_def, code_ptr); + } + } + void GenStruct(StructDef &struct_def, std::string *code_ptr, const IDLOptions &opts) const { if (struct_def.generated) return; @@ -688,8 +856,20 @@ class CSharpGenerator : public BaseGenerator { code += parser_.file_identifier_; code += "\"); }\n"; } + + // Generate the Verify method that checks if a ByteBuffer is save to + // access + code += " public static "; + code += "bool Verify" + struct_def.name + "(ByteBuffer _bb) {"; + code += "Google.FlatBuffers.Verifier verifier = new "; + code += "Google.FlatBuffers.Verifier(_bb); "; + code += "return verifier.VerifyBuffer(\""; + code += parser_.file_identifier_; + code += "\", false, " + struct_def.name + "Verify.Verify);"; + code += " }\n"; } } + // Generate the __init method that sets the field in a pre-existing // accessor object. This is to allow object reuse. code += " public void __init(int _i, ByteBuffer _bb) "; @@ -1418,6 +1598,67 @@ class CSharpGenerator : public BaseGenerator { code += " }\n"; } + std::string GenUnionVerify(const Type &union_type) const { + if (union_type.enum_def) { + const auto &enum_def = *union_type.enum_def; + + auto ret = + "\n\nstatic public class " + enum_def.name + "Verify\n"; + ret += "{\n"; + ret += + " static public bool Verify(Google.FlatBuffers.Verifier verifier, " + "byte typeId, uint tablePos)\n"; + ret += " {\n"; + ret += " bool result = true;\n"; + + const auto union_enum_loop = [&]() { + ret += " switch((" + enum_def.name + ")typeId)\n"; + ret += " {\n"; + + for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) { + const auto &ev = **it; + if (ev.IsZero()) { continue; } + + ret += " case " + Name(enum_def) + "." + Name(ev) + ":\n"; + + if (IsString(ev.union_type)) { + ret += + " result = verifier.VerifyUnionString(tablePos);\n"; + ret += " break;"; + } else if (ev.union_type.base_type == BASE_TYPE_STRUCT) { + if (! ev.union_type.struct_def->fixed) { + auto type = GenTypeGet(ev.union_type); + ret += " result = " + type + "Verify.Verify(verifier, tablePos);\n"; + } else { + ret += " result = verifier.VerifyUnionData(tablePos, " + + NumToString(InlineSize(ev.union_type)) + ", " + + NumToString(InlineAlignment(ev.union_type)) + + ");\n";; + } + ret += " break;"; + } else { + FLATBUFFERS_ASSERT(false); + } + ret += "\n"; + } + + ret += " default: result = true;\n"; + ret += " break;\n"; + ret += " }\n"; + ret += " return result;\n"; + }; + + union_enum_loop(); + ret += " }\n"; + ret += "}\n"; + ret += "\n"; + + return ret; + } + FLATBUFFERS_ASSERT(0); + return ""; + } + void GenEnum_ObjectAPI(EnumDef &enum_def, std::string *code_ptr, const IDLOptions &opts) const { auto &code = *code_ptr; @@ -1493,6 +1734,9 @@ class CSharpGenerator : public BaseGenerator { code += " }\n"; code += " }\n"; code += "}\n\n"; + + code += GenUnionVerify(enum_def.underlying_type); + // JsonConverter if (opts.cs_gen_json_serializer) { if (enum_def.attributes.Lookup("private")) { diff --git a/src/idl_gen_go.cpp b/src/idl_gen_go.cpp index 6a66b5c62..0f2882b75 100644 --- a/src/idl_gen_go.cpp +++ b/src/idl_gen_go.cpp @@ -292,6 +292,14 @@ class GoGenerator : public BaseGenerator { const std::string size_prefix[] = { "", "SizePrefixed" }; const std::string struct_type = namer_.Type(struct_def); + bool has_file_identifier = (parser_.root_struct_def_ == &struct_def) && + parser_.file_identifier_.length(); + + if (has_file_identifier) { + code += "const " + struct_type + "Identifier = \"" + + parser_.file_identifier_ + "\"\n\n"; + } + for (int i = 0; i < 2; i++) { code += "func Get" + size_prefix[i] + "RootAs" + struct_type; code += "(buf []byte, offset flatbuffers.UOffsetT) "; @@ -312,6 +320,26 @@ class GoGenerator : public BaseGenerator { } code += "\treturn x\n"; code += "}\n\n"; + + code += "func Finish" + size_prefix[i] + struct_type + + "Buffer(builder *flatbuffers.Builder, offset " + "flatbuffers.UOffsetT) {\n"; + if (has_file_identifier) { + code += "\tidentifierBytes := []byte(" + struct_type + "Identifier)\n"; + code += "\tbuilder.Finish" + size_prefix[i] + + "WithFileIdentifier(offset, identifierBytes)\n"; + } else { + code += "\tbuilder.Finish" + size_prefix[i] + "(offset)\n"; + } + code += "}\n\n"; + + if (has_file_identifier) { + code += "func " + size_prefix[i] + struct_type + + "BufferHasIdentifier(buf []byte) bool {\n"; + code += "\treturn flatbuffers." + size_prefix[i] + + "BufferHasIdentifier(buf, " + struct_type + "Identifier)\n"; + code += "}\n\n"; + } } } @@ -513,7 +541,7 @@ class GoGenerator : public BaseGenerator { GenReceiver(struct_def, code_ptr); code += " " + namer_.Field(field) + "ByKey"; code += "(obj *" + TypeName(field); - code += ", key " + NativeType(key_field.value.type) + ") bool" + + code += ", key " + NativeType(key_field.value.type) + ") bool " + OffsetPrefix(field); code += "\t\tx := rcv._tab.Vector(o)\n"; code += "\t\treturn "; @@ -892,8 +920,8 @@ class GoGenerator : public BaseGenerator { code += "o1, o2 flatbuffers.UOffsetT, buf []byte) bool {\n"; code += "\tobj1 := &" + namer_.Type(struct_def) + "{}\n"; code += "\tobj2 := &" + namer_.Type(struct_def) + "{}\n"; - code += "\tobj1.Init(buf, flatbuffers.UOffsetT(len(buf)) - o1)\n"; - code += "\tobj2.Init(buf, flatbuffers.UOffsetT(len(buf)) - o2)\n"; + code += "\tobj1.Init(buf, flatbuffers.UOffsetT(len(buf))-o1)\n"; + code += "\tobj2.Init(buf, flatbuffers.UOffsetT(len(buf))-o2)\n"; if (IsString(field.value.type)) { code += "\treturn string(obj1." + namer_.Function(field.name) + "()) < "; code += "string(obj2." + namer_.Function(field.name) + "())\n"; @@ -915,13 +943,13 @@ class GoGenerator : public BaseGenerator { code += "key " + NativeType(field.value.type) + ", "; code += "vectorLocation flatbuffers.UOffsetT, "; code += "buf []byte) bool {\n"; - code += "\tspan := flatbuffers.GetUOffsetT(buf[vectorLocation - 4:])\n"; + code += "\tspan := flatbuffers.GetUOffsetT(buf[vectorLocation-4:])\n"; code += "\tstart := flatbuffers.UOffsetT(0)\n"; if (IsString(field.value.type)) { code += "\tbKey := []byte(key)\n"; } code += "\tfor span != 0 {\n"; code += "\t\tmiddle := span / 2\n"; code += "\t\ttableOffset := flatbuffers.GetIndirectOffset(buf, "; - code += "vectorLocation+ 4 * (start + middle))\n"; + code += "vectorLocation+4*(start+middle))\n"; code += "\t\tobj := &" + namer_.Type(struct_def) + "{}\n"; code += "\t\tobj.Init(buf, tableOffset)\n"; @@ -1032,8 +1060,8 @@ class GoGenerator : public BaseGenerator { code += "\t\treturn &" + WrapInNameSpaceAndTrack(&enum_def, NativeName(enum_def)) + - "{ Type: " + namer_.EnumVariant(enum_def, ev) + - ", Value: x.UnPack() }\n"; + "{Type: " + namer_.EnumVariant(enum_def, ev) + + ", Value: x.UnPack()}\n"; } code += "\t}\n"; code += "\treturn nil\n"; @@ -1046,7 +1074,7 @@ class GoGenerator : public BaseGenerator { code += "func (t *" + NativeName(struct_def) + ") Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {\n"; - code += "\tif t == nil { return 0 }\n"; + code += "\tif t == nil {\n\t\treturn 0\n\t}\n"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { const FieldDef &field = **it; @@ -1116,8 +1144,7 @@ class GoGenerator : public BaseGenerator { if (field.value.type.struct_def->fixed) continue; code += "\t" + offset + " := t." + field_field + ".Pack(builder)\n"; } else if (field.value.type.base_type == BASE_TYPE_UNION) { - code += "\t" + offset + " := t." + field_field + ".Pack(builder)\n"; - code += "\t\n"; + code += "\t" + offset + " := t." + field_field + ".Pack(builder)\n\n"; } else { FLATBUFFERS_ASSERT(0); } @@ -1233,7 +1260,7 @@ class GoGenerator : public BaseGenerator { code += "func (rcv *" + struct_type + ") UnPack() *" + NativeName(struct_def) + " {\n"; - code += "\tif rcv == nil { return nil }\n"; + code += "\tif rcv == nil {\n\t\treturn nil\n\t}\n"; code += "\tt := &" + NativeName(struct_def) + "{}\n"; code += "\trcv.UnPackTo(t)\n"; code += "\treturn t\n"; @@ -1245,7 +1272,7 @@ class GoGenerator : public BaseGenerator { code += "func (t *" + NativeName(struct_def) + ") Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {\n"; - code += "\tif t == nil { return 0 }\n"; + code += "\tif t == nil {\n\t\treturn 0\n\t}\n"; code += "\treturn Create" + namer_.Type(struct_def) + "(builder"; StructPackArgs(struct_def, "", code_ptr); code += ")\n"; @@ -1289,7 +1316,7 @@ class GoGenerator : public BaseGenerator { code += "func (rcv *" + namer_.Type(struct_def) + ") UnPack() *" + NativeName(struct_def) + " {\n"; - code += "\tif rcv == nil { return nil }\n"; + code += "\tif rcv == nil {\n\t\treturn nil\n\t}\n"; code += "\tt := &" + NativeName(struct_def) + "{}\n"; code += "\trcv.UnPackTo(t)\n"; code += "\treturn t\n"; @@ -1477,15 +1504,17 @@ class GoGenerator : public BaseGenerator { code += "package " + name_space_name + "\n\n"; if (needs_imports) { code += "import (\n"; + // standard imports, in alphabetical order for go fmt if (needs_bytes_import_) code += "\t\"bytes\"\n"; - // math is needed to support non-finite scalar default values. - if (needs_math_import_) { code += "\t\"math\"\n"; } - if (is_enum) { code += "\t\"strconv\"\n"; } if (!parser_.opts.go_import.empty()) { code += "\tflatbuffers \"" + parser_.opts.go_import + "\"\n"; } else { code += "\tflatbuffers \"github.com/google/flatbuffers/go\"\n"; } + // math is needed to support non-finite scalar default values. + if (needs_math_import_) { code += "\t\"math\"\n"; } + if (is_enum) { code += "\t\"strconv\"\n"; } + if (tracked_imported_namespaces_.size() > 0) { code += "\n"; for (auto it = tracked_imported_namespaces_.begin(); diff --git a/src/idl_gen_python.cpp b/src/idl_gen_python.cpp index 5b5ce353a..6c93b9092 100644 --- a/src/idl_gen_python.cpp +++ b/src/idl_gen_python.cpp @@ -139,13 +139,15 @@ class PythonGenerator : public BaseGenerator { code += Indent + Indent + "return x\n"; code += "\n"; - // Add an alias with the old name - code += Indent + "@classmethod\n"; - code += Indent + "def GetRootAs" + struct_type + "(cls, buf, offset=0):\n"; - code += - Indent + Indent + - "\"\"\"This method is deprecated. Please switch to GetRootAs.\"\"\"\n"; - code += Indent + Indent + "return cls.GetRootAs(buf, offset)\n"; + if (!parser_.opts.python_no_type_prefix_suffix) { + // Add an alias with the old name + code += Indent + "@classmethod\n"; + code += Indent + "def GetRootAs" + struct_type + "(cls, buf, offset=0):\n"; + code += + Indent + Indent + + "\"\"\"This method is deprecated. Please switch to GetRootAs.\"\"\"\n"; + code += Indent + Indent + "return cls.GetRootAs(buf, offset)\n"; + } } // Initialize an existing object with other data, to avoid an allocation. @@ -480,7 +482,10 @@ class PythonGenerator : public BaseGenerator { if (!nested) { return; } // There is no nested flatbuffer. const std::string unqualified_name = nested->constant; - const std::string qualified_name = NestedFlatbufferType(unqualified_name); + std::string qualified_name = NestedFlatbufferType(unqualified_name); + if (qualified_name.empty()) { + qualified_name = nested->constant; + } auto &code = *code_ptr; GenReceiver(struct_def, code_ptr); @@ -491,7 +496,7 @@ class PythonGenerator : public BaseGenerator { code += Indent + Indent + Indent; code += "from " + qualified_name + " import " + unqualified_name + "\n"; code += Indent + Indent + Indent + "return " + unqualified_name; - code += ".GetRootAs" + unqualified_name; + code += ".GetRootAs"; code += "(self._tab.Bytes, self._tab.Vector(o))\n"; code += Indent + Indent + "return 0\n"; code += "\n"; @@ -605,15 +610,18 @@ class PythonGenerator : public BaseGenerator { auto &code = *code_ptr; const auto struct_type = namer_.Type(struct_def); // Generate method with struct name. - code += "def " + struct_type + "Start(builder): "; - code += "builder.StartObject("; - code += NumToString(struct_def.fields.vec.size()); - code += ")\n"; - if (!parser_.opts.one_file) { + const auto name = parser_.opts.python_no_type_prefix_suffix ? "Start" : struct_type + "Start"; + + code += "def " + name + "(builder):\n"; + code += Indent + "return builder.StartObject("; + code += NumToString(struct_def.fields.vec.size()); + code += ")\n\n"; + + if (!parser_.opts.one_file && !parser_.opts.python_no_type_prefix_suffix) { // Generate method without struct name. code += "def Start(builder):\n"; - code += Indent + "return " + struct_type + "Start(builder)\n"; + code += Indent + "return " + struct_type + "Start(builder)\n\n"; } } @@ -624,12 +632,14 @@ class PythonGenerator : public BaseGenerator { const std::string field_var = namer_.Variable(field); const std::string field_method = namer_.Method(field); + const auto name = parser_.opts.python_no_type_prefix_suffix ? "Add" + field_method : namer_.Type(struct_def) + "Add" + field_method; + // Generate method with struct name. - code += "def " + namer_.Type(struct_def) + "Add" + field_method; + code += "def " + name; code += "(builder, "; code += field_var; - code += "): "; - code += "builder.Prepend"; + code += "):\n"; + code += Indent + "return builder.Prepend"; code += GenMethod(field) + "Slot("; code += NumToString(offset) + ", "; if (!IsScalar(field.value.type.base_type) && (!struct_def.fixed)) { @@ -646,16 +656,16 @@ class PythonGenerator : public BaseGenerator { } else { code += field.value.constant; } - code += ")\n"; + code += ")\n\n"; - if (!parser_.opts.one_file) { + if (!parser_.opts.one_file && !parser_.opts.python_no_type_prefix_suffix) { // Generate method without struct name. code += "def Add" + field_method + "(builder, " + field_var + "):\n"; code += Indent + "return " + namer_.Type(struct_def) + "Add" + field_method; code += "(builder, "; code += field_var; - code += ")\n"; + code += ")\n\n"; } } @@ -667,20 +677,22 @@ class PythonGenerator : public BaseGenerator { const std::string field_method = namer_.Method(field); // Generate method with struct name. - code += "def " + struct_type + "Start" + field_method; - code += "Vector(builder, numElems): return builder.StartVector("; + const auto name = parser_.opts.python_no_type_prefix_suffix ? "Start" + field_method : struct_type + "Start" + field_method; + code += "def " + name; + code += "Vector(builder, numElems):\n"; + code += Indent + "return builder.StartVector("; auto vector_type = field.value.type.VectorType(); auto alignment = InlineAlignment(vector_type); auto elem_size = InlineSize(vector_type); code += NumToString(elem_size); code += ", numElems, " + NumToString(alignment); - code += ")\n"; + code += ")\n\n"; - if (!parser_.opts.one_file) { + if (!parser_.opts.one_file && !parser_.opts.python_no_type_prefix_suffix) { // Generate method without struct name. code += "def Start" + field_method + "Vector(builder, numElems):\n"; code += Indent + "return " + struct_type + "Start"; - code += field_method + "Vector(builder, numElems)\n"; + code += field_method + "Vector(builder, numElems)\n\n"; } } @@ -725,15 +737,16 @@ class PythonGenerator : public BaseGenerator { std::string *code_ptr) const { auto &code = *code_ptr; + const auto name = parser_.opts.python_no_type_prefix_suffix ? "End" : namer_.Type(struct_def) + "End"; // Generate method with struct name. - code += "def " + namer_.Type(struct_def) + "End"; - code += "(builder): "; - code += "return builder.EndObject()\n"; + code += "def " + name + "(builder):\n"; + code += Indent + "return builder.EndObject()\n\n"; - if (!parser_.opts.one_file) { + if (!parser_.opts.one_file && !parser_.opts.python_no_type_prefix_suffix) { // Generate method without struct name. code += "def End(builder):\n"; code += Indent + "return " + namer_.Type(struct_def) + "End(builder)"; + code += "\n"; } } diff --git a/src/idl_gen_swift.cpp b/src/idl_gen_swift.cpp index 6afa069ea..8257c0c12 100644 --- a/src/idl_gen_swift.cpp +++ b/src/idl_gen_swift.cpp @@ -725,9 +725,9 @@ class SwiftGenerator : public BaseGenerator { code_.SetValue("CONSTANT", default_value); code_.SetValue("VALUETYPE", "Bool"); code_ += GenReaderMainBody(optional) + "\\"; - code_.SetValue("VALUETYPE", "Byte"); - code_ += GenOffset() + "return o == 0 ? {{CONSTANT}} : 0 != " + - GenReader("VALUETYPE", "o") + " }"; + code_ += GenOffset() + + "return o == 0 ? {{CONSTANT}} : " + GenReader("VALUETYPE", "o") + + " }"; if (parser_.opts.mutable_buffer) code_ += GenMutate("o", GenOffset()); return; } diff --git a/src/idl_gen_ts.cpp b/src/idl_gen_ts.cpp index 298349d58..18737a958 100644 --- a/src/idl_gen_ts.cpp +++ b/src/idl_gen_ts.cpp @@ -474,14 +474,13 @@ class TsGenerator : public BaseGenerator { return "BigInt('" + value.constant + "')"; } default: { - if (auto val = value.type.enum_def->FindByValue(value.constant)) { - return AddImport(imports, *value.type.enum_def, - *value.type.enum_def) - .name + - "." + namer_.Variant(*val); - } else { - return value.constant; - } + EnumVal *val = value.type.enum_def->FindByValue(value.constant); + if (val == nullptr) + val = const_cast(value.type.enum_def->MinValue()); + return AddImport(imports, *value.type.enum_def, + *value.type.enum_def) + .name + + "." + namer_.Variant(*val); } } } diff --git a/tests/FlatBuffers.Test/FlatBuffers.Core.Test.csproj b/tests/FlatBuffers.Test/FlatBuffers.Core.Test.csproj index a82b07af3..75f70fef3 100644 --- a/tests/FlatBuffers.Test/FlatBuffers.Core.Test.csproj +++ b/tests/FlatBuffers.Test/FlatBuffers.Core.Test.csproj @@ -46,6 +46,9 @@ FlatBuffers\FlatBufferConstants.cs + + FlatBuffers\FlatBufferVerify.cs + FlatBuffers\Struct.cs diff --git a/tests/FlatBuffers.Test/FlatBuffersExampleTests.cs b/tests/FlatBuffers.Test/FlatBuffersExampleTests.cs index 6c9e309c9..e3dbea642 100644 --- a/tests/FlatBuffers.Test/FlatBuffersExampleTests.cs +++ b/tests/FlatBuffers.Test/FlatBuffersExampleTests.cs @@ -198,6 +198,9 @@ namespace Google.FlatBuffers.Test private void TestBuffer(ByteBuffer bb) { + bool test = Monster.VerifyMonster(bb); + Assert.AreEqual(true, test); + Monster monster = Monster.GetRootAsMonster(bb); Assert.AreEqual(80, monster.Hp); @@ -299,7 +302,7 @@ namespace Google.FlatBuffers.Test var jsonText = File.ReadAllText(@"../monsterdata_test.json"); var mon = MonsterT.DeserializeFromJson(jsonText); var fbb = new FlatBufferBuilder(1); - fbb.Finish(Monster.Pack(fbb, mon).Value); + Monster.FinishMonsterBuffer(fbb, Monster.Pack(fbb, mon)); TestBuffer(fbb.DataBuffer); } diff --git a/tests/FlatBuffers.Test/FlatBuffersFuzzTests.cs b/tests/FlatBuffers.Test/FlatBuffersFuzzTests.cs index 0377a7b40..fb6c4836b 100644 --- a/tests/FlatBuffers.Test/FlatBuffersFuzzTests.cs +++ b/tests/FlatBuffers.Test/FlatBuffersFuzzTests.cs @@ -15,6 +15,7 @@ */ using System; +using Google.FlatBuffers; namespace Google.FlatBuffers.Test { @@ -204,9 +205,21 @@ namespace Google.FlatBuffers.Test 1, // value 0 }, builder.DataBuffer.ToFullArray()); - } + var verifier = new Verifier(builder.DataBuffer); + var offset = 8; + // table must be ok + Assert.IsTrue(verifier.VerifyTableStart((uint)offset)); + // First field must be bool + Assert.IsTrue(verifier.VerifyField((uint)offset, 4, 1, 1, true)); + // Check Error: Second field + Assert.IsFalse(verifier.VerifyField((uint)offset, 6, 1, 1, true)); + // Check Error: First field too big alignment + Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 1, 2, true)); + // Check Error: First size to big + Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 2, 1, true)); + } - [FlatBuffersTestMethod] + [FlatBuffersTestMethod] public void TestVTableWithOneBool_DefaultValue() { var builder = new FlatBufferBuilder(1); @@ -223,6 +236,14 @@ namespace Google.FlatBuffers.Test 4, 0, 0, 0, // int32 offset for start of vtable }, builder.DataBuffer.ToFullArray()); + var verifier = new Verifier(builder.DataBuffer); + var offset = 4; + // table must be ok + Assert.IsTrue(verifier.VerifyTableStart((uint)offset)); + // First field must be bool + Assert.IsTrue(verifier.VerifyField((uint)offset, 4, 1, 1, false)); + // Error Check: First field not present + Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 1, 1, true)); } [FlatBuffersTestMethod] @@ -232,7 +253,7 @@ namespace Google.FlatBuffers.Test builder.StartTable(1); Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray()); builder.AddShort(0, 0x789A, 0); - builder.EndTable(); + int offset = builder.EndTable(); Assert.ArrayEqual(new byte[] { 0, 0, // padding to 16 bytes @@ -244,6 +265,18 @@ namespace Google.FlatBuffers.Test 0x9A, 0x78, //value 0 }, builder.DataBuffer.ToFullArray()); + var verifier = new Verifier(builder.DataBuffer); + offset += builder.DataBuffer.Position; + // table must be ok + Assert.IsTrue(verifier.VerifyTableStart((uint)offset)); + // First field must be ushort + Assert.IsTrue(verifier.VerifyField((uint)offset, 4, 2, 2, true)); + // Check Error: Second field + Assert.IsFalse(verifier.VerifyField((uint)offset, 6, 2, 2, true)); + // Check Error: First field too big alignment + Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 4, 2, true)); + // Check Error: First field size to big + Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 2, 4, true)); } [FlatBuffersTestMethod] @@ -254,7 +287,7 @@ namespace Google.FlatBuffers.Test Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray()); builder.AddShort(0, 0x3456, 0); builder.AddShort(1, 0x789A, 0); - builder.EndTable(); + int offset = builder.EndTable(); Assert.ArrayEqual(new byte[] { 8, 0, // vtable bytes @@ -266,6 +299,18 @@ namespace Google.FlatBuffers.Test 0x56, 0x34, // value 0 }, builder.DataBuffer.ToFullArray()); + var verifier = new Verifier(builder.DataBuffer); + offset += builder.DataBuffer.Position; + // table must be ok + Assert.IsTrue(verifier.VerifyTableStart((uint)offset)); + // First field must be ushort + Assert.IsTrue(verifier.VerifyField((uint)offset, 4, 2, 2, true)); + // Check Error: Second field + Assert.IsTrue(verifier.VerifyField((uint)offset, 6, 2, 2, true)); + // Check Error: Second field too big alignment + Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 4, 2, true)); + // Check Error: Second field size to big + Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 2, 4, true)); } [FlatBuffersTestMethod] @@ -276,7 +321,7 @@ namespace Google.FlatBuffers.Test Assert.ArrayEqual(new byte[] { 0 }, builder.DataBuffer.ToFullArray()); builder.AddShort(0, 0x3456, 0); builder.AddBool(1, true, false); - builder.EndTable(); + int offset = builder.EndTable(); Assert.ArrayEqual(new byte[] { 8, 0, // vtable bytes @@ -288,6 +333,18 @@ namespace Google.FlatBuffers.Test 0x56, 0x34, // value 0 }, builder.DataBuffer.ToFullArray()); + var verifier = new Verifier(builder.DataBuffer); + offset += builder.DataBuffer.Position; + // table must be ok + Assert.IsTrue(verifier.VerifyTableStart((uint)offset)); + // First field must be ushort + Assert.IsTrue(verifier.VerifyField((uint)offset, 4, 2, 2, true)); + // Check Error: Second field must be bool + Assert.IsTrue(verifier.VerifyField((uint)offset, 6, 1, 1, true)); + // Check Error: Second field too big alignment + Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 4, 2, true)); + // Check Error: Second field size to big + Assert.IsFalse(verifier.VerifyField((uint)offset, 4, 2, 4, true)); } [FlatBuffersTestMethod] @@ -315,6 +372,12 @@ namespace Google.FlatBuffers.Test 0, 0, 0, 0, }, builder.DataBuffer.ToFullArray()); + var verifier = new Verifier(builder.DataBuffer); + uint checkOffset = 20; + // table must be ok + Assert.IsTrue(verifier.VerifyTableStart(checkOffset)); + // First field must be vector with element size 1 + Assert.IsTrue(verifier.VerifyVectorOfData(checkOffset, 4, 1, true)); } [FlatBuffersTestMethod] @@ -342,7 +405,15 @@ namespace Google.FlatBuffers.Test 0, 0, 0, 0, // length of vector (not in sctruc) }, builder.DataBuffer.ToFullArray()); - } + var verifier = new Verifier(builder.DataBuffer); + uint checkOffset = 16; + // table must be ok + Assert.IsTrue(verifier.VerifyTableStart(checkOffset)); + // First field must be short + Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 2, 2, true)); + // Second field must be vector with element size 1 + Assert.IsTrue(verifier.VerifyVectorOfData(checkOffset, 6, 2, true)); + } [FlatBuffersTestMethod] @@ -373,6 +444,16 @@ namespace Google.FlatBuffers.Test 0x34, 0x12, // vector value 1 }, builder.DataBuffer.ToFullArray()); + var verifier = new Verifier(builder.DataBuffer); + uint checkOffset = 12; + // table must be ok + Assert.IsTrue(verifier.VerifyTableStart(checkOffset)); + // Second field must be vector with element size 2 + Assert.IsTrue(verifier.VerifyVectorOfData(checkOffset, 6, 2, true)); + // Check Error: Second field with too big size + Assert.IsFalse(verifier.VerifyVectorOfData(checkOffset, 6, 4, true)); + // First field must be short + Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 2, 2, true)); } [FlatBuffersTestMethod] @@ -403,8 +484,17 @@ namespace Google.FlatBuffers.Test 0x00, 0x00, 0x00, 55, // struct value 0 }, builder.DataBuffer.ToFullArray()); + var verifier = new Verifier(builder.DataBuffer); + uint checkOffset = 16; + // table must be ok + Assert.IsTrue(verifier.VerifyTableStart(checkOffset)); + // First field must be a struct with 12 bytes + Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 12, 4, true)); + // Check Error: First field with more than 12 bytes + Assert.IsFalse(verifier.VerifyField(checkOffset, 4, 16, 4, true)); } + [FlatBuffersTestMethod] public void TestVTableWithAVectorOf_2xStructOf_2xInt8() { @@ -437,6 +527,12 @@ namespace Google.FlatBuffers.Test 33, // vector 0, 0 }, builder.DataBuffer.ToFullArray()); + var verifier = new Verifier(builder.DataBuffer); + uint checkOffset = 16; + // table must be ok + Assert.IsTrue(verifier.VerifyTableStart(checkOffset)); + // First field must be vector with element size 2 + Assert.IsTrue(verifier.VerifyVectorOfData(checkOffset, 4, 2, true)); } [FlatBuffersTestMethod] @@ -470,6 +566,104 @@ namespace Google.FlatBuffers.Test byte[] unpadded = new byte[padded.Length - 12]; Buffer.BlockCopy(padded, 12, unpadded, 0, unpadded.Length); Assert.ArrayEqual(unpadded, builder.DataBuffer.ToSizedArray()); + + var verifier = new Verifier(builder.DataBuffer); + uint checkOffset = builder.DataBuffer.GetUint(builder.DataBuffer.Position) + (uint)builder.DataBuffer.Position; + // table must be ok + Assert.IsTrue(verifier.VerifyTableStart(checkOffset)); + // First field must be a struct with 12 bytes + Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 1, 1, true)); + // Second field must be a struct with 12 bytes + Assert.IsTrue(verifier.VerifyField(checkOffset, 6, 2, 2, true)); + } + + [FlatBuffersTestMethod] + public void TestVTableWithStrings() + { + var builder = new FlatBufferBuilder(64); + var str1 = builder.CreateString("foo"); + var str2 = builder.CreateString("foobar"); + builder.StartTable(2); + builder.AddOffset(0, str1.Value, 0); + builder.AddOffset(1, str2.Value, 0); + var off = builder.EndTable(); + builder.Finish(off); + + byte[] padded = new byte[] + { + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, //Padding to 32 bytes + 12, 0, 0, 0, // root of table, pointing to vtable offset + 8, 0, // vtable bytes + 12, 0, // object length + 8, 0, // start of value 0 + 4, 0, // start of value 1 + 8, 0, 0, 0, // int32 offset for start of vtable + 8, 0, 0, 0, // pointer to string + 16, 0, 0, 0, // pointer to string + 6, 0, 0, 0, // length of string + 102, 111, 111, 98, 97, 114, 0, 0, // "foobar" + padding + 3, 0, 0, 0, // length of string + 102, 111, 111, 0 // "bar" + }; + Assert.ArrayEqual(padded, builder.DataBuffer.ToFullArray()); + + var verifier = new Verifier(builder.DataBuffer); + uint checkOffset = builder.DataBuffer.GetUint(builder.DataBuffer.Position) + (uint)builder.DataBuffer.Position; + // table must be ok + Assert.IsTrue(verifier.VerifyTableStart(checkOffset)); + // First field string check + Assert.IsTrue(verifier.VerifyString(checkOffset, 4, true)); + // Second field string check + Assert.IsTrue(verifier.VerifyString(checkOffset, 6, true)); + } + + [FlatBuffersTestMethod] + public void TestVTableWithVectorOfStrings() + { + var builder = new FlatBufferBuilder(64); + var str1 = builder.CreateString("foo"); + var str2 = builder.CreateString("foobar"); + builder.StartVector(sizeof(int), 2, 1); + builder.AddOffset(str1.Value); + builder.AddOffset(str2.Value); + var vec = builder.EndVector(); + builder.StartTable(1); + builder.AddOffset(0, vec.Value, 0); + var off = builder.EndTable(); + builder.Finish(off); + + byte[] padded = new byte[] + { + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, //Padding to 32 bytes + 12, 0, 0, 0, // root of table, pointing to vtable offset + 0, 0, // padding + 6, 0, // vtable bytes + 8, 0, // object length + 4, 0, // start of value 0 + 6, 0, 0, 0, // int32 offset for start of vtable + 4, 0, 0, 0, // pointer to vector + 2, 0, 0, 0, // length of vector + 8, 0, 0, 0, // int32 offset to string 1 + 16, 0, 0, 0, // int32 offset to string 2 + 6, 0, 0, 0, // length of string + 102, 111, 111, 98, 97, 114, 0, 0, // "foobar" + padding + 3, 0, 0, 0, // length of string + 102, 111, 111, 0 // "bar" + }; + Assert.ArrayEqual(padded, builder.DataBuffer.ToFullArray()); + + var verifier = new Verifier(builder.DataBuffer); + uint checkOffset = builder.DataBuffer.GetUint(builder.DataBuffer.Position) + (uint)builder.DataBuffer.Position; + // table must be ok + Assert.IsTrue(verifier.VerifyTableStart(checkOffset)); + // First field string check + Assert.IsTrue(verifier.VerifyVectorOfStrings(checkOffset, 4, true)); } [FlatBuffersTestMethod] @@ -521,6 +715,33 @@ namespace Google.FlatBuffers.Test 33, }, builder.DataBuffer.ToFullArray()); + + // check obj1 + var verifier = new Verifier(builder.DataBuffer); + uint checkOffset = builder.DataBuffer.GetUint(builder.DataBuffer.Position) + (uint)builder.DataBuffer.Position; + // table must be ok + Assert.IsTrue(verifier.VerifyTableStart(checkOffset)); + // First field must be a struct with 12 bytes + Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 1, 1, true)); + // Second field must be a struct with 12 bytes + Assert.IsTrue(verifier.VerifyField(checkOffset, 6, 1, 1, true)); + // Third field must be a struct with 12 bytes + Assert.IsTrue(verifier.VerifyField(checkOffset, 8, 1, 1, true)); + // Check Error: 4. field did not exist + Assert.IsFalse(verifier.VerifyField(checkOffset, 10, 1, 1, true)); + + // check obj0 + checkOffset = 56; + // table must be ok + Assert.IsTrue(verifier.VerifyTableStart(checkOffset)); + // First field must be a struct with 12 bytes + Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 1, 1, true)); + // Second field must be a struct with 12 bytes + Assert.IsTrue(verifier.VerifyField(checkOffset, 6, 1, 1, true)); + // Check Error: 3. field did not exist + Assert.IsFalse(verifier.VerifyField(checkOffset, 8, 1, 1, true)); + // Check Error: 4. field did not exist + Assert.IsFalse(verifier.VerifyField(checkOffset, 10, 1, 1, true)); } [FlatBuffersTestMethod] @@ -569,6 +790,16 @@ namespace Google.FlatBuffers.Test byte[] unpadded = new byte[padded.Length - 28]; Buffer.BlockCopy(padded, 28, unpadded, 0, unpadded.Length); Assert.ArrayEqual(unpadded, builder.DataBuffer.ToSizedArray()); + + var verifier = new Verifier(builder.DataBuffer); + uint checkOffset = builder.DataBuffer.GetUint(builder.DataBuffer.Position) + (uint)builder.DataBuffer.Position; + // table must be ok + Assert.IsTrue(verifier.VerifyTableStart(checkOffset)); + for (var i = 0; i < 8; i++) + { + Assert.IsTrue(verifier.VerifyField(checkOffset, (short)(4 + i * 2), 1, 1, true)); + } + Assert.IsFalse(verifier.VerifyField(checkOffset, (short)(4 + 8 * 2), 1, 1, true)); } [FlatBuffersTestMethod] @@ -639,6 +870,16 @@ namespace Google.FlatBuffers.Test }, builder.DataBuffer.ToFullArray()); + var verifier = new Verifier(builder.DataBuffer); + uint checkOffset = 8; + // table must be ok + Assert.IsTrue(verifier.VerifyTableStart(checkOffset)); + // First Field must be float + Assert.IsTrue(verifier.VerifyField(checkOffset, 4, 4, 4, true)); + // Check Error: First Field with to big size + Assert.IsFalse(verifier.VerifyField(checkOffset, 4, 8, 4, true)); + // Check Error: First Field with to big padding + Assert.IsFalse(verifier.VerifyField(checkOffset, 4, 4, 8, true)); } private void CheckObjects(int fieldCount, int objectCount) diff --git a/tests/KeywordTest/KeywordsInTable.cs b/tests/KeywordTest/KeywordsInTable.cs index 90030116a..9556c9f6d 100644 --- a/tests/KeywordTest/KeywordsInTable.cs +++ b/tests/KeywordTest/KeywordsInTable.cs @@ -92,4 +92,17 @@ public class KeywordsInTableT } +static public class KeywordsInTableVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyField(tablePos, 4 /*Is*/, 4 /*KeywordTest.ABC*/, 4, false) + && verifier.VerifyField(tablePos, 6 /*Private*/, 4 /*KeywordTest.@public*/, 4, false) + && verifier.VerifyField(tablePos, 8 /*Type*/, 4 /*int*/, 4, false) + && verifier.VerifyField(tablePos, 10 /*Default*/, 1 /*bool*/, 1, false) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/KeywordTest/KeywordsInUnion.cs b/tests/KeywordTest/KeywordsInUnion.cs index 0efa0668d..d8a870f41 100644 --- a/tests/KeywordTest/KeywordsInUnion.cs +++ b/tests/KeywordTest/KeywordsInUnion.cs @@ -37,6 +37,28 @@ public class KeywordsInUnionUnion { } } + + +static public class KeywordsInUnionVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos) + { + bool result = true; + switch((KeywordsInUnion)typeId) + { + case KeywordsInUnion.@static: + result = KeywordTest.KeywordsInTableVerify.Verify(verifier, tablePos); + break; + case KeywordsInUnion.@internal: + result = KeywordTest.KeywordsInTableVerify.Verify(verifier, tablePos); + break; + default: result = true; + break; + } + return result; + } +} + public class KeywordsInUnionUnion_JsonConverter : Newtonsoft.Json.JsonConverter { public override bool CanConvert(System.Type objectType) { return objectType == typeof(KeywordsInUnionUnion) || objectType == typeof(System.Collections.Generic.List); diff --git a/tests/KeywordTest/Table2.cs b/tests/KeywordTest/Table2.cs index 56ee6898e..59cfee06f 100644 --- a/tests/KeywordTest/Table2.cs +++ b/tests/KeywordTest/Table2.cs @@ -91,4 +91,15 @@ public class Table2T } +static public class Table2Verify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyField(tablePos, 4 /*TypeType*/, 1 /*KeywordTest.KeywordsInUnion*/, 1, false) + && verifier.VerifyUnion(tablePos, 4, 6 /*Type*/, KeywordTest.KeywordsInUnionVerify.Verify, false) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/MyGame/Example/Ability.go b/tests/MyGame/Example/Ability.go index ae869aafd..922c0e4ae 100644 --- a/tests/MyGame/Example/Ability.go +++ b/tests/MyGame/Example/Ability.go @@ -12,7 +12,9 @@ type AbilityT struct { } func (t *AbilityT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } + if t == nil { + return 0 + } return CreateAbility(builder, t.Id, t.Distance) } func (rcv *Ability) UnPackTo(t *AbilityT) { @@ -21,7 +23,9 @@ func (rcv *Ability) UnPackTo(t *AbilityT) { } func (rcv *Ability) UnPack() *AbilityT { - if rcv == nil { return nil } + if rcv == nil { + return nil + } t := &AbilityT{} rcv.UnPackTo(t) return t diff --git a/tests/MyGame/Example/Any.cs b/tests/MyGame/Example/Any.cs index 90cd22bf9..021faa626 100644 --- a/tests/MyGame/Example/Any.cs +++ b/tests/MyGame/Example/Any.cs @@ -41,6 +41,31 @@ public class AnyUnion { } } + + +static public class AnyVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos) + { + bool result = true; + switch((Any)typeId) + { + case Any.Monster: + result = MyGame.Example.MonsterVerify.Verify(verifier, tablePos); + break; + case Any.TestSimpleTableWithEnum: + result = MyGame.Example.TestSimpleTableWithEnumVerify.Verify(verifier, tablePos); + break; + case Any.MyGame_Example2_Monster: + result = MyGame.Example2.MonsterVerify.Verify(verifier, tablePos); + break; + default: result = true; + break; + } + return result; + } +} + public class AnyUnion_JsonConverter : Newtonsoft.Json.JsonConverter { public override bool CanConvert(System.Type objectType) { return objectType == typeof(AnyUnion) || objectType == typeof(System.Collections.Generic.List); diff --git a/tests/MyGame/Example/Any.go b/tests/MyGame/Example/Any.go index 3b7f6295d..9d56df275 100644 --- a/tests/MyGame/Example/Any.go +++ b/tests/MyGame/Example/Any.go @@ -3,8 +3,8 @@ package Example import ( - "strconv" flatbuffers "github.com/google/flatbuffers/go" + "strconv" MyGame__Example2 "MyGame/Example2" ) @@ -64,15 +64,15 @@ func (rcv Any) UnPack(table flatbuffers.Table) *AnyT { case AnyMonster: var x Monster x.Init(table.Bytes, table.Pos) - return &AnyT{ Type: AnyMonster, Value: x.UnPack() } + return &AnyT{Type: AnyMonster, Value: x.UnPack()} case AnyTestSimpleTableWithEnum: var x TestSimpleTableWithEnum x.Init(table.Bytes, table.Pos) - return &AnyT{ Type: AnyTestSimpleTableWithEnum, Value: x.UnPack() } + return &AnyT{Type: AnyTestSimpleTableWithEnum, Value: x.UnPack()} case AnyMyGame_Example2_Monster: var x MyGame__Example2.Monster x.Init(table.Bytes, table.Pos) - return &AnyT{ Type: AnyMyGame_Example2_Monster, Value: x.UnPack() } + return &AnyT{Type: AnyMyGame_Example2_Monster, Value: x.UnPack()} } return nil } diff --git a/tests/MyGame/Example/AnyAmbiguousAliases.cs b/tests/MyGame/Example/AnyAmbiguousAliases.cs index eec417235..3fb3d779d 100644 --- a/tests/MyGame/Example/AnyAmbiguousAliases.cs +++ b/tests/MyGame/Example/AnyAmbiguousAliases.cs @@ -41,6 +41,31 @@ public class AnyAmbiguousAliasesUnion { } } + + +static public class AnyAmbiguousAliasesVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos) + { + bool result = true; + switch((AnyAmbiguousAliases)typeId) + { + case AnyAmbiguousAliases.M1: + result = MyGame.Example.MonsterVerify.Verify(verifier, tablePos); + break; + case AnyAmbiguousAliases.M2: + result = MyGame.Example.MonsterVerify.Verify(verifier, tablePos); + break; + case AnyAmbiguousAliases.M3: + result = MyGame.Example.MonsterVerify.Verify(verifier, tablePos); + break; + default: result = true; + break; + } + return result; + } +} + public class AnyAmbiguousAliasesUnion_JsonConverter : Newtonsoft.Json.JsonConverter { public override bool CanConvert(System.Type objectType) { return objectType == typeof(AnyAmbiguousAliasesUnion) || objectType == typeof(System.Collections.Generic.List); diff --git a/tests/MyGame/Example/AnyAmbiguousAliases.go b/tests/MyGame/Example/AnyAmbiguousAliases.go index 83e5f7d82..6cfb12f74 100644 --- a/tests/MyGame/Example/AnyAmbiguousAliases.go +++ b/tests/MyGame/Example/AnyAmbiguousAliases.go @@ -3,8 +3,8 @@ package Example import ( - "strconv" flatbuffers "github.com/google/flatbuffers/go" + "strconv" ) type AnyAmbiguousAliases byte @@ -62,15 +62,15 @@ func (rcv AnyAmbiguousAliases) UnPack(table flatbuffers.Table) *AnyAmbiguousAlia case AnyAmbiguousAliasesM1: var x Monster x.Init(table.Bytes, table.Pos) - return &AnyAmbiguousAliasesT{ Type: AnyAmbiguousAliasesM1, Value: x.UnPack() } + return &AnyAmbiguousAliasesT{Type: AnyAmbiguousAliasesM1, Value: x.UnPack()} case AnyAmbiguousAliasesM2: var x Monster x.Init(table.Bytes, table.Pos) - return &AnyAmbiguousAliasesT{ Type: AnyAmbiguousAliasesM2, Value: x.UnPack() } + return &AnyAmbiguousAliasesT{Type: AnyAmbiguousAliasesM2, Value: x.UnPack()} case AnyAmbiguousAliasesM3: var x Monster x.Init(table.Bytes, table.Pos) - return &AnyAmbiguousAliasesT{ Type: AnyAmbiguousAliasesM3, Value: x.UnPack() } + return &AnyAmbiguousAliasesT{Type: AnyAmbiguousAliasesM3, Value: x.UnPack()} } return nil } diff --git a/tests/MyGame/Example/AnyUniqueAliases.cs b/tests/MyGame/Example/AnyUniqueAliases.cs index bb6a21206..629edb69f 100644 --- a/tests/MyGame/Example/AnyUniqueAliases.cs +++ b/tests/MyGame/Example/AnyUniqueAliases.cs @@ -41,6 +41,31 @@ public class AnyUniqueAliasesUnion { } } + + +static public class AnyUniqueAliasesVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos) + { + bool result = true; + switch((AnyUniqueAliases)typeId) + { + case AnyUniqueAliases.M: + result = MyGame.Example.MonsterVerify.Verify(verifier, tablePos); + break; + case AnyUniqueAliases.TS: + result = MyGame.Example.TestSimpleTableWithEnumVerify.Verify(verifier, tablePos); + break; + case AnyUniqueAliases.M2: + result = MyGame.Example2.MonsterVerify.Verify(verifier, tablePos); + break; + default: result = true; + break; + } + return result; + } +} + public class AnyUniqueAliasesUnion_JsonConverter : Newtonsoft.Json.JsonConverter { public override bool CanConvert(System.Type objectType) { return objectType == typeof(AnyUniqueAliasesUnion) || objectType == typeof(System.Collections.Generic.List); diff --git a/tests/MyGame/Example/AnyUniqueAliases.go b/tests/MyGame/Example/AnyUniqueAliases.go index b36e61d9b..0bf17b09f 100644 --- a/tests/MyGame/Example/AnyUniqueAliases.go +++ b/tests/MyGame/Example/AnyUniqueAliases.go @@ -3,8 +3,8 @@ package Example import ( - "strconv" flatbuffers "github.com/google/flatbuffers/go" + "strconv" MyGame__Example2 "MyGame/Example2" ) @@ -64,15 +64,15 @@ func (rcv AnyUniqueAliases) UnPack(table flatbuffers.Table) *AnyUniqueAliasesT { case AnyUniqueAliasesM: var x Monster x.Init(table.Bytes, table.Pos) - return &AnyUniqueAliasesT{ Type: AnyUniqueAliasesM, Value: x.UnPack() } + return &AnyUniqueAliasesT{Type: AnyUniqueAliasesM, Value: x.UnPack()} case AnyUniqueAliasesTS: var x TestSimpleTableWithEnum x.Init(table.Bytes, table.Pos) - return &AnyUniqueAliasesT{ Type: AnyUniqueAliasesTS, Value: x.UnPack() } + return &AnyUniqueAliasesT{Type: AnyUniqueAliasesTS, Value: x.UnPack()} case AnyUniqueAliasesM2: var x MyGame__Example2.Monster x.Init(table.Bytes, table.Pos) - return &AnyUniqueAliasesT{ Type: AnyUniqueAliasesM2, Value: x.UnPack() } + return &AnyUniqueAliasesT{Type: AnyUniqueAliasesM2, Value: x.UnPack()} } return nil } diff --git a/tests/MyGame/Example/ArrayTable.cs b/tests/MyGame/Example/ArrayTable.cs index 56b8353f8..d38b70c06 100644 --- a/tests/MyGame/Example/ArrayTable.cs +++ b/tests/MyGame/Example/ArrayTable.cs @@ -17,6 +17,7 @@ public struct ArrayTable : IFlatbufferObject public static ArrayTable GetRootAsArrayTable(ByteBuffer _bb) { return GetRootAsArrayTable(_bb, new ArrayTable()); } public static ArrayTable GetRootAsArrayTable(ByteBuffer _bb, ArrayTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); } public static bool ArrayTableBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "ARRT"); } + public static bool VerifyArrayTable(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("ARRT", false, ArrayTableVerify.Verify); } public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); } public ArrayTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } @@ -72,4 +73,14 @@ public class ArrayTableT } +static public class ArrayTableVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyField(tablePos, 4 /*A*/, 160 /*MyGame.Example.ArrayStruct*/, 8, false) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/MyGame/Example/ArrayTable.py b/tests/MyGame/Example/ArrayTable.py index b7a3ac5b6..7f4051f5e 100644 --- a/tests/MyGame/Example/ArrayTable.py +++ b/tests/MyGame/Example/ArrayTable.py @@ -39,15 +39,24 @@ class ArrayTable(object): return obj return None -def ArrayTableStart(builder): builder.StartObject(1) +def ArrayTableStart(builder): + return builder.StartObject(1) + def Start(builder): return ArrayTableStart(builder) -def ArrayTableAddA(builder, a): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0) + +def ArrayTableAddA(builder, a): + return builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0) + def AddA(builder, a): return ArrayTableAddA(builder, a) -def ArrayTableEnd(builder): return builder.EndObject() + +def ArrayTableEnd(builder): + return builder.EndObject() + def End(builder): return ArrayTableEnd(builder) + import MyGame.Example.ArrayStruct try: from typing import Optional diff --git a/tests/MyGame/Example/Monster.cs b/tests/MyGame/Example/Monster.cs index 4abde535c..e7cdd2e85 100644 --- a/tests/MyGame/Example/Monster.cs +++ b/tests/MyGame/Example/Monster.cs @@ -18,6 +18,7 @@ public struct Monster : IFlatbufferObject public static Monster GetRootAsMonster(ByteBuffer _bb) { return GetRootAsMonster(_bb, new Monster()); } public static Monster GetRootAsMonster(ByteBuffer _bb, Monster obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); } public static bool MonsterBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "MONS"); } + public static bool VerifyMonster(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("MONS", false, MonsterVerify.Verify); } public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); } public Monster __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } @@ -1100,4 +1101,74 @@ public class MonsterT } +static public class MonsterVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyField(tablePos, 4 /*Pos*/, 32 /*MyGame.Example.Vec3*/, 8, false) + && verifier.VerifyField(tablePos, 6 /*Mana*/, 2 /*short*/, 2, false) + && verifier.VerifyField(tablePos, 8 /*Hp*/, 2 /*short*/, 2, false) + && verifier.VerifyString(tablePos, 10 /*Name*/, true) + && verifier.VerifyVectorOfData(tablePos, 14 /*Inventory*/, 1 /*byte*/, false) + && verifier.VerifyField(tablePos, 16 /*Color*/, 1 /*MyGame.Example.Color*/, 1, false) + && verifier.VerifyField(tablePos, 18 /*TestType*/, 1 /*MyGame.Example.Any*/, 1, false) + && verifier.VerifyUnion(tablePos, 18, 20 /*Test*/, MyGame.Example.AnyVerify.Verify, false) + && verifier.VerifyVectorOfData(tablePos, 22 /*Test4*/, 4 /*MyGame.Example.Test*/, false) + && verifier.VerifyVectorOfStrings(tablePos, 24 /*Testarrayofstring*/, false) + && verifier.VerifyVectorOfTables(tablePos, 26 /*Testarrayoftables*/, MyGame.Example.MonsterVerify.Verify, false) + && verifier.VerifyTable(tablePos, 28 /*Enemy*/, MyGame.Example.MonsterVerify.Verify, false) + && verifier.VerifyNestedBuffer(tablePos, 30 /*Testnestedflatbuffer*/, MyGame.Example.MonsterVerify.Verify, false) + && verifier.VerifyTable(tablePos, 32 /*Testempty*/, MyGame.Example.StatVerify.Verify, false) + && verifier.VerifyField(tablePos, 34 /*Testbool*/, 1 /*bool*/, 1, false) + && verifier.VerifyField(tablePos, 36 /*Testhashs32Fnv1*/, 4 /*int*/, 4, false) + && verifier.VerifyField(tablePos, 38 /*Testhashu32Fnv1*/, 4 /*uint*/, 4, false) + && verifier.VerifyField(tablePos, 40 /*Testhashs64Fnv1*/, 8 /*long*/, 8, false) + && verifier.VerifyField(tablePos, 42 /*Testhashu64Fnv1*/, 8 /*ulong*/, 8, false) + && verifier.VerifyField(tablePos, 44 /*Testhashs32Fnv1a*/, 4 /*int*/, 4, false) + && verifier.VerifyField(tablePos, 46 /*Testhashu32Fnv1a*/, 4 /*uint*/, 4, false) + && verifier.VerifyField(tablePos, 48 /*Testhashs64Fnv1a*/, 8 /*long*/, 8, false) + && verifier.VerifyField(tablePos, 50 /*Testhashu64Fnv1a*/, 8 /*ulong*/, 8, false) + && verifier.VerifyVectorOfData(tablePos, 52 /*Testarrayofbools*/, 1 /*bool*/, false) + && verifier.VerifyField(tablePos, 54 /*Testf*/, 4 /*float*/, 4, false) + && verifier.VerifyField(tablePos, 56 /*Testf2*/, 4 /*float*/, 4, false) + && verifier.VerifyField(tablePos, 58 /*Testf3*/, 4 /*float*/, 4, false) + && verifier.VerifyVectorOfStrings(tablePos, 60 /*Testarrayofstring2*/, false) + && verifier.VerifyVectorOfData(tablePos, 62 /*Testarrayofsortedstruct*/, 8 /*MyGame.Example.Ability*/, false) + && verifier.VerifyNestedBuffer(tablePos, 64 /*Flex*/, null, false) + && verifier.VerifyVectorOfData(tablePos, 66 /*Test5*/, 4 /*MyGame.Example.Test*/, false) + && verifier.VerifyVectorOfData(tablePos, 68 /*VectorOfLongs*/, 8 /*long*/, false) + && verifier.VerifyVectorOfData(tablePos, 70 /*VectorOfDoubles*/, 8 /*double*/, false) + && verifier.VerifyTable(tablePos, 72 /*ParentNamespaceTest*/, MyGame.InParentNamespaceVerify.Verify, false) + && verifier.VerifyVectorOfTables(tablePos, 74 /*VectorOfReferrables*/, MyGame.Example.ReferrableVerify.Verify, false) + && verifier.VerifyField(tablePos, 76 /*SingleWeakReference*/, 8 /*ulong*/, 8, false) + && verifier.VerifyVectorOfData(tablePos, 78 /*VectorOfWeakReferences*/, 8 /*ulong*/, false) + && verifier.VerifyVectorOfTables(tablePos, 80 /*VectorOfStrongReferrables*/, MyGame.Example.ReferrableVerify.Verify, false) + && verifier.VerifyField(tablePos, 82 /*CoOwningReference*/, 8 /*ulong*/, 8, false) + && verifier.VerifyVectorOfData(tablePos, 84 /*VectorOfCoOwningReferences*/, 8 /*ulong*/, false) + && verifier.VerifyField(tablePos, 86 /*NonOwningReference*/, 8 /*ulong*/, 8, false) + && verifier.VerifyVectorOfData(tablePos, 88 /*VectorOfNonOwningReferences*/, 8 /*ulong*/, false) + && verifier.VerifyField(tablePos, 90 /*AnyUniqueType*/, 1 /*MyGame.Example.AnyUniqueAliases*/, 1, false) + && verifier.VerifyUnion(tablePos, 90, 92 /*AnyUnique*/, MyGame.Example.AnyUniqueAliasesVerify.Verify, false) + && verifier.VerifyField(tablePos, 94 /*AnyAmbiguousType*/, 1 /*MyGame.Example.AnyAmbiguousAliases*/, 1, false) + && verifier.VerifyUnion(tablePos, 94, 96 /*AnyAmbiguous*/, MyGame.Example.AnyAmbiguousAliasesVerify.Verify, false) + && verifier.VerifyVectorOfData(tablePos, 98 /*VectorOfEnums*/, 1 /*MyGame.Example.Color*/, false) + && verifier.VerifyField(tablePos, 100 /*SignedEnum*/, 1 /*MyGame.Example.Race*/, 1, false) + && verifier.VerifyNestedBuffer(tablePos, 102 /*Testrequirednestedflatbuffer*/, MyGame.Example.MonsterVerify.Verify, false) + && verifier.VerifyVectorOfTables(tablePos, 104 /*ScalarKeySortedTables*/, MyGame.Example.StatVerify.Verify, false) + && verifier.VerifyField(tablePos, 106 /*NativeInline*/, 4 /*MyGame.Example.Test*/, 2, false) + && verifier.VerifyField(tablePos, 108 /*LongEnumNonEnumDefault*/, 8 /*MyGame.Example.LongEnum*/, 8, false) + && verifier.VerifyField(tablePos, 110 /*LongEnumNormalDefault*/, 8 /*MyGame.Example.LongEnum*/, 8, false) + && verifier.VerifyField(tablePos, 112 /*NanDefault*/, 4 /*float*/, 4, false) + && verifier.VerifyField(tablePos, 114 /*InfDefault*/, 4 /*float*/, 4, false) + && verifier.VerifyField(tablePos, 116 /*PositiveInfDefault*/, 4 /*float*/, 4, false) + && verifier.VerifyField(tablePos, 118 /*InfinityDefault*/, 4 /*float*/, 4, false) + && verifier.VerifyField(tablePos, 120 /*PositiveInfinityDefault*/, 4 /*float*/, 4, false) + && verifier.VerifyField(tablePos, 122 /*NegativeInfDefault*/, 4 /*float*/, 4, false) + && verifier.VerifyField(tablePos, 124 /*NegativeInfinityDefault*/, 4 /*float*/, 4, false) + && verifier.VerifyField(tablePos, 126 /*DoubleInfDefault*/, 8 /*double*/, 8, false) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/MyGame/Example/Monster.go b/tests/MyGame/Example/Monster.go index 5380e1350..cc6453b1a 100644 --- a/tests/MyGame/Example/Monster.go +++ b/tests/MyGame/Example/Monster.go @@ -4,8 +4,8 @@ package Example import ( "bytes" - "math" flatbuffers "github.com/google/flatbuffers/go" + "math" MyGame "MyGame" ) @@ -73,7 +73,9 @@ type MonsterT struct { } func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } + if t == nil { + return 0 + } nameOffset := flatbuffers.UOffsetT(0) if t.Name != "" { nameOffset = builder.CreateString(t.Name) @@ -83,7 +85,7 @@ func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { inventoryOffset = builder.CreateByteString(t.Inventory) } testOffset := t.Test.Pack(builder) - + test4Offset := flatbuffers.UOffsetT(0) if t.Test4 != nil { test4Length := len(t.Test4) @@ -242,9 +244,9 @@ func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { vectorOfNonOwningReferencesOffset = builder.EndVector(vectorOfNonOwningReferencesLength) } anyUniqueOffset := t.AnyUnique.Pack(builder) - + anyAmbiguousOffset := t.AnyAmbiguous.Pack(builder) - + vectorOfEnumsOffset := flatbuffers.UOffsetT(0) if t.VectorOfEnums != nil { vectorOfEnumsLength := len(t.VectorOfEnums) @@ -493,7 +495,9 @@ func (rcv *Monster) UnPackTo(t *MonsterT) { } func (rcv *Monster) UnPack() *MonsterT { - if rcv == nil { return nil } + if rcv == nil { + return nil + } t := &MonsterT{} rcv.UnPackTo(t) return t @@ -503,6 +507,8 @@ type Monster struct { _tab flatbuffers.Table } +const MonsterIdentifier = "MONS" + func GetRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Monster { n := flatbuffers.GetUOffsetT(buf[offset:]) x := &Monster{} @@ -510,6 +516,15 @@ func GetRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Monster { return x } +func FinishMonsterBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + identifierBytes := []byte(MonsterIdentifier) + builder.FinishWithFileIdentifier(offset, identifierBytes) +} + +func MonsterBufferHasIdentifier(buf []byte) bool { + return flatbuffers.BufferHasIdentifier(buf, MonsterIdentifier) +} + func GetSizePrefixedRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Monster { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) x := &Monster{} @@ -517,6 +532,15 @@ func GetSizePrefixedRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Mons return x } +func FinishSizePrefixedMonsterBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + identifierBytes := []byte(MonsterIdentifier) + builder.FinishSizePrefixedWithFileIdentifier(offset, identifierBytes) +} + +func SizePrefixedMonsterBufferHasIdentifier(buf []byte) bool { + return flatbuffers.SizePrefixedBufferHasIdentifier(buf, MonsterIdentifier) +} + func (rcv *Monster) Init(buf []byte, i flatbuffers.UOffsetT) { rcv._tab.Bytes = buf rcv._tab.Pos = i @@ -574,18 +598,18 @@ func (rcv *Monster) Name() []byte { func MonsterKeyCompare(o1, o2 flatbuffers.UOffsetT, buf []byte) bool { obj1 := &Monster{} obj2 := &Monster{} - obj1.Init(buf, flatbuffers.UOffsetT(len(buf)) - o1) - obj2.Init(buf, flatbuffers.UOffsetT(len(buf)) - o2) + obj1.Init(buf, flatbuffers.UOffsetT(len(buf))-o1) + obj2.Init(buf, flatbuffers.UOffsetT(len(buf))-o2) return string(obj1.Name()) < string(obj2.Name()) } func (rcv *Monster) LookupByKey(key string, vectorLocation flatbuffers.UOffsetT, buf []byte) bool { - span := flatbuffers.GetUOffsetT(buf[vectorLocation - 4:]) + span := flatbuffers.GetUOffsetT(buf[vectorLocation-4:]) start := flatbuffers.UOffsetT(0) bKey := []byte(key) for span != 0 { middle := span / 2 - tableOffset := flatbuffers.GetIndirectOffset(buf, vectorLocation+ 4 * (start + middle)) + tableOffset := flatbuffers.GetIndirectOffset(buf, vectorLocation+4*(start+middle)) obj := &Monster{} obj.Init(buf, tableOffset) comp := bytes.Compare(obj.Name(), bKey) @@ -720,7 +744,7 @@ func (rcv *Monster) Testarrayoftables(obj *Monster, j int) bool { return false } -func (rcv *Monster) TestarrayoftablesByKey(obj *Monster, key string) bool{ +func (rcv *Monster) TestarrayoftablesByKey(obj *Monster, key string) bool { o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) if o != 0 { x := rcv._tab.Vector(o) @@ -1135,7 +1159,7 @@ func (rcv *Monster) VectorOfReferrables(obj *Referrable, j int) bool { return false } -func (rcv *Monster) VectorOfReferrablesByKey(obj *Referrable, key uint64) bool{ +func (rcv *Monster) VectorOfReferrablesByKey(obj *Referrable, key uint64) bool { o := flatbuffers.UOffsetT(rcv._tab.Offset(74)) if o != 0 { x := rcv._tab.Vector(o) @@ -1202,7 +1226,7 @@ func (rcv *Monster) VectorOfStrongReferrables(obj *Referrable, j int) bool { return false } -func (rcv *Monster) VectorOfStrongReferrablesByKey(obj *Referrable, key uint64) bool{ +func (rcv *Monster) VectorOfStrongReferrablesByKey(obj *Referrable, key uint64) bool { o := flatbuffers.UOffsetT(rcv._tab.Offset(80)) if o != 0 { x := rcv._tab.Vector(o) @@ -1429,7 +1453,7 @@ func (rcv *Monster) ScalarKeySortedTables(obj *Stat, j int) bool { return false } -func (rcv *Monster) ScalarKeySortedTablesByKey(obj *Stat, key uint16) bool{ +func (rcv *Monster) ScalarKeySortedTablesByKey(obj *Stat, key uint16) bool { o := flatbuffers.UOffsetT(rcv._tab.Offset(104)) if o != 0 { x := rcv._tab.Vector(o) diff --git a/tests/MyGame/Example/Monster.py b/tests/MyGame/Example/Monster.py index 03dda3b66..bde02b4ab 100644 --- a/tests/MyGame/Example/Monster.py +++ b/tests/MyGame/Example/Monster.py @@ -214,7 +214,7 @@ class Monster(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30)) if o != 0: from MyGame.Example.Monster import Monster - return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o)) + return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o)) return 0 # Monster @@ -751,7 +751,7 @@ class Monster(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102)) if o != 0: from MyGame.Example.Monster import Monster - return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o)) + return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o)) return 0 # Monster @@ -872,63 +872,120 @@ class Monster(object): return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos) return float('inf') -def MonsterStart(builder): builder.StartObject(62) +def MonsterStart(builder): + return builder.StartObject(62) + def Start(builder): return MonsterStart(builder) -def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0) + +def MonsterAddPos(builder, pos): + return builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0) + def AddPos(builder, pos): return MonsterAddPos(builder, pos) -def MonsterAddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150) + +def MonsterAddMana(builder, mana): + return builder.PrependInt16Slot(1, mana, 150) + def AddMana(builder, mana): return MonsterAddMana(builder, mana) -def MonsterAddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100) + +def MonsterAddHp(builder, hp): + return builder.PrependInt16Slot(2, hp, 100) + def AddHp(builder, hp): return MonsterAddHp(builder, hp) -def MonsterAddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + +def MonsterAddName(builder, name): + return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + def AddName(builder, name): return MonsterAddName(builder, name) -def MonsterAddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0) + +def MonsterAddInventory(builder, inventory): + return builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0) + def AddInventory(builder, inventory): return MonsterAddInventory(builder, inventory) -def MonsterStartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1) + +def MonsterStartInventoryVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + def StartInventoryVector(builder, numElems): return MonsterStartInventoryVector(builder, numElems) -def MonsterAddColor(builder, color): builder.PrependUint8Slot(6, color, 8) + +def MonsterAddColor(builder, color): + return builder.PrependUint8Slot(6, color, 8) + def AddColor(builder, color): return MonsterAddColor(builder, color) -def MonsterAddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0) + +def MonsterAddTestType(builder, testType): + return builder.PrependUint8Slot(7, testType, 0) + def AddTestType(builder, testType): return MonsterAddTestType(builder, testType) -def MonsterAddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0) + +def MonsterAddTest(builder, test): + return builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0) + def AddTest(builder, test): return MonsterAddTest(builder, test) -def MonsterAddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0) + +def MonsterAddTest4(builder, test4): + return builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0) + def AddTest4(builder, test4): return MonsterAddTest4(builder, test4) -def MonsterStartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2) + +def MonsterStartTest4Vector(builder, numElems): + return builder.StartVector(4, numElems, 2) + def StartTest4Vector(builder, numElems): return MonsterStartTest4Vector(builder, numElems) -def MonsterAddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0) + +def MonsterAddTestarrayofstring(builder, testarrayofstring): + return builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0) + def AddTestarrayofstring(builder, testarrayofstring): return MonsterAddTestarrayofstring(builder, testarrayofstring) -def MonsterStartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def MonsterStartTestarrayofstringVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartTestarrayofstringVector(builder, numElems): return MonsterStartTestarrayofstringVector(builder, numElems) -def MonsterAddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0) + +def MonsterAddTestarrayoftables(builder, testarrayoftables): + return builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0) + def AddTestarrayoftables(builder, testarrayoftables): return MonsterAddTestarrayoftables(builder, testarrayoftables) -def MonsterStartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def MonsterStartTestarrayoftablesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartTestarrayoftablesVector(builder, numElems): return MonsterStartTestarrayoftablesVector(builder, numElems) -def MonsterAddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0) + +def MonsterAddEnemy(builder, enemy): + return builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0) + def AddEnemy(builder, enemy): return MonsterAddEnemy(builder, enemy) -def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0) + +def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer): + return builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0) + def AddTestnestedflatbuffer(builder, testnestedflatbuffer): return MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer) -def MonsterStartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1) + +def MonsterStartTestnestedflatbufferVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + def StartTestnestedflatbufferVector(builder, numElems): return MonsterStartTestnestedflatbufferVector(builder, numElems) + def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes): builder.StartVector(1, len(bytes), 1) builder.head = builder.head - len(bytes) @@ -936,156 +993,306 @@ def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes): return builder.EndVector() def MakeTestnestedflatbufferVectorFromBytes(builder, bytes): return MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes) -def MonsterAddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0) +def MonsterAddTestempty(builder, testempty): + return builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0) + def AddTestempty(builder, testempty): return MonsterAddTestempty(builder, testempty) -def MonsterAddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0) + +def MonsterAddTestbool(builder, testbool): + return builder.PrependBoolSlot(15, testbool, 0) + def AddTestbool(builder, testbool): return MonsterAddTestbool(builder, testbool) -def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0) + +def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1): + return builder.PrependInt32Slot(16, testhashs32Fnv1, 0) + def AddTesthashs32Fnv1(builder, testhashs32Fnv1): return MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1) -def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0) + +def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1): + return builder.PrependUint32Slot(17, testhashu32Fnv1, 0) + def AddTesthashu32Fnv1(builder, testhashu32Fnv1): return MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1) -def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0) + +def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1): + return builder.PrependInt64Slot(18, testhashs64Fnv1, 0) + def AddTesthashs64Fnv1(builder, testhashs64Fnv1): return MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1) -def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0) + +def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1): + return builder.PrependUint64Slot(19, testhashu64Fnv1, 0) + def AddTesthashu64Fnv1(builder, testhashu64Fnv1): return MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1) -def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0) + +def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a): + return builder.PrependInt32Slot(20, testhashs32Fnv1a, 0) + def AddTesthashs32Fnv1a(builder, testhashs32Fnv1a): return MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a) -def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0) + +def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a): + return builder.PrependUint32Slot(21, testhashu32Fnv1a, 0) + def AddTesthashu32Fnv1a(builder, testhashu32Fnv1a): return MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a) -def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0) + +def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a): + return builder.PrependInt64Slot(22, testhashs64Fnv1a, 0) + def AddTesthashs64Fnv1a(builder, testhashs64Fnv1a): return MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a) -def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0) + +def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a): + return builder.PrependUint64Slot(23, testhashu64Fnv1a, 0) + def AddTesthashu64Fnv1a(builder, testhashu64Fnv1a): return MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a) -def MonsterAddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0) + +def MonsterAddTestarrayofbools(builder, testarrayofbools): + return builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0) + def AddTestarrayofbools(builder, testarrayofbools): return MonsterAddTestarrayofbools(builder, testarrayofbools) -def MonsterStartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1) + +def MonsterStartTestarrayofboolsVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + def StartTestarrayofboolsVector(builder, numElems): return MonsterStartTestarrayofboolsVector(builder, numElems) -def MonsterAddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159) + +def MonsterAddTestf(builder, testf): + return builder.PrependFloat32Slot(25, testf, 3.14159) + def AddTestf(builder, testf): return MonsterAddTestf(builder, testf) -def MonsterAddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0) + +def MonsterAddTestf2(builder, testf2): + return builder.PrependFloat32Slot(26, testf2, 3.0) + def AddTestf2(builder, testf2): return MonsterAddTestf2(builder, testf2) -def MonsterAddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0) + +def MonsterAddTestf3(builder, testf3): + return builder.PrependFloat32Slot(27, testf3, 0.0) + def AddTestf3(builder, testf3): return MonsterAddTestf3(builder, testf3) -def MonsterAddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0) + +def MonsterAddTestarrayofstring2(builder, testarrayofstring2): + return builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0) + def AddTestarrayofstring2(builder, testarrayofstring2): return MonsterAddTestarrayofstring2(builder, testarrayofstring2) -def MonsterStartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def MonsterStartTestarrayofstring2Vector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartTestarrayofstring2Vector(builder, numElems): return MonsterStartTestarrayofstring2Vector(builder, numElems) -def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0) + +def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct): + return builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0) + def AddTestarrayofsortedstruct(builder, testarrayofsortedstruct): return MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct) -def MonsterStartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4) + +def MonsterStartTestarrayofsortedstructVector(builder, numElems): + return builder.StartVector(8, numElems, 4) + def StartTestarrayofsortedstructVector(builder, numElems): return MonsterStartTestarrayofsortedstructVector(builder, numElems) -def MonsterAddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0) + +def MonsterAddFlex(builder, flex): + return builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0) + def AddFlex(builder, flex): return MonsterAddFlex(builder, flex) -def MonsterStartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1) + +def MonsterStartFlexVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + def StartFlexVector(builder, numElems): return MonsterStartFlexVector(builder, numElems) -def MonsterAddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0) + +def MonsterAddTest5(builder, test5): + return builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0) + def AddTest5(builder, test5): return MonsterAddTest5(builder, test5) -def MonsterStartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2) + +def MonsterStartTest5Vector(builder, numElems): + return builder.StartVector(4, numElems, 2) + def StartTest5Vector(builder, numElems): return MonsterStartTest5Vector(builder, numElems) -def MonsterAddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0) + +def MonsterAddVectorOfLongs(builder, vectorOfLongs): + return builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0) + def AddVectorOfLongs(builder, vectorOfLongs): return MonsterAddVectorOfLongs(builder, vectorOfLongs) -def MonsterStartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8) + +def MonsterStartVectorOfLongsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + def StartVectorOfLongsVector(builder, numElems): return MonsterStartVectorOfLongsVector(builder, numElems) -def MonsterAddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0) + +def MonsterAddVectorOfDoubles(builder, vectorOfDoubles): + return builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0) + def AddVectorOfDoubles(builder, vectorOfDoubles): return MonsterAddVectorOfDoubles(builder, vectorOfDoubles) -def MonsterStartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8) + +def MonsterStartVectorOfDoublesVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + def StartVectorOfDoublesVector(builder, numElems): return MonsterStartVectorOfDoublesVector(builder, numElems) -def MonsterAddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0) + +def MonsterAddParentNamespaceTest(builder, parentNamespaceTest): + return builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0) + def AddParentNamespaceTest(builder, parentNamespaceTest): return MonsterAddParentNamespaceTest(builder, parentNamespaceTest) -def MonsterAddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0) + +def MonsterAddVectorOfReferrables(builder, vectorOfReferrables): + return builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0) + def AddVectorOfReferrables(builder, vectorOfReferrables): return MonsterAddVectorOfReferrables(builder, vectorOfReferrables) -def MonsterStartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def MonsterStartVectorOfReferrablesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartVectorOfReferrablesVector(builder, numElems): return MonsterStartVectorOfReferrablesVector(builder, numElems) -def MonsterAddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0) + +def MonsterAddSingleWeakReference(builder, singleWeakReference): + return builder.PrependUint64Slot(36, singleWeakReference, 0) + def AddSingleWeakReference(builder, singleWeakReference): return MonsterAddSingleWeakReference(builder, singleWeakReference) -def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0) + +def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences): + return builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0) + def AddVectorOfWeakReferences(builder, vectorOfWeakReferences): return MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences) -def MonsterStartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8) + +def MonsterStartVectorOfWeakReferencesVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + def StartVectorOfWeakReferencesVector(builder, numElems): return MonsterStartVectorOfWeakReferencesVector(builder, numElems) -def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0) + +def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): + return builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0) + def AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): return MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables) -def MonsterStartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def MonsterStartVectorOfStrongReferrablesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartVectorOfStrongReferrablesVector(builder, numElems): return MonsterStartVectorOfStrongReferrablesVector(builder, numElems) -def MonsterAddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0) + +def MonsterAddCoOwningReference(builder, coOwningReference): + return builder.PrependUint64Slot(39, coOwningReference, 0) + def AddCoOwningReference(builder, coOwningReference): return MonsterAddCoOwningReference(builder, coOwningReference) -def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0) + +def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): + return builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0) + def AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): return MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences) -def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8) + +def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + def StartVectorOfCoOwningReferencesVector(builder, numElems): return MonsterStartVectorOfCoOwningReferencesVector(builder, numElems) -def MonsterAddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0) + +def MonsterAddNonOwningReference(builder, nonOwningReference): + return builder.PrependUint64Slot(41, nonOwningReference, 0) + def AddNonOwningReference(builder, nonOwningReference): return MonsterAddNonOwningReference(builder, nonOwningReference) -def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0) + +def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): + return builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0) + def AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): return MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences) -def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8) + +def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + def StartVectorOfNonOwningReferencesVector(builder, numElems): return MonsterStartVectorOfNonOwningReferencesVector(builder, numElems) -def MonsterAddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0) + +def MonsterAddAnyUniqueType(builder, anyUniqueType): + return builder.PrependUint8Slot(43, anyUniqueType, 0) + def AddAnyUniqueType(builder, anyUniqueType): return MonsterAddAnyUniqueType(builder, anyUniqueType) -def MonsterAddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0) + +def MonsterAddAnyUnique(builder, anyUnique): + return builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0) + def AddAnyUnique(builder, anyUnique): return MonsterAddAnyUnique(builder, anyUnique) -def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0) + +def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType): + return builder.PrependUint8Slot(45, anyAmbiguousType, 0) + def AddAnyAmbiguousType(builder, anyAmbiguousType): return MonsterAddAnyAmbiguousType(builder, anyAmbiguousType) -def MonsterAddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0) + +def MonsterAddAnyAmbiguous(builder, anyAmbiguous): + return builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0) + def AddAnyAmbiguous(builder, anyAmbiguous): return MonsterAddAnyAmbiguous(builder, anyAmbiguous) -def MonsterAddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0) + +def MonsterAddVectorOfEnums(builder, vectorOfEnums): + return builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0) + def AddVectorOfEnums(builder, vectorOfEnums): return MonsterAddVectorOfEnums(builder, vectorOfEnums) -def MonsterStartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1) + +def MonsterStartVectorOfEnumsVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + def StartVectorOfEnumsVector(builder, numElems): return MonsterStartVectorOfEnumsVector(builder, numElems) -def MonsterAddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1) + +def MonsterAddSignedEnum(builder, signedEnum): + return builder.PrependInt8Slot(48, signedEnum, -1) + def AddSignedEnum(builder, signedEnum): return MonsterAddSignedEnum(builder, signedEnum) -def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0) + +def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): + return builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0) + def AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): return MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer) -def MonsterStartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1) + +def MonsterStartTestrequirednestedflatbufferVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + def StartTestrequirednestedflatbufferVector(builder, numElems): return MonsterStartTestrequirednestedflatbufferVector(builder, numElems) + def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes): builder.StartVector(1, len(bytes), 1) builder.head = builder.head - len(bytes) @@ -1093,48 +1300,90 @@ def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes): return builder.EndVector() def MakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes): return MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes) -def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0) +def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables): + return builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0) + def AddScalarKeySortedTables(builder, scalarKeySortedTables): return MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables) -def MonsterStartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def MonsterStartScalarKeySortedTablesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartScalarKeySortedTablesVector(builder, numElems): return MonsterStartScalarKeySortedTablesVector(builder, numElems) -def MonsterAddNativeInline(builder, nativeInline): builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0) + +def MonsterAddNativeInline(builder, nativeInline): + return builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0) + def AddNativeInline(builder, nativeInline): return MonsterAddNativeInline(builder, nativeInline) -def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault): builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0) + +def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault): + return builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0) + def AddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault): return MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault) -def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault): builder.PrependUint64Slot(53, longEnumNormalDefault, 2) + +def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault): + return builder.PrependUint64Slot(53, longEnumNormalDefault, 2) + def AddLongEnumNormalDefault(builder, longEnumNormalDefault): return MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault) -def MonsterAddNanDefault(builder, nanDefault): builder.PrependFloat32Slot(54, nanDefault, float('nan')) + +def MonsterAddNanDefault(builder, nanDefault): + return builder.PrependFloat32Slot(54, nanDefault, float('nan')) + def AddNanDefault(builder, nanDefault): return MonsterAddNanDefault(builder, nanDefault) -def MonsterAddInfDefault(builder, infDefault): builder.PrependFloat32Slot(55, infDefault, float('inf')) + +def MonsterAddInfDefault(builder, infDefault): + return builder.PrependFloat32Slot(55, infDefault, float('inf')) + def AddInfDefault(builder, infDefault): return MonsterAddInfDefault(builder, infDefault) -def MonsterAddPositiveInfDefault(builder, positiveInfDefault): builder.PrependFloat32Slot(56, positiveInfDefault, float('inf')) + +def MonsterAddPositiveInfDefault(builder, positiveInfDefault): + return builder.PrependFloat32Slot(56, positiveInfDefault, float('inf')) + def AddPositiveInfDefault(builder, positiveInfDefault): return MonsterAddPositiveInfDefault(builder, positiveInfDefault) -def MonsterAddInfinityDefault(builder, infinityDefault): builder.PrependFloat32Slot(57, infinityDefault, float('inf')) + +def MonsterAddInfinityDefault(builder, infinityDefault): + return builder.PrependFloat32Slot(57, infinityDefault, float('inf')) + def AddInfinityDefault(builder, infinityDefault): return MonsterAddInfinityDefault(builder, infinityDefault) -def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault): builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf')) + +def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault): + return builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf')) + def AddPositiveInfinityDefault(builder, positiveInfinityDefault): return MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault) -def MonsterAddNegativeInfDefault(builder, negativeInfDefault): builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf')) + +def MonsterAddNegativeInfDefault(builder, negativeInfDefault): + return builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf')) + def AddNegativeInfDefault(builder, negativeInfDefault): return MonsterAddNegativeInfDefault(builder, negativeInfDefault) -def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault): builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf')) + +def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault): + return builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf')) + def AddNegativeInfinityDefault(builder, negativeInfinityDefault): return MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault) -def MonsterAddDoubleInfDefault(builder, doubleInfDefault): builder.PrependFloat64Slot(61, doubleInfDefault, float('inf')) + +def MonsterAddDoubleInfDefault(builder, doubleInfDefault): + return builder.PrependFloat64Slot(61, doubleInfDefault, float('inf')) + def AddDoubleInfDefault(builder, doubleInfDefault): return MonsterAddDoubleInfDefault(builder, doubleInfDefault) -def MonsterEnd(builder): return builder.EndObject() + +def MonsterEnd(builder): + return builder.EndObject() + def End(builder): return MonsterEnd(builder) + import MyGame.Example.Ability import MyGame.Example.Any import MyGame.Example.AnyAmbiguousAliases diff --git a/tests/MyGame/Example/NestedUnion/NestedUnionTest.py b/tests/MyGame/Example/NestedUnion/NestedUnionTest.py index 9a3cbee22..33c2a4415 100644 --- a/tests/MyGame/Example/NestedUnion/NestedUnionTest.py +++ b/tests/MyGame/Example/NestedUnion/NestedUnionTest.py @@ -55,24 +55,42 @@ class NestedUnionTest(object): return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos) return 0 -def NestedUnionTestStart(builder): builder.StartObject(4) +def NestedUnionTestStart(builder): + return builder.StartObject(4) + def Start(builder): return NestedUnionTestStart(builder) -def NestedUnionTestAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + +def NestedUnionTestAddName(builder, name): + return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + def AddName(builder, name): return NestedUnionTestAddName(builder, name) -def NestedUnionTestAddDataType(builder, dataType): builder.PrependUint8Slot(1, dataType, 0) + +def NestedUnionTestAddDataType(builder, dataType): + return builder.PrependUint8Slot(1, dataType, 0) + def AddDataType(builder, dataType): return NestedUnionTestAddDataType(builder, dataType) -def NestedUnionTestAddData(builder, data): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0) + +def NestedUnionTestAddData(builder, data): + return builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0) + def AddData(builder, data): return NestedUnionTestAddData(builder, data) -def NestedUnionTestAddId(builder, id): builder.PrependInt16Slot(3, id, 0) + +def NestedUnionTestAddId(builder, id): + return builder.PrependInt16Slot(3, id, 0) + def AddId(builder, id): return NestedUnionTestAddId(builder, id) -def NestedUnionTestEnd(builder): return builder.EndObject() + +def NestedUnionTestEnd(builder): + return builder.EndObject() + def End(builder): return NestedUnionTestEnd(builder) + import MyGame.Example.NestedUnion.Any import MyGame.Example.NestedUnion.TestSimpleTableWithEnum import MyGame.Example.NestedUnion.Vec3 diff --git a/tests/MyGame/Example/NestedUnion/TestSimpleTableWithEnum.py b/tests/MyGame/Example/NestedUnion/TestSimpleTableWithEnum.py index 46ebc263c..b3ad74f76 100644 --- a/tests/MyGame/Example/NestedUnion/TestSimpleTableWithEnum.py +++ b/tests/MyGame/Example/NestedUnion/TestSimpleTableWithEnum.py @@ -31,16 +31,25 @@ class TestSimpleTableWithEnum(object): return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) return 2 -def TestSimpleTableWithEnumStart(builder): builder.StartObject(1) +def TestSimpleTableWithEnumStart(builder): + return builder.StartObject(1) + def Start(builder): return TestSimpleTableWithEnumStart(builder) -def TestSimpleTableWithEnumAddColor(builder, color): builder.PrependUint8Slot(0, color, 2) + +def TestSimpleTableWithEnumAddColor(builder, color): + return builder.PrependUint8Slot(0, color, 2) + def AddColor(builder, color): return TestSimpleTableWithEnumAddColor(builder, color) -def TestSimpleTableWithEnumEnd(builder): return builder.EndObject() + +def TestSimpleTableWithEnumEnd(builder): + return builder.EndObject() + def End(builder): return TestSimpleTableWithEnumEnd(builder) + class TestSimpleTableWithEnumT(object): # TestSimpleTableWithEnumT diff --git a/tests/MyGame/Example/NestedUnion/Vec3.py b/tests/MyGame/Example/NestedUnion/Vec3.py index f3bb75f26..915f58014 100644 --- a/tests/MyGame/Example/NestedUnion/Vec3.py +++ b/tests/MyGame/Example/NestedUnion/Vec3.py @@ -70,30 +70,54 @@ class Vec3(object): return obj return None -def Vec3Start(builder): builder.StartObject(6) +def Vec3Start(builder): + return builder.StartObject(6) + def Start(builder): return Vec3Start(builder) -def Vec3AddX(builder, x): builder.PrependFloat64Slot(0, x, 0.0) + +def Vec3AddX(builder, x): + return builder.PrependFloat64Slot(0, x, 0.0) + def AddX(builder, x): return Vec3AddX(builder, x) -def Vec3AddY(builder, y): builder.PrependFloat64Slot(1, y, 0.0) + +def Vec3AddY(builder, y): + return builder.PrependFloat64Slot(1, y, 0.0) + def AddY(builder, y): return Vec3AddY(builder, y) -def Vec3AddZ(builder, z): builder.PrependFloat64Slot(2, z, 0.0) + +def Vec3AddZ(builder, z): + return builder.PrependFloat64Slot(2, z, 0.0) + def AddZ(builder, z): return Vec3AddZ(builder, z) -def Vec3AddTest1(builder, test1): builder.PrependFloat64Slot(3, test1, 0.0) + +def Vec3AddTest1(builder, test1): + return builder.PrependFloat64Slot(3, test1, 0.0) + def AddTest1(builder, test1): return Vec3AddTest1(builder, test1) -def Vec3AddTest2(builder, test2): builder.PrependUint8Slot(4, test2, 0) + +def Vec3AddTest2(builder, test2): + return builder.PrependUint8Slot(4, test2, 0) + def AddTest2(builder, test2): return Vec3AddTest2(builder, test2) -def Vec3AddTest3(builder, test3): builder.PrependStructSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(test3), 0) + +def Vec3AddTest3(builder, test3): + return builder.PrependStructSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(test3), 0) + def AddTest3(builder, test3): return Vec3AddTest3(builder, test3) -def Vec3End(builder): return builder.EndObject() + +def Vec3End(builder): + return builder.EndObject() + def End(builder): return Vec3End(builder) + import MyGame.Example.NestedUnion.Test try: from typing import Optional diff --git a/tests/MyGame/Example/Referrable.cs b/tests/MyGame/Example/Referrable.cs index 095b1f6f2..c6434d265 100644 --- a/tests/MyGame/Example/Referrable.cs +++ b/tests/MyGame/Example/Referrable.cs @@ -92,4 +92,14 @@ public class ReferrableT } +static public class ReferrableVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyField(tablePos, 4 /*Id*/, 8 /*ulong*/, 8, false) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/MyGame/Example/Referrable.go b/tests/MyGame/Example/Referrable.go index 0b14beb2e..f6248bb7e 100644 --- a/tests/MyGame/Example/Referrable.go +++ b/tests/MyGame/Example/Referrable.go @@ -11,7 +11,9 @@ type ReferrableT struct { } func (t *ReferrableT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } + if t == nil { + return 0 + } ReferrableStart(builder) ReferrableAddId(builder, t.Id) return ReferrableEnd(builder) @@ -22,7 +24,9 @@ func (rcv *Referrable) UnPackTo(t *ReferrableT) { } func (rcv *Referrable) UnPack() *ReferrableT { - if rcv == nil { return nil } + if rcv == nil { + return nil + } t := &ReferrableT{} rcv.UnPackTo(t) return t @@ -39,6 +43,10 @@ func GetRootAsReferrable(buf []byte, offset flatbuffers.UOffsetT) *Referrable { return x } +func FinishReferrableBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + func GetSizePrefixedRootAsReferrable(buf []byte, offset flatbuffers.UOffsetT) *Referrable { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) x := &Referrable{} @@ -46,6 +54,10 @@ func GetSizePrefixedRootAsReferrable(buf []byte, offset flatbuffers.UOffsetT) *R return x } +func FinishSizePrefixedReferrableBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + func (rcv *Referrable) Init(buf []byte, i flatbuffers.UOffsetT) { rcv._tab.Bytes = buf rcv._tab.Pos = i @@ -70,17 +82,17 @@ func (rcv *Referrable) MutateId(n uint64) bool { func ReferrableKeyCompare(o1, o2 flatbuffers.UOffsetT, buf []byte) bool { obj1 := &Referrable{} obj2 := &Referrable{} - obj1.Init(buf, flatbuffers.UOffsetT(len(buf)) - o1) - obj2.Init(buf, flatbuffers.UOffsetT(len(buf)) - o2) + obj1.Init(buf, flatbuffers.UOffsetT(len(buf))-o1) + obj2.Init(buf, flatbuffers.UOffsetT(len(buf))-o2) return obj1.Id() < obj2.Id() } func (rcv *Referrable) LookupByKey(key uint64, vectorLocation flatbuffers.UOffsetT, buf []byte) bool { - span := flatbuffers.GetUOffsetT(buf[vectorLocation - 4:]) + span := flatbuffers.GetUOffsetT(buf[vectorLocation-4:]) start := flatbuffers.UOffsetT(0) for span != 0 { middle := span / 2 - tableOffset := flatbuffers.GetIndirectOffset(buf, vectorLocation+ 4 * (start + middle)) + tableOffset := flatbuffers.GetIndirectOffset(buf, vectorLocation+4*(start+middle)) obj := &Referrable{} obj.Init(buf, tableOffset) val := obj.Id() diff --git a/tests/MyGame/Example/Referrable.py b/tests/MyGame/Example/Referrable.py index 5fd1e24a2..e5081e1ae 100644 --- a/tests/MyGame/Example/Referrable.py +++ b/tests/MyGame/Example/Referrable.py @@ -35,16 +35,25 @@ class Referrable(object): return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos) return 0 -def ReferrableStart(builder): builder.StartObject(1) +def ReferrableStart(builder): + return builder.StartObject(1) + def Start(builder): return ReferrableStart(builder) -def ReferrableAddId(builder, id): builder.PrependUint64Slot(0, id, 0) + +def ReferrableAddId(builder, id): + return builder.PrependUint64Slot(0, id, 0) + def AddId(builder, id): return ReferrableAddId(builder, id) -def ReferrableEnd(builder): return builder.EndObject() + +def ReferrableEnd(builder): + return builder.EndObject() + def End(builder): return ReferrableEnd(builder) + class ReferrableT(object): # ReferrableT diff --git a/tests/MyGame/Example/Stat.cs b/tests/MyGame/Example/Stat.cs index dc29bd48f..c73f2aaea 100644 --- a/tests/MyGame/Example/Stat.cs +++ b/tests/MyGame/Example/Stat.cs @@ -117,4 +117,16 @@ public class StatT } +static public class StatVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyString(tablePos, 4 /*Id*/, false) + && verifier.VerifyField(tablePos, 6 /*Val*/, 8 /*long*/, 8, false) + && verifier.VerifyField(tablePos, 8 /*Count*/, 2 /*ushort*/, 2, false) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/MyGame/Example/Stat.go b/tests/MyGame/Example/Stat.go index 9c0821419..5855abf16 100644 --- a/tests/MyGame/Example/Stat.go +++ b/tests/MyGame/Example/Stat.go @@ -13,7 +13,9 @@ type StatT struct { } func (t *StatT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } + if t == nil { + return 0 + } idOffset := flatbuffers.UOffsetT(0) if t.Id != "" { idOffset = builder.CreateString(t.Id) @@ -32,7 +34,9 @@ func (rcv *Stat) UnPackTo(t *StatT) { } func (rcv *Stat) UnPack() *StatT { - if rcv == nil { return nil } + if rcv == nil { + return nil + } t := &StatT{} rcv.UnPackTo(t) return t @@ -49,6 +53,10 @@ func GetRootAsStat(buf []byte, offset flatbuffers.UOffsetT) *Stat { return x } +func FinishStatBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + func GetSizePrefixedRootAsStat(buf []byte, offset flatbuffers.UOffsetT) *Stat { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) x := &Stat{} @@ -56,6 +64,10 @@ func GetSizePrefixedRootAsStat(buf []byte, offset flatbuffers.UOffsetT) *Stat { return x } +func FinishSizePrefixedStatBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + func (rcv *Stat) Init(buf []byte, i flatbuffers.UOffsetT) { rcv._tab.Bytes = buf rcv._tab.Pos = i @@ -100,17 +112,17 @@ func (rcv *Stat) MutateCount(n uint16) bool { func StatKeyCompare(o1, o2 flatbuffers.UOffsetT, buf []byte) bool { obj1 := &Stat{} obj2 := &Stat{} - obj1.Init(buf, flatbuffers.UOffsetT(len(buf)) - o1) - obj2.Init(buf, flatbuffers.UOffsetT(len(buf)) - o2) + obj1.Init(buf, flatbuffers.UOffsetT(len(buf))-o1) + obj2.Init(buf, flatbuffers.UOffsetT(len(buf))-o2) return obj1.Count() < obj2.Count() } func (rcv *Stat) LookupByKey(key uint16, vectorLocation flatbuffers.UOffsetT, buf []byte) bool { - span := flatbuffers.GetUOffsetT(buf[vectorLocation - 4:]) + span := flatbuffers.GetUOffsetT(buf[vectorLocation-4:]) start := flatbuffers.UOffsetT(0) for span != 0 { middle := span / 2 - tableOffset := flatbuffers.GetIndirectOffset(buf, vectorLocation+ 4 * (start + middle)) + tableOffset := flatbuffers.GetIndirectOffset(buf, vectorLocation+4*(start+middle)) obj := &Stat{} obj.Init(buf, tableOffset) val := obj.Count() diff --git a/tests/MyGame/Example/Stat.py b/tests/MyGame/Example/Stat.py index 471bc36ff..00ca1a468 100644 --- a/tests/MyGame/Example/Stat.py +++ b/tests/MyGame/Example/Stat.py @@ -49,22 +49,37 @@ class Stat(object): return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) return 0 -def StatStart(builder): builder.StartObject(3) +def StatStart(builder): + return builder.StartObject(3) + def Start(builder): return StatStart(builder) -def StatAddId(builder, id): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0) + +def StatAddId(builder, id): + return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0) + def AddId(builder, id): return StatAddId(builder, id) -def StatAddVal(builder, val): builder.PrependInt64Slot(1, val, 0) + +def StatAddVal(builder, val): + return builder.PrependInt64Slot(1, val, 0) + def AddVal(builder, val): return StatAddVal(builder, val) -def StatAddCount(builder, count): builder.PrependUint16Slot(2, count, 0) + +def StatAddCount(builder, count): + return builder.PrependUint16Slot(2, count, 0) + def AddCount(builder, count): return StatAddCount(builder, count) -def StatEnd(builder): return builder.EndObject() + +def StatEnd(builder): + return builder.EndObject() + def End(builder): return StatEnd(builder) + class StatT(object): # StatT diff --git a/tests/MyGame/Example/StructOfStructs.go b/tests/MyGame/Example/StructOfStructs.go index 22281b669..234c795e3 100644 --- a/tests/MyGame/Example/StructOfStructs.go +++ b/tests/MyGame/Example/StructOfStructs.go @@ -13,7 +13,9 @@ type StructOfStructsT struct { } func (t *StructOfStructsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } + if t == nil { + return 0 + } return CreateStructOfStructs(builder, t.A.Id, t.A.Distance, t.B.A, t.B.B, t.C.Id, t.C.Distance) } func (rcv *StructOfStructs) UnPackTo(t *StructOfStructsT) { @@ -23,7 +25,9 @@ func (rcv *StructOfStructs) UnPackTo(t *StructOfStructsT) { } func (rcv *StructOfStructs) UnPack() *StructOfStructsT { - if rcv == nil { return nil } + if rcv == nil { + return nil + } t := &StructOfStructsT{} rcv.UnPackTo(t) return t diff --git a/tests/MyGame/Example/StructOfStructsOfStructs.go b/tests/MyGame/Example/StructOfStructsOfStructs.go index b8f32a0dc..90094aa99 100644 --- a/tests/MyGame/Example/StructOfStructsOfStructs.go +++ b/tests/MyGame/Example/StructOfStructsOfStructs.go @@ -11,7 +11,9 @@ type StructOfStructsOfStructsT struct { } func (t *StructOfStructsOfStructsT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } + if t == nil { + return 0 + } return CreateStructOfStructsOfStructs(builder, t.A.A.Id, t.A.A.Distance, t.A.B.A, t.A.B.B, t.A.C.Id, t.A.C.Distance) } func (rcv *StructOfStructsOfStructs) UnPackTo(t *StructOfStructsOfStructsT) { @@ -19,7 +21,9 @@ func (rcv *StructOfStructsOfStructs) UnPackTo(t *StructOfStructsOfStructsT) { } func (rcv *StructOfStructsOfStructs) UnPack() *StructOfStructsOfStructsT { - if rcv == nil { return nil } + if rcv == nil { + return nil + } t := &StructOfStructsOfStructsT{} rcv.UnPackTo(t) return t diff --git a/tests/MyGame/Example/Test.go b/tests/MyGame/Example/Test.go index 149171171..d7efcf4f7 100644 --- a/tests/MyGame/Example/Test.go +++ b/tests/MyGame/Example/Test.go @@ -12,7 +12,9 @@ type TestT struct { } func (t *TestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } + if t == nil { + return 0 + } return CreateTest(builder, t.A, t.B) } func (rcv *Test) UnPackTo(t *TestT) { @@ -21,7 +23,9 @@ func (rcv *Test) UnPackTo(t *TestT) { } func (rcv *Test) UnPack() *TestT { - if rcv == nil { return nil } + if rcv == nil { + return nil + } t := &TestT{} rcv.UnPackTo(t) return t diff --git a/tests/MyGame/Example/TestSimpleTableWithEnum.cs b/tests/MyGame/Example/TestSimpleTableWithEnum.cs index 218411008..2a827a507 100644 --- a/tests/MyGame/Example/TestSimpleTableWithEnum.cs +++ b/tests/MyGame/Example/TestSimpleTableWithEnum.cs @@ -62,4 +62,14 @@ internal partial class TestSimpleTableWithEnumT } +static public class TestSimpleTableWithEnumVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyField(tablePos, 4 /*Color*/, 1 /*MyGame.Example.Color*/, 1, false) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/MyGame/Example/TestSimpleTableWithEnum.go b/tests/MyGame/Example/TestSimpleTableWithEnum.go index 553867fe4..f491ccd86 100644 --- a/tests/MyGame/Example/TestSimpleTableWithEnum.go +++ b/tests/MyGame/Example/TestSimpleTableWithEnum.go @@ -11,7 +11,9 @@ type TestSimpleTableWithEnumT struct { } func (t *TestSimpleTableWithEnumT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } + if t == nil { + return 0 + } TestSimpleTableWithEnumStart(builder) TestSimpleTableWithEnumAddColor(builder, t.Color) return TestSimpleTableWithEnumEnd(builder) @@ -22,7 +24,9 @@ func (rcv *TestSimpleTableWithEnum) UnPackTo(t *TestSimpleTableWithEnumT) { } func (rcv *TestSimpleTableWithEnum) UnPack() *TestSimpleTableWithEnumT { - if rcv == nil { return nil } + if rcv == nil { + return nil + } t := &TestSimpleTableWithEnumT{} rcv.UnPackTo(t) return t @@ -39,6 +43,10 @@ func GetRootAsTestSimpleTableWithEnum(buf []byte, offset flatbuffers.UOffsetT) * return x } +func FinishTestSimpleTableWithEnumBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + func GetSizePrefixedRootAsTestSimpleTableWithEnum(buf []byte, offset flatbuffers.UOffsetT) *TestSimpleTableWithEnum { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) x := &TestSimpleTableWithEnum{} @@ -46,6 +54,10 @@ func GetSizePrefixedRootAsTestSimpleTableWithEnum(buf []byte, offset flatbuffers return x } +func FinishSizePrefixedTestSimpleTableWithEnumBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + func (rcv *TestSimpleTableWithEnum) Init(buf []byte, i flatbuffers.UOffsetT) { rcv._tab.Bytes = buf rcv._tab.Pos = i diff --git a/tests/MyGame/Example/TestSimpleTableWithEnum.py b/tests/MyGame/Example/TestSimpleTableWithEnum.py index 9e58cc4b5..99e5c41bc 100644 --- a/tests/MyGame/Example/TestSimpleTableWithEnum.py +++ b/tests/MyGame/Example/TestSimpleTableWithEnum.py @@ -35,16 +35,25 @@ class TestSimpleTableWithEnum(object): return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) return 2 -def TestSimpleTableWithEnumStart(builder): builder.StartObject(1) +def TestSimpleTableWithEnumStart(builder): + return builder.StartObject(1) + def Start(builder): return TestSimpleTableWithEnumStart(builder) -def TestSimpleTableWithEnumAddColor(builder, color): builder.PrependUint8Slot(0, color, 2) + +def TestSimpleTableWithEnumAddColor(builder, color): + return builder.PrependUint8Slot(0, color, 2) + def AddColor(builder, color): return TestSimpleTableWithEnumAddColor(builder, color) -def TestSimpleTableWithEnumEnd(builder): return builder.EndObject() + +def TestSimpleTableWithEnumEnd(builder): + return builder.EndObject() + def End(builder): return TestSimpleTableWithEnumEnd(builder) + class TestSimpleTableWithEnumT(object): # TestSimpleTableWithEnumT diff --git a/tests/MyGame/Example/TypeAliases.cs b/tests/MyGame/Example/TypeAliases.cs index 0980db91b..e4eecf3e0 100644 --- a/tests/MyGame/Example/TypeAliases.cs +++ b/tests/MyGame/Example/TypeAliases.cs @@ -208,4 +208,25 @@ public class TypeAliasesT } +static public class TypeAliasesVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyField(tablePos, 4 /*I8*/, 1 /*sbyte*/, 1, false) + && verifier.VerifyField(tablePos, 6 /*U8*/, 1 /*byte*/, 1, false) + && verifier.VerifyField(tablePos, 8 /*I16*/, 2 /*short*/, 2, false) + && verifier.VerifyField(tablePos, 10 /*U16*/, 2 /*ushort*/, 2, false) + && verifier.VerifyField(tablePos, 12 /*I32*/, 4 /*int*/, 4, false) + && verifier.VerifyField(tablePos, 14 /*U32*/, 4 /*uint*/, 4, false) + && verifier.VerifyField(tablePos, 16 /*I64*/, 8 /*long*/, 8, false) + && verifier.VerifyField(tablePos, 18 /*U64*/, 8 /*ulong*/, 8, false) + && verifier.VerifyField(tablePos, 20 /*F32*/, 4 /*float*/, 4, false) + && verifier.VerifyField(tablePos, 22 /*F64*/, 8 /*double*/, 8, false) + && verifier.VerifyVectorOfData(tablePos, 24 /*V8*/, 1 /*sbyte*/, false) + && verifier.VerifyVectorOfData(tablePos, 26 /*Vf64*/, 8 /*double*/, false) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/MyGame/Example/TypeAliases.go b/tests/MyGame/Example/TypeAliases.go index 9ded35e6f..e13311ee3 100644 --- a/tests/MyGame/Example/TypeAliases.go +++ b/tests/MyGame/Example/TypeAliases.go @@ -22,7 +22,9 @@ type TypeAliasesT struct { } func (t *TypeAliasesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } + if t == nil { + return 0 + } v8Offset := flatbuffers.UOffsetT(0) if t.V8 != nil { v8Length := len(t.V8) @@ -81,7 +83,9 @@ func (rcv *TypeAliases) UnPackTo(t *TypeAliasesT) { } func (rcv *TypeAliases) UnPack() *TypeAliasesT { - if rcv == nil { return nil } + if rcv == nil { + return nil + } t := &TypeAliasesT{} rcv.UnPackTo(t) return t @@ -98,6 +102,10 @@ func GetRootAsTypeAliases(buf []byte, offset flatbuffers.UOffsetT) *TypeAliases return x } +func FinishTypeAliasesBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + func GetSizePrefixedRootAsTypeAliases(buf []byte, offset flatbuffers.UOffsetT) *TypeAliases { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) x := &TypeAliases{} @@ -105,6 +113,10 @@ func GetSizePrefixedRootAsTypeAliases(buf []byte, offset flatbuffers.UOffsetT) * return x } +func FinishSizePrefixedTypeAliasesBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + func (rcv *TypeAliases) Init(buf []byte, i flatbuffers.UOffsetT) { rcv._tab.Bytes = buf rcv._tab.Pos = i diff --git a/tests/MyGame/Example/TypeAliases.py b/tests/MyGame/Example/TypeAliases.py index b3020490a..8fb33b9d3 100644 --- a/tests/MyGame/Example/TypeAliases.py +++ b/tests/MyGame/Example/TypeAliases.py @@ -152,54 +152,102 @@ class TypeAliases(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) return o == 0 -def TypeAliasesStart(builder): builder.StartObject(12) +def TypeAliasesStart(builder): + return builder.StartObject(12) + def Start(builder): return TypeAliasesStart(builder) -def TypeAliasesAddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0) + +def TypeAliasesAddI8(builder, i8): + return builder.PrependInt8Slot(0, i8, 0) + def AddI8(builder, i8): return TypeAliasesAddI8(builder, i8) -def TypeAliasesAddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0) + +def TypeAliasesAddU8(builder, u8): + return builder.PrependUint8Slot(1, u8, 0) + def AddU8(builder, u8): return TypeAliasesAddU8(builder, u8) -def TypeAliasesAddI16(builder, i16): builder.PrependInt16Slot(2, i16, 0) + +def TypeAliasesAddI16(builder, i16): + return builder.PrependInt16Slot(2, i16, 0) + def AddI16(builder, i16): return TypeAliasesAddI16(builder, i16) -def TypeAliasesAddU16(builder, u16): builder.PrependUint16Slot(3, u16, 0) + +def TypeAliasesAddU16(builder, u16): + return builder.PrependUint16Slot(3, u16, 0) + def AddU16(builder, u16): return TypeAliasesAddU16(builder, u16) -def TypeAliasesAddI32(builder, i32): builder.PrependInt32Slot(4, i32, 0) + +def TypeAliasesAddI32(builder, i32): + return builder.PrependInt32Slot(4, i32, 0) + def AddI32(builder, i32): return TypeAliasesAddI32(builder, i32) -def TypeAliasesAddU32(builder, u32): builder.PrependUint32Slot(5, u32, 0) + +def TypeAliasesAddU32(builder, u32): + return builder.PrependUint32Slot(5, u32, 0) + def AddU32(builder, u32): return TypeAliasesAddU32(builder, u32) -def TypeAliasesAddI64(builder, i64): builder.PrependInt64Slot(6, i64, 0) + +def TypeAliasesAddI64(builder, i64): + return builder.PrependInt64Slot(6, i64, 0) + def AddI64(builder, i64): return TypeAliasesAddI64(builder, i64) -def TypeAliasesAddU64(builder, u64): builder.PrependUint64Slot(7, u64, 0) + +def TypeAliasesAddU64(builder, u64): + return builder.PrependUint64Slot(7, u64, 0) + def AddU64(builder, u64): return TypeAliasesAddU64(builder, u64) -def TypeAliasesAddF32(builder, f32): builder.PrependFloat32Slot(8, f32, 0.0) + +def TypeAliasesAddF32(builder, f32): + return builder.PrependFloat32Slot(8, f32, 0.0) + def AddF32(builder, f32): return TypeAliasesAddF32(builder, f32) -def TypeAliasesAddF64(builder, f64): builder.PrependFloat64Slot(9, f64, 0.0) + +def TypeAliasesAddF64(builder, f64): + return builder.PrependFloat64Slot(9, f64, 0.0) + def AddF64(builder, f64): return TypeAliasesAddF64(builder, f64) -def TypeAliasesAddV8(builder, v8): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0) + +def TypeAliasesAddV8(builder, v8): + return builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0) + def AddV8(builder, v8): return TypeAliasesAddV8(builder, v8) -def TypeAliasesStartV8Vector(builder, numElems): return builder.StartVector(1, numElems, 1) + +def TypeAliasesStartV8Vector(builder, numElems): + return builder.StartVector(1, numElems, 1) + def StartV8Vector(builder, numElems): return TypeAliasesStartV8Vector(builder, numElems) -def TypeAliasesAddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0) + +def TypeAliasesAddVf64(builder, vf64): + return builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0) + def AddVf64(builder, vf64): return TypeAliasesAddVf64(builder, vf64) -def TypeAliasesStartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8) + +def TypeAliasesStartVf64Vector(builder, numElems): + return builder.StartVector(8, numElems, 8) + def StartVf64Vector(builder, numElems): return TypeAliasesStartVf64Vector(builder, numElems) -def TypeAliasesEnd(builder): return builder.EndObject() + +def TypeAliasesEnd(builder): + return builder.EndObject() + def End(builder): return TypeAliasesEnd(builder) + try: from typing import List except: diff --git a/tests/MyGame/Example/Vec3.go b/tests/MyGame/Example/Vec3.go index 16a05cde8..ae0cb1e76 100644 --- a/tests/MyGame/Example/Vec3.go +++ b/tests/MyGame/Example/Vec3.go @@ -16,7 +16,9 @@ type Vec3T struct { } func (t *Vec3T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } + if t == nil { + return 0 + } return CreateVec3(builder, t.X, t.Y, t.Z, t.Test1, t.Test2, t.Test3.A, t.Test3.B) } func (rcv *Vec3) UnPackTo(t *Vec3T) { @@ -29,7 +31,9 @@ func (rcv *Vec3) UnPackTo(t *Vec3T) { } func (rcv *Vec3) UnPack() *Vec3T { - if rcv == nil { return nil } + if rcv == nil { + return nil + } t := &Vec3T{} rcv.UnPackTo(t) return t diff --git a/tests/MyGame/Example2/Monster.cs b/tests/MyGame/Example2/Monster.cs index 465f04d51..f9fa70060 100644 --- a/tests/MyGame/Example2/Monster.cs +++ b/tests/MyGame/Example2/Monster.cs @@ -47,4 +47,13 @@ public class MonsterT } +static public class MonsterVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/MyGame/Example2/Monster.go b/tests/MyGame/Example2/Monster.go index 792011f24..4062f7c2e 100644 --- a/tests/MyGame/Example2/Monster.go +++ b/tests/MyGame/Example2/Monster.go @@ -10,7 +10,9 @@ type MonsterT struct { } func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } + if t == nil { + return 0 + } MonsterStart(builder) return MonsterEnd(builder) } @@ -19,7 +21,9 @@ func (rcv *Monster) UnPackTo(t *MonsterT) { } func (rcv *Monster) UnPack() *MonsterT { - if rcv == nil { return nil } + if rcv == nil { + return nil + } t := &MonsterT{} rcv.UnPackTo(t) return t @@ -36,6 +40,10 @@ func GetRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Monster { return x } +func FinishMonsterBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + func GetSizePrefixedRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Monster { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) x := &Monster{} @@ -43,6 +51,10 @@ func GetSizePrefixedRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Mons return x } +func FinishSizePrefixedMonsterBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + func (rcv *Monster) Init(buf []byte, i flatbuffers.UOffsetT) { rcv._tab.Bytes = buf rcv._tab.Pos = i diff --git a/tests/MyGame/Example2/Monster.py b/tests/MyGame/Example2/Monster.py index 020efef73..965c4ffdc 100644 --- a/tests/MyGame/Example2/Monster.py +++ b/tests/MyGame/Example2/Monster.py @@ -28,13 +28,19 @@ class Monster(object): def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def MonsterStart(builder): builder.StartObject(0) +def MonsterStart(builder): + return builder.StartObject(0) + def Start(builder): return MonsterStart(builder) -def MonsterEnd(builder): return builder.EndObject() + +def MonsterEnd(builder): + return builder.EndObject() + def End(builder): return MonsterEnd(builder) + class MonsterT(object): # MonsterT diff --git a/tests/MyGame/InParentNamespace.cs b/tests/MyGame/InParentNamespace.cs index ca99f3e86..8416105f0 100644 --- a/tests/MyGame/InParentNamespace.cs +++ b/tests/MyGame/InParentNamespace.cs @@ -47,4 +47,13 @@ public class InParentNamespaceT } +static public class InParentNamespaceVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/MyGame/InParentNamespace.go b/tests/MyGame/InParentNamespace.go index 2c4a4e0e6..37c44c180 100644 --- a/tests/MyGame/InParentNamespace.go +++ b/tests/MyGame/InParentNamespace.go @@ -10,7 +10,9 @@ type InParentNamespaceT struct { } func (t *InParentNamespaceT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { - if t == nil { return 0 } + if t == nil { + return 0 + } InParentNamespaceStart(builder) return InParentNamespaceEnd(builder) } @@ -19,7 +21,9 @@ func (rcv *InParentNamespace) UnPackTo(t *InParentNamespaceT) { } func (rcv *InParentNamespace) UnPack() *InParentNamespaceT { - if rcv == nil { return nil } + if rcv == nil { + return nil + } t := &InParentNamespaceT{} rcv.UnPackTo(t) return t @@ -36,6 +40,10 @@ func GetRootAsInParentNamespace(buf []byte, offset flatbuffers.UOffsetT) *InPare return x } +func FinishInParentNamespaceBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + func GetSizePrefixedRootAsInParentNamespace(buf []byte, offset flatbuffers.UOffsetT) *InParentNamespace { n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) x := &InParentNamespace{} @@ -43,6 +51,10 @@ func GetSizePrefixedRootAsInParentNamespace(buf []byte, offset flatbuffers.UOffs return x } +func FinishSizePrefixedInParentNamespaceBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + func (rcv *InParentNamespace) Init(buf []byte, i flatbuffers.UOffsetT) { rcv._tab.Bytes = buf rcv._tab.Pos = i diff --git a/tests/MyGame/InParentNamespace.py b/tests/MyGame/InParentNamespace.py index 0914aa462..bd10e6955 100644 --- a/tests/MyGame/InParentNamespace.py +++ b/tests/MyGame/InParentNamespace.py @@ -28,13 +28,19 @@ class InParentNamespace(object): def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def InParentNamespaceStart(builder): builder.StartObject(0) +def InParentNamespaceStart(builder): + return builder.StartObject(0) + def Start(builder): return InParentNamespaceStart(builder) -def InParentNamespaceEnd(builder): return builder.EndObject() + +def InParentNamespaceEnd(builder): + return builder.EndObject() + def End(builder): return InParentNamespaceEnd(builder) + class InParentNamespaceT(object): # InParentNamespaceT diff --git a/tests/MyGame/MonsterExtra.cs b/tests/MyGame/MonsterExtra.cs index f5bd71f1a..c1061b6b2 100644 --- a/tests/MyGame/MonsterExtra.cs +++ b/tests/MyGame/MonsterExtra.cs @@ -17,6 +17,7 @@ public struct MonsterExtra : IFlatbufferObject public static MonsterExtra GetRootAsMonsterExtra(ByteBuffer _bb) { return GetRootAsMonsterExtra(_bb, new MonsterExtra()); } public static MonsterExtra GetRootAsMonsterExtra(ByteBuffer _bb, MonsterExtra obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); } public static bool MonsterExtraBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "MONE"); } + public static bool VerifyMonsterExtra(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("MONE", false, MonsterExtraVerify.Verify); } public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); } public MonsterExtra __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } @@ -206,4 +207,23 @@ public class MonsterExtraT } +static public class MonsterExtraVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyField(tablePos, 4 /*D0*/, 8 /*double*/, 8, false) + && verifier.VerifyField(tablePos, 6 /*D1*/, 8 /*double*/, 8, false) + && verifier.VerifyField(tablePos, 8 /*D2*/, 8 /*double*/, 8, false) + && verifier.VerifyField(tablePos, 10 /*D3*/, 8 /*double*/, 8, false) + && verifier.VerifyField(tablePos, 12 /*F0*/, 4 /*float*/, 4, false) + && verifier.VerifyField(tablePos, 14 /*F1*/, 4 /*float*/, 4, false) + && verifier.VerifyField(tablePos, 16 /*F2*/, 4 /*float*/, 4, false) + && verifier.VerifyField(tablePos, 18 /*F3*/, 4 /*float*/, 4, false) + && verifier.VerifyVectorOfData(tablePos, 20 /*Dvec*/, 8 /*double*/, false) + && verifier.VerifyVectorOfData(tablePos, 22 /*Fvec*/, 4 /*float*/, false) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/MyGame/MonsterExtra.py b/tests/MyGame/MonsterExtra.py index 90916523c..10e380b79 100644 --- a/tests/MyGame/MonsterExtra.py +++ b/tests/MyGame/MonsterExtra.py @@ -138,48 +138,90 @@ class MonsterExtra(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) return o == 0 -def MonsterExtraStart(builder): builder.StartObject(11) +def MonsterExtraStart(builder): + return builder.StartObject(11) + def Start(builder): return MonsterExtraStart(builder) -def MonsterExtraAddD0(builder, d0): builder.PrependFloat64Slot(0, d0, float('nan')) + +def MonsterExtraAddD0(builder, d0): + return builder.PrependFloat64Slot(0, d0, float('nan')) + def AddD0(builder, d0): return MonsterExtraAddD0(builder, d0) -def MonsterExtraAddD1(builder, d1): builder.PrependFloat64Slot(1, d1, float('nan')) + +def MonsterExtraAddD1(builder, d1): + return builder.PrependFloat64Slot(1, d1, float('nan')) + def AddD1(builder, d1): return MonsterExtraAddD1(builder, d1) -def MonsterExtraAddD2(builder, d2): builder.PrependFloat64Slot(2, d2, float('inf')) + +def MonsterExtraAddD2(builder, d2): + return builder.PrependFloat64Slot(2, d2, float('inf')) + def AddD2(builder, d2): return MonsterExtraAddD2(builder, d2) -def MonsterExtraAddD3(builder, d3): builder.PrependFloat64Slot(3, d3, float('-inf')) + +def MonsterExtraAddD3(builder, d3): + return builder.PrependFloat64Slot(3, d3, float('-inf')) + def AddD3(builder, d3): return MonsterExtraAddD3(builder, d3) -def MonsterExtraAddF0(builder, f0): builder.PrependFloat32Slot(4, f0, float('nan')) + +def MonsterExtraAddF0(builder, f0): + return builder.PrependFloat32Slot(4, f0, float('nan')) + def AddF0(builder, f0): return MonsterExtraAddF0(builder, f0) -def MonsterExtraAddF1(builder, f1): builder.PrependFloat32Slot(5, f1, float('nan')) + +def MonsterExtraAddF1(builder, f1): + return builder.PrependFloat32Slot(5, f1, float('nan')) + def AddF1(builder, f1): return MonsterExtraAddF1(builder, f1) -def MonsterExtraAddF2(builder, f2): builder.PrependFloat32Slot(6, f2, float('inf')) + +def MonsterExtraAddF2(builder, f2): + return builder.PrependFloat32Slot(6, f2, float('inf')) + def AddF2(builder, f2): return MonsterExtraAddF2(builder, f2) -def MonsterExtraAddF3(builder, f3): builder.PrependFloat32Slot(7, f3, float('-inf')) + +def MonsterExtraAddF3(builder, f3): + return builder.PrependFloat32Slot(7, f3, float('-inf')) + def AddF3(builder, f3): return MonsterExtraAddF3(builder, f3) -def MonsterExtraAddDvec(builder, dvec): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(dvec), 0) + +def MonsterExtraAddDvec(builder, dvec): + return builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(dvec), 0) + def AddDvec(builder, dvec): return MonsterExtraAddDvec(builder, dvec) -def MonsterExtraStartDvecVector(builder, numElems): return builder.StartVector(8, numElems, 8) + +def MonsterExtraStartDvecVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + def StartDvecVector(builder, numElems): return MonsterExtraStartDvecVector(builder, numElems) -def MonsterExtraAddFvec(builder, fvec): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0) + +def MonsterExtraAddFvec(builder, fvec): + return builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0) + def AddFvec(builder, fvec): return MonsterExtraAddFvec(builder, fvec) -def MonsterExtraStartFvecVector(builder, numElems): return builder.StartVector(4, numElems, 4) + +def MonsterExtraStartFvecVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + def StartFvecVector(builder, numElems): return MonsterExtraStartFvecVector(builder, numElems) -def MonsterExtraEnd(builder): return builder.EndObject() + +def MonsterExtraEnd(builder): + return builder.EndObject() + def End(builder): return MonsterExtraEnd(builder) + try: from typing import List except: diff --git a/tests/go_test.go b/tests/go_test.go index 7cbac1e5e..f230060a6 100644 --- a/tests/go_test.go +++ b/tests/go_test.go @@ -17,12 +17,12 @@ package main import ( - order "order" - pizza "Pizza" mygame "MyGame" // refers to generated code example "MyGame/Example" // refers to generated code + pizza "Pizza" "encoding/json" optional_scalars "optional_scalars" // refers to generated code + order "order" "bytes" "flag" @@ -140,7 +140,7 @@ func TestAll(t *testing.T) { // Verify that using the generated Go code builds a buffer without // returning errors: - generated, off := CheckGeneratedBuild(false, t.Fatalf) + generated, off := CheckGeneratedBuild(false, false, t.Fatalf) // Verify that the buffer generated by Go code is readable by the // generated Go code: @@ -148,6 +148,16 @@ func TestAll(t *testing.T) { CheckMutateBuffer(generated, off, false, t.Fatalf) CheckObjectAPI(generated, off, false, t.Fatalf) + // Generate the buffer again, with file identifier. + generated, off = CheckGeneratedBuild(false, true, t.Fatalf) + + // Check that this buffer with file identifier is usable + // and that the file identifier is correct. + CheckReadBuffer(generated, off, false, t.Fatalf) + CheckMutateBuffer(generated, off, false, t.Fatalf) + CheckObjectAPI(generated, off, false, t.Fatalf) + CheckFileIdentifier(generated, off, false, t.Fatalf) + // Verify that the buffer generated by C++ code is readable by the // generated Go code: monsterDataCpp, err := os.ReadFile(cppData) @@ -157,6 +167,7 @@ func TestAll(t *testing.T) { CheckReadBuffer(monsterDataCpp, 0, false, t.Fatalf) CheckMutateBuffer(monsterDataCpp, 0, false, t.Fatalf) CheckObjectAPI(monsterDataCpp, 0, false, t.Fatalf) + CheckFileIdentifier(monsterDataCpp, 0, false, t.Fatalf) // Verify that vtables are deduplicated when written: CheckVtableDeduplication(t.Fatalf) @@ -391,6 +402,31 @@ func CheckReadBuffer(buf []byte, offset flatbuffers.UOffsetT, sizePrefix bool, f } } +// CheckFileIdentifier checks the "MONS" file identifier +func CheckFileIdentifier(buf []byte, offset flatbuffers.UOffsetT, sizePrefix bool, fail func(string, ...interface{})) { + // Strip offset + buf = buf[offset:] + + var fileIdentifier string + var hasFileIdentifier bool + + if sizePrefix { + fileIdentifier = flatbuffers.GetSizePrefixedBufferIdentifier(buf) + hasFileIdentifier = example.SizePrefixedMonsterBufferHasIdentifier(buf) + } else { + fileIdentifier = flatbuffers.GetBufferIdentifier(buf) + hasFileIdentifier = example.MonsterBufferHasIdentifier(buf) + } + + expectedFileIdentifier := "MONS" + if fileIdentifier != expectedFileIdentifier { + fail("expected file identifier %q, got %q", expectedFileIdentifier, fileIdentifier) + } + if !hasFileIdentifier { + fail("did not find file identifier") + } +} + // CheckMutateBuffer checks that the given buffer can be mutated correctly // as the example Monster. Only available scalar values are mutated. func CheckMutateBuffer(org []byte, offset flatbuffers.UOffsetT, sizePrefix bool, fail func(string, ...interface{})) { @@ -1067,6 +1103,79 @@ func CheckByteLayout(fail func(string, ...interface{})) { 33, // value 0 }) + // test 16b: same as test 16, size prefixed + b = flatbuffers.NewBuilder(0) + b.StartObject(2) + b.PrependInt8Slot(0, 33, 0) + b.PrependInt16Slot(1, 66, 0) + off = b.EndObject() + b.FinishSizePrefixed(off) + + check([]byte{ + 20, 0, 0, 0, // size prefix + 12, 0, 0, 0, // root of table: points to vtable offset + + 8, 0, // vtable bytes + 8, 0, // end of object from here + 7, 0, // start of value 0 + 4, 0, // start of value 1 + + 8, 0, 0, 0, // offset for start of vtable (int32) + + 66, 0, // value 1 + 0, // padding + 33, // value 0 + }) + + // test 16c: same as test 16, with file identifier + b = flatbuffers.NewBuilder(0) + b.StartObject(2) + b.PrependInt8Slot(0, 33, 0) + b.PrependInt16Slot(1, 66, 0) + off = b.EndObject() + b.FinishWithFileIdentifier(off, []byte("TEST")) + + check([]byte{ + 16, 0, 0, 0, // root of table: points to vtable offset + 'T', 'E', 'S', 'T', // file identifier + + 8, 0, // vtable bytes + 8, 0, // end of object from here + 7, 0, // start of value 0 + 4, 0, // start of value 1 + + 8, 0, 0, 0, // offset for start of vtable (int32) + + 66, 0, // value 1 + 0, // padding + 33, // value 0 + }) + + // test 16d: same as test 16, size prefixed with file identifier + b = flatbuffers.NewBuilder(0) + b.StartObject(2) + b.PrependInt8Slot(0, 33, 0) + b.PrependInt16Slot(1, 66, 0) + off = b.EndObject() + b.FinishSizePrefixedWithFileIdentifier(off, []byte("TEST")) + + check([]byte{ + 24, 0, 0, 0, // size prefix + 16, 0, 0, 0, // root of table: points to vtable offset + 'T', 'E', 'S', 'T', // file identifier + + 8, 0, // vtable bytes + 8, 0, // end of object from here + 7, 0, // start of value 0 + 4, 0, // start of value 1 + + 8, 0, 0, 0, // offset for start of vtable (int32) + + 66, 0, // value 1 + 0, // padding + 33, // value 0 + }) + // test 17: one unfinished table and one finished table b = flatbuffers.NewBuilder(0) b.StartObject(2) @@ -1285,7 +1394,7 @@ func CheckGetRootAsForNonRootTable(fail func(string, ...interface{})) { } // CheckGeneratedBuild uses generated code to build the example Monster. -func CheckGeneratedBuild(sizePrefix bool, fail func(string, ...interface{})) ([]byte, flatbuffers.UOffsetT) { +func CheckGeneratedBuild(sizePrefix, fileIdentifier bool, fail func(string, ...interface{})) ([]byte, flatbuffers.UOffsetT) { b := flatbuffers.NewBuilder(0) str := b.CreateString("MyMonster") test1 := b.CreateString("test1") @@ -1329,10 +1438,18 @@ func CheckGeneratedBuild(sizePrefix bool, fail func(string, ...interface{})) ([] example.MonsterAddTestarrayofstring(b, testArrayOfString) mon := example.MonsterEnd(b) - if sizePrefix { - b.FinishSizePrefixed(mon) + if fileIdentifier { + if sizePrefix { + example.FinishSizePrefixedMonsterBuffer(b, mon) + } else { + example.FinishMonsterBuffer(b, mon) + } } else { - b.Finish(mon) + if sizePrefix { + b.FinishSizePrefixed(mon) + } else { + b.Finish(mon) + } } return b.Bytes, b.Head() @@ -1733,21 +1850,32 @@ func CheckParentNamespace(fail func(string, ...interface{})) { } func CheckSizePrefixedBuffer(fail func(string, ...interface{})) { - // Generate a size-prefixed flatbuffer - generated, off := CheckGeneratedBuild(true, fail) - - // Check that the size prefix is the size of monsterdata_go_wire.mon minus 4 - size := flatbuffers.GetSizePrefix(generated, off) - if size != 220 { - fail("mismatch between size prefix and expected size") - } + // Generate a size-prefixed flatbuffer, first without file identifier + generated, off := CheckGeneratedBuild(true, false, fail) // Check that the buffer can be used as expected CheckReadBuffer(generated, off, true, fail) CheckMutateBuffer(generated, off, true, fail) CheckObjectAPI(generated, off, true, fail) - // Write generated bfufer out to a file + // Now generate a size-prefixed flatbuffer with file identifier + generated, off = CheckGeneratedBuild(true, true, fail) + + // Check that the size prefix is the size of monsterdata_go_wire.mon, + // plus 4 bytes for padding + size := flatbuffers.GetSizePrefix(generated, off) + expectedSize := uint32(228) + if size != expectedSize { + fail("mismatch between size prefix (%d) and expected size (%d)", size, expectedSize) + } + + // Check that the buffer can be used as expected + CheckReadBuffer(generated, off, true, fail) + CheckMutateBuffer(generated, off, true, fail) + CheckObjectAPI(generated, off, true, fail) + CheckFileIdentifier(generated, off, true, fail) + + // Write generated buffer out to a file if err := os.WriteFile(outData+".sp", generated[off:], os.FileMode(0644)); err != nil { fail("failed to write file: %s", err) } @@ -2324,7 +2452,7 @@ func BenchmarkVtableDeduplication(b *testing.B) { // BenchmarkParseGold measures the speed of parsing the 'gold' data // used throughout this test suite. func BenchmarkParseGold(b *testing.B) { - buf, offset := CheckGeneratedBuild(false, b.Fatalf) + buf, offset := CheckGeneratedBuild(false, false, b.Fatalf) monster := example.GetRootAsMonster(buf, offset) // use these to prevent allocations: @@ -2386,7 +2514,7 @@ func BenchmarkParseGold(b *testing.B) { // BenchmarkBuildGold uses generated code to build the example Monster. func BenchmarkBuildGold(b *testing.B) { - buf, offset := CheckGeneratedBuild(false, b.Fatalf) + buf, offset := CheckGeneratedBuild(false, false, b.Fatalf) bytes_length := int64(len(buf[offset:])) reuse_str := "MyMonster" diff --git a/tests/monster_test_generated.py b/tests/monster_test_generated.py index b70c31a2f..36bbb6021 100644 --- a/tests/monster_test_generated.py +++ b/tests/monster_test_generated.py @@ -108,8 +108,12 @@ class InParentNamespace(object): def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def InParentNamespaceStart(builder): builder.StartObject(0) -def InParentNamespaceEnd(builder): return builder.EndObject() +def InParentNamespaceStart(builder): + return builder.StartObject(0) + +def InParentNamespaceEnd(builder): + return builder.EndObject() + class InParentNamespaceT(object): @@ -169,8 +173,12 @@ class Monster(object): def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def MonsterStart(builder): builder.StartObject(0) -def MonsterEnd(builder): return builder.EndObject() +def MonsterStart(builder): + return builder.StartObject(0) + +def MonsterEnd(builder): + return builder.EndObject() + class MonsterT(object): @@ -297,9 +305,15 @@ class TestSimpleTableWithEnum(object): return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) return 2 -def TestSimpleTableWithEnumStart(builder): builder.StartObject(1) -def TestSimpleTableWithEnumAddColor(builder, color): builder.PrependUint8Slot(0, color, 2) -def TestSimpleTableWithEnumEnd(builder): return builder.EndObject() +def TestSimpleTableWithEnumStart(builder): + return builder.StartObject(1) + +def TestSimpleTableWithEnumAddColor(builder, color): + return builder.PrependUint8Slot(0, color, 2) + +def TestSimpleTableWithEnumEnd(builder): + return builder.EndObject() + class TestSimpleTableWithEnumT(object): @@ -693,11 +707,21 @@ class Stat(object): return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) return 0 -def StatStart(builder): builder.StartObject(3) -def StatAddId(builder, id): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0) -def StatAddVal(builder, val): builder.PrependInt64Slot(1, val, 0) -def StatAddCount(builder, count): builder.PrependUint16Slot(2, count, 0) -def StatEnd(builder): return builder.EndObject() +def StatStart(builder): + return builder.StartObject(3) + +def StatAddId(builder, id): + return builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0) + +def StatAddVal(builder, val): + return builder.PrependInt64Slot(1, val, 0) + +def StatAddCount(builder, count): + return builder.PrependUint16Slot(2, count, 0) + +def StatEnd(builder): + return builder.EndObject() + class StatT(object): @@ -775,9 +799,15 @@ class Referrable(object): return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos) return 0 -def ReferrableStart(builder): builder.StartObject(1) -def ReferrableAddId(builder, id): builder.PrependUint64Slot(0, id, 0) -def ReferrableEnd(builder): return builder.EndObject() +def ReferrableStart(builder): + return builder.StartObject(1) + +def ReferrableAddId(builder, id): + return builder.PrependUint64Slot(0, id, 0) + +def ReferrableEnd(builder): + return builder.EndObject() + class ReferrableT(object): @@ -1021,7 +1051,7 @@ class Monster(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30)) if o != 0: from MyGame.Example.Monster import Monster - return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o)) + return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o)) return 0 # Monster @@ -1552,7 +1582,7 @@ class Monster(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102)) if o != 0: from MyGame.Example.Monster import Monster - return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o)) + return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o)) return 0 # Monster @@ -1671,99 +1701,265 @@ class Monster(object): return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos) return float('inf') -def MonsterStart(builder): builder.StartObject(62) -def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0) -def MonsterAddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150) -def MonsterAddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100) -def MonsterAddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) -def MonsterAddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0) -def MonsterStartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def MonsterAddColor(builder, color): builder.PrependUint8Slot(6, color, 8) -def MonsterAddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0) -def MonsterAddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0) -def MonsterAddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0) -def MonsterStartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2) -def MonsterAddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0) -def MonsterStartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def MonsterAddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0) -def MonsterStartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def MonsterAddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0) -def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0) -def MonsterStartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def MonsterStart(builder): + return builder.StartObject(62) + +def MonsterAddPos(builder, pos): + return builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0) + +def MonsterAddMana(builder, mana): + return builder.PrependInt16Slot(1, mana, 150) + +def MonsterAddHp(builder, hp): + return builder.PrependInt16Slot(2, hp, 100) + +def MonsterAddName(builder, name): + return builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + +def MonsterAddInventory(builder, inventory): + return builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0) + +def MonsterStartInventoryVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + +def MonsterAddColor(builder, color): + return builder.PrependUint8Slot(6, color, 8) + +def MonsterAddTestType(builder, testType): + return builder.PrependUint8Slot(7, testType, 0) + +def MonsterAddTest(builder, test): + return builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0) + +def MonsterAddTest4(builder, test4): + return builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0) + +def MonsterStartTest4Vector(builder, numElems): + return builder.StartVector(4, numElems, 2) + +def MonsterAddTestarrayofstring(builder, testarrayofstring): + return builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0) + +def MonsterStartTestarrayofstringVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def MonsterAddTestarrayoftables(builder, testarrayoftables): + return builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0) + +def MonsterStartTestarrayoftablesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def MonsterAddEnemy(builder, enemy): + return builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0) + +def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer): + return builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0) + +def MonsterStartTestnestedflatbufferVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes): builder.StartVector(1, len(bytes), 1) builder.head = builder.head - len(bytes) builder.Bytes[builder.head : builder.head + len(bytes)] = bytes return builder.EndVector() -def MonsterAddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0) -def MonsterAddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0) -def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0) -def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0) -def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0) -def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0) -def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0) -def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0) -def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0) -def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0) -def MonsterAddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0) -def MonsterStartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def MonsterAddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159) -def MonsterAddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0) -def MonsterAddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0) -def MonsterAddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0) -def MonsterStartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4) -def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0) -def MonsterStartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4) -def MonsterAddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0) -def MonsterStartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def MonsterAddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0) -def MonsterStartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2) -def MonsterAddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0) -def MonsterStartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def MonsterAddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0) -def MonsterStartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def MonsterAddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0) -def MonsterAddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0) -def MonsterStartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def MonsterAddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0) -def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0) -def MonsterStartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0) -def MonsterStartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def MonsterAddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0) -def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0) -def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def MonsterAddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0) -def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0) -def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def MonsterAddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0) -def MonsterAddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0) -def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0) -def MonsterAddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0) -def MonsterAddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0) -def MonsterStartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def MonsterAddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1) -def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0) -def MonsterStartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def MonsterAddTestempty(builder, testempty): + return builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0) + +def MonsterAddTestbool(builder, testbool): + return builder.PrependBoolSlot(15, testbool, 0) + +def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1): + return builder.PrependInt32Slot(16, testhashs32Fnv1, 0) + +def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1): + return builder.PrependUint32Slot(17, testhashu32Fnv1, 0) + +def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1): + return builder.PrependInt64Slot(18, testhashs64Fnv1, 0) + +def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1): + return builder.PrependUint64Slot(19, testhashu64Fnv1, 0) + +def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a): + return builder.PrependInt32Slot(20, testhashs32Fnv1a, 0) + +def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a): + return builder.PrependUint32Slot(21, testhashu32Fnv1a, 0) + +def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a): + return builder.PrependInt64Slot(22, testhashs64Fnv1a, 0) + +def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a): + return builder.PrependUint64Slot(23, testhashu64Fnv1a, 0) + +def MonsterAddTestarrayofbools(builder, testarrayofbools): + return builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0) + +def MonsterStartTestarrayofboolsVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + +def MonsterAddTestf(builder, testf): + return builder.PrependFloat32Slot(25, testf, 3.14159) + +def MonsterAddTestf2(builder, testf2): + return builder.PrependFloat32Slot(26, testf2, 3.0) + +def MonsterAddTestf3(builder, testf3): + return builder.PrependFloat32Slot(27, testf3, 0.0) + +def MonsterAddTestarrayofstring2(builder, testarrayofstring2): + return builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0) + +def MonsterStartTestarrayofstring2Vector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct): + return builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0) + +def MonsterStartTestarrayofsortedstructVector(builder, numElems): + return builder.StartVector(8, numElems, 4) + +def MonsterAddFlex(builder, flex): + return builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0) + +def MonsterStartFlexVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + +def MonsterAddTest5(builder, test5): + return builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0) + +def MonsterStartTest5Vector(builder, numElems): + return builder.StartVector(4, numElems, 2) + +def MonsterAddVectorOfLongs(builder, vectorOfLongs): + return builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0) + +def MonsterStartVectorOfLongsVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def MonsterAddVectorOfDoubles(builder, vectorOfDoubles): + return builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0) + +def MonsterStartVectorOfDoublesVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def MonsterAddParentNamespaceTest(builder, parentNamespaceTest): + return builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0) + +def MonsterAddVectorOfReferrables(builder, vectorOfReferrables): + return builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0) + +def MonsterStartVectorOfReferrablesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def MonsterAddSingleWeakReference(builder, singleWeakReference): + return builder.PrependUint64Slot(36, singleWeakReference, 0) + +def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences): + return builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0) + +def MonsterStartVectorOfWeakReferencesVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): + return builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0) + +def MonsterStartVectorOfStrongReferrablesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def MonsterAddCoOwningReference(builder, coOwningReference): + return builder.PrependUint64Slot(39, coOwningReference, 0) + +def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): + return builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0) + +def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def MonsterAddNonOwningReference(builder, nonOwningReference): + return builder.PrependUint64Slot(41, nonOwningReference, 0) + +def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): + return builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0) + +def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def MonsterAddAnyUniqueType(builder, anyUniqueType): + return builder.PrependUint8Slot(43, anyUniqueType, 0) + +def MonsterAddAnyUnique(builder, anyUnique): + return builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0) + +def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType): + return builder.PrependUint8Slot(45, anyAmbiguousType, 0) + +def MonsterAddAnyAmbiguous(builder, anyAmbiguous): + return builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0) + +def MonsterAddVectorOfEnums(builder, vectorOfEnums): + return builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0) + +def MonsterStartVectorOfEnumsVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + +def MonsterAddSignedEnum(builder, signedEnum): + return builder.PrependInt8Slot(48, signedEnum, -1) + +def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): + return builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0) + +def MonsterStartTestrequirednestedflatbufferVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes): builder.StartVector(1, len(bytes), 1) builder.head = builder.head - len(bytes) builder.Bytes[builder.head : builder.head + len(bytes)] = bytes return builder.EndVector() -def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0) -def MonsterStartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def MonsterAddNativeInline(builder, nativeInline): builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0) -def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault): builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0) -def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault): builder.PrependUint64Slot(53, longEnumNormalDefault, 2) -def MonsterAddNanDefault(builder, nanDefault): builder.PrependFloat32Slot(54, nanDefault, float('nan')) -def MonsterAddInfDefault(builder, infDefault): builder.PrependFloat32Slot(55, infDefault, float('inf')) -def MonsterAddPositiveInfDefault(builder, positiveInfDefault): builder.PrependFloat32Slot(56, positiveInfDefault, float('inf')) -def MonsterAddInfinityDefault(builder, infinityDefault): builder.PrependFloat32Slot(57, infinityDefault, float('inf')) -def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault): builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf')) -def MonsterAddNegativeInfDefault(builder, negativeInfDefault): builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf')) -def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault): builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf')) -def MonsterAddDoubleInfDefault(builder, doubleInfDefault): builder.PrependFloat64Slot(61, doubleInfDefault, float('inf')) -def MonsterEnd(builder): return builder.EndObject() +def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables): + return builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0) + +def MonsterStartScalarKeySortedTablesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def MonsterAddNativeInline(builder, nativeInline): + return builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0) + +def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault): + return builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0) + +def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault): + return builder.PrependUint64Slot(53, longEnumNormalDefault, 2) + +def MonsterAddNanDefault(builder, nanDefault): + return builder.PrependFloat32Slot(54, nanDefault, float('nan')) + +def MonsterAddInfDefault(builder, infDefault): + return builder.PrependFloat32Slot(55, infDefault, float('inf')) + +def MonsterAddPositiveInfDefault(builder, positiveInfDefault): + return builder.PrependFloat32Slot(56, positiveInfDefault, float('inf')) + +def MonsterAddInfinityDefault(builder, infinityDefault): + return builder.PrependFloat32Slot(57, infinityDefault, float('inf')) + +def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault): + return builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf')) + +def MonsterAddNegativeInfDefault(builder, negativeInfDefault): + return builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf')) + +def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault): + return builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf')) + +def MonsterAddDoubleInfDefault(builder, doubleInfDefault): + return builder.PrependFloat64Slot(61, doubleInfDefault, float('inf')) + +def MonsterEnd(builder): + return builder.EndObject() + try: from typing import List, Optional, Union @@ -2455,22 +2651,54 @@ class TypeAliases(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) return o == 0 -def TypeAliasesStart(builder): builder.StartObject(12) -def TypeAliasesAddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0) -def TypeAliasesAddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0) -def TypeAliasesAddI16(builder, i16): builder.PrependInt16Slot(2, i16, 0) -def TypeAliasesAddU16(builder, u16): builder.PrependUint16Slot(3, u16, 0) -def TypeAliasesAddI32(builder, i32): builder.PrependInt32Slot(4, i32, 0) -def TypeAliasesAddU32(builder, u32): builder.PrependUint32Slot(5, u32, 0) -def TypeAliasesAddI64(builder, i64): builder.PrependInt64Slot(6, i64, 0) -def TypeAliasesAddU64(builder, u64): builder.PrependUint64Slot(7, u64, 0) -def TypeAliasesAddF32(builder, f32): builder.PrependFloat32Slot(8, f32, 0.0) -def TypeAliasesAddF64(builder, f64): builder.PrependFloat64Slot(9, f64, 0.0) -def TypeAliasesAddV8(builder, v8): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0) -def TypeAliasesStartV8Vector(builder, numElems): return builder.StartVector(1, numElems, 1) -def TypeAliasesAddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0) -def TypeAliasesStartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8) -def TypeAliasesEnd(builder): return builder.EndObject() +def TypeAliasesStart(builder): + return builder.StartObject(12) + +def TypeAliasesAddI8(builder, i8): + return builder.PrependInt8Slot(0, i8, 0) + +def TypeAliasesAddU8(builder, u8): + return builder.PrependUint8Slot(1, u8, 0) + +def TypeAliasesAddI16(builder, i16): + return builder.PrependInt16Slot(2, i16, 0) + +def TypeAliasesAddU16(builder, u16): + return builder.PrependUint16Slot(3, u16, 0) + +def TypeAliasesAddI32(builder, i32): + return builder.PrependInt32Slot(4, i32, 0) + +def TypeAliasesAddU32(builder, u32): + return builder.PrependUint32Slot(5, u32, 0) + +def TypeAliasesAddI64(builder, i64): + return builder.PrependInt64Slot(6, i64, 0) + +def TypeAliasesAddU64(builder, u64): + return builder.PrependUint64Slot(7, u64, 0) + +def TypeAliasesAddF32(builder, f32): + return builder.PrependFloat32Slot(8, f32, 0.0) + +def TypeAliasesAddF64(builder, f64): + return builder.PrependFloat64Slot(9, f64, 0.0) + +def TypeAliasesAddV8(builder, v8): + return builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0) + +def TypeAliasesStartV8Vector(builder, numElems): + return builder.StartVector(1, numElems, 1) + +def TypeAliasesAddVf64(builder, vf64): + return builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0) + +def TypeAliasesStartVf64Vector(builder, numElems): + return builder.StartVector(8, numElems, 8) + +def TypeAliasesEnd(builder): + return builder.EndObject() + try: from typing import List diff --git a/tests/monsterdata_go_wire.mon.sp b/tests/monsterdata_go_wire.mon.sp index cf3019c03..daddcd0e6 100644 Binary files a/tests/monsterdata_go_wire.mon.sp and b/tests/monsterdata_go_wire.mon.sp differ diff --git a/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.cs b/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.cs index 8ec7b8d58..bfb8a8a28 100644 --- a/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.cs +++ b/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.cs @@ -62,4 +62,14 @@ public class TableInNestedNST } +static public class TableInNestedNSVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyField(tablePos, 4 /*Foo*/, 4 /*int*/, 4, false) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/namespace_test/NamespaceA/NamespaceB/UnionInNestedNS.cs b/tests/namespace_test/NamespaceA/NamespaceB/UnionInNestedNS.cs index 08bc431e2..8105c3b0e 100644 --- a/tests/namespace_test/NamespaceA/NamespaceB/UnionInNestedNS.cs +++ b/tests/namespace_test/NamespaceA/NamespaceB/UnionInNestedNS.cs @@ -33,6 +33,25 @@ public class UnionInNestedNSUnion { } } + + +static public class UnionInNestedNSVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos) + { + bool result = true; + switch((UnionInNestedNS)typeId) + { + case UnionInNestedNS.TableInNestedNS: + result = NamespaceA.NamespaceB.TableInNestedNSVerify.Verify(verifier, tablePos); + break; + default: result = true; + break; + } + return result; + } +} + public class UnionInNestedNSUnion_JsonConverter : Newtonsoft.Json.JsonConverter { public override bool CanConvert(System.Type objectType) { return objectType == typeof(UnionInNestedNSUnion) || objectType == typeof(System.Collections.Generic.List); diff --git a/tests/namespace_test/NamespaceA/SecondTableInA.cs b/tests/namespace_test/NamespaceA/SecondTableInA.cs index 7e7556cdc..b6ea91a9d 100644 --- a/tests/namespace_test/NamespaceA/SecondTableInA.cs +++ b/tests/namespace_test/NamespaceA/SecondTableInA.cs @@ -62,4 +62,14 @@ public class SecondTableInAT } +static public class SecondTableInAVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyTable(tablePos, 4 /*ReferToC*/, NamespaceC.TableInCVerify.Verify, false) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/namespace_test/NamespaceA/TableInFirstNS.cs b/tests/namespace_test/NamespaceA/TableInFirstNS.cs index 5c5e7b01f..202983ab3 100644 --- a/tests/namespace_test/NamespaceA/TableInFirstNS.cs +++ b/tests/namespace_test/NamespaceA/TableInFirstNS.cs @@ -116,4 +116,18 @@ public class TableInFirstNST } +static public class TableInFirstNSVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyTable(tablePos, 4 /*FooTable*/, NamespaceA.NamespaceB.TableInNestedNSVerify.Verify, false) + && verifier.VerifyField(tablePos, 6 /*FooEnum*/, 1 /*NamespaceA.NamespaceB.EnumInNestedNS*/, 1, false) + && verifier.VerifyField(tablePos, 8 /*FooUnionType*/, 1 /*NamespaceA.NamespaceB.UnionInNestedNS*/, 1, false) + && verifier.VerifyUnion(tablePos, 8, 10 /*FooUnion*/, NamespaceA.NamespaceB.UnionInNestedNSVerify.Verify, false) + && verifier.VerifyField(tablePos, 12 /*FooStruct*/, 8 /*NamespaceA.NamespaceB.StructInNestedNS*/, 4, false) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/namespace_test/NamespaceC/TableInC.cs b/tests/namespace_test/NamespaceC/TableInC.cs index 42714d2a4..5cc60d045 100644 --- a/tests/namespace_test/NamespaceC/TableInC.cs +++ b/tests/namespace_test/NamespaceC/TableInC.cs @@ -72,4 +72,15 @@ public class TableInCT } +static public class TableInCVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyTable(tablePos, 4 /*ReferToA1*/, NamespaceA.TableInFirstNSVerify.Verify, false) + && verifier.VerifyTable(tablePos, 6 /*ReferToA2*/, NamespaceA.SecondTableInAVerify.Verify, false) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/nested_namespace_test/nested_namespace_test3_generated.cs b/tests/nested_namespace_test/nested_namespace_test3_generated.cs index b26aae0a2..6927bc390 100644 --- a/tests/nested_namespace_test/nested_namespace_test3_generated.cs +++ b/tests/nested_namespace_test/nested_namespace_test3_generated.cs @@ -62,4 +62,14 @@ public class ColorTestTableT } +static public class ColorTestTableVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyField(tablePos, 4 /*Color*/, 1 /*global::NamespaceB.Color*/, 1, false) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/optional_scalars/ScalarStuff.cs b/tests/optional_scalars/ScalarStuff.cs index ec2388b34..74bfb61ff 100644 --- a/tests/optional_scalars/ScalarStuff.cs +++ b/tests/optional_scalars/ScalarStuff.cs @@ -17,6 +17,7 @@ public struct ScalarStuff : IFlatbufferObject public static ScalarStuff GetRootAsScalarStuff(ByteBuffer _bb) { return GetRootAsScalarStuff(_bb, new ScalarStuff()); } public static ScalarStuff GetRootAsScalarStuff(ByteBuffer _bb, ScalarStuff obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); } public static bool ScalarStuffBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "NULL"); } + public static bool VerifyScalarStuff(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("NULL", false, ScalarStuffVerify.Verify); } public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); } public ScalarStuff __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } @@ -351,4 +352,49 @@ public class ScalarStuffT } +static public class ScalarStuffVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyField(tablePos, 4 /*JustI8*/, 1 /*sbyte*/, 1, false) + && verifier.VerifyField(tablePos, 6 /*MaybeI8*/, 1 /*sbyte*/, 1, false) + && verifier.VerifyField(tablePos, 8 /*DefaultI8*/, 1 /*sbyte*/, 1, false) + && verifier.VerifyField(tablePos, 10 /*JustU8*/, 1 /*byte*/, 1, false) + && verifier.VerifyField(tablePos, 12 /*MaybeU8*/, 1 /*byte*/, 1, false) + && verifier.VerifyField(tablePos, 14 /*DefaultU8*/, 1 /*byte*/, 1, false) + && verifier.VerifyField(tablePos, 16 /*JustI16*/, 2 /*short*/, 2, false) + && verifier.VerifyField(tablePos, 18 /*MaybeI16*/, 2 /*short*/, 2, false) + && verifier.VerifyField(tablePos, 20 /*DefaultI16*/, 2 /*short*/, 2, false) + && verifier.VerifyField(tablePos, 22 /*JustU16*/, 2 /*ushort*/, 2, false) + && verifier.VerifyField(tablePos, 24 /*MaybeU16*/, 2 /*ushort*/, 2, false) + && verifier.VerifyField(tablePos, 26 /*DefaultU16*/, 2 /*ushort*/, 2, false) + && verifier.VerifyField(tablePos, 28 /*JustI32*/, 4 /*int*/, 4, false) + && verifier.VerifyField(tablePos, 30 /*MaybeI32*/, 4 /*int*/, 4, false) + && verifier.VerifyField(tablePos, 32 /*DefaultI32*/, 4 /*int*/, 4, false) + && verifier.VerifyField(tablePos, 34 /*JustU32*/, 4 /*uint*/, 4, false) + && verifier.VerifyField(tablePos, 36 /*MaybeU32*/, 4 /*uint*/, 4, false) + && verifier.VerifyField(tablePos, 38 /*DefaultU32*/, 4 /*uint*/, 4, false) + && verifier.VerifyField(tablePos, 40 /*JustI64*/, 8 /*long*/, 8, false) + && verifier.VerifyField(tablePos, 42 /*MaybeI64*/, 8 /*long*/, 8, false) + && verifier.VerifyField(tablePos, 44 /*DefaultI64*/, 8 /*long*/, 8, false) + && verifier.VerifyField(tablePos, 46 /*JustU64*/, 8 /*ulong*/, 8, false) + && verifier.VerifyField(tablePos, 48 /*MaybeU64*/, 8 /*ulong*/, 8, false) + && verifier.VerifyField(tablePos, 50 /*DefaultU64*/, 8 /*ulong*/, 8, false) + && verifier.VerifyField(tablePos, 52 /*JustF32*/, 4 /*float*/, 4, false) + && verifier.VerifyField(tablePos, 54 /*MaybeF32*/, 4 /*float*/, 4, false) + && verifier.VerifyField(tablePos, 56 /*DefaultF32*/, 4 /*float*/, 4, false) + && verifier.VerifyField(tablePos, 58 /*JustF64*/, 8 /*double*/, 8, false) + && verifier.VerifyField(tablePos, 60 /*MaybeF64*/, 8 /*double*/, 8, false) + && verifier.VerifyField(tablePos, 62 /*DefaultF64*/, 8 /*double*/, 8, false) + && verifier.VerifyField(tablePos, 64 /*JustBool*/, 1 /*bool*/, 1, false) + && verifier.VerifyField(tablePos, 66 /*MaybeBool*/, 1 /*bool*/, 1, false) + && verifier.VerifyField(tablePos, 68 /*DefaultBool*/, 1 /*bool*/, 1, false) + && verifier.VerifyField(tablePos, 70 /*JustEnum*/, 1 /*optional_scalars.OptionalByte*/, 1, false) + && verifier.VerifyField(tablePos, 72 /*MaybeEnum*/, 1 /*optional_scalars.OptionalByte*/, 1, false) + && verifier.VerifyField(tablePos, 74 /*DefaultEnum*/, 1 /*optional_scalars.OptionalByte*/, 1, false) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/optional_scalars/ScalarStuff.py b/tests/optional_scalars/ScalarStuff.py index ca7c253a6..b75ba22df 100644 --- a/tests/optional_scalars/ScalarStuff.py +++ b/tests/optional_scalars/ScalarStuff.py @@ -280,121 +280,235 @@ class ScalarStuff(object): return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) return 1 -def ScalarStuffStart(builder): builder.StartObject(36) +def ScalarStuffStart(builder): + return builder.StartObject(36) + def Start(builder): return ScalarStuffStart(builder) -def ScalarStuffAddJustI8(builder, justI8): builder.PrependInt8Slot(0, justI8, 0) + +def ScalarStuffAddJustI8(builder, justI8): + return builder.PrependInt8Slot(0, justI8, 0) + def AddJustI8(builder, justI8): return ScalarStuffAddJustI8(builder, justI8) -def ScalarStuffAddMaybeI8(builder, maybeI8): builder.PrependInt8Slot(1, maybeI8, None) + +def ScalarStuffAddMaybeI8(builder, maybeI8): + return builder.PrependInt8Slot(1, maybeI8, None) + def AddMaybeI8(builder, maybeI8): return ScalarStuffAddMaybeI8(builder, maybeI8) -def ScalarStuffAddDefaultI8(builder, defaultI8): builder.PrependInt8Slot(2, defaultI8, 42) + +def ScalarStuffAddDefaultI8(builder, defaultI8): + return builder.PrependInt8Slot(2, defaultI8, 42) + def AddDefaultI8(builder, defaultI8): return ScalarStuffAddDefaultI8(builder, defaultI8) -def ScalarStuffAddJustU8(builder, justU8): builder.PrependUint8Slot(3, justU8, 0) + +def ScalarStuffAddJustU8(builder, justU8): + return builder.PrependUint8Slot(3, justU8, 0) + def AddJustU8(builder, justU8): return ScalarStuffAddJustU8(builder, justU8) -def ScalarStuffAddMaybeU8(builder, maybeU8): builder.PrependUint8Slot(4, maybeU8, None) + +def ScalarStuffAddMaybeU8(builder, maybeU8): + return builder.PrependUint8Slot(4, maybeU8, None) + def AddMaybeU8(builder, maybeU8): return ScalarStuffAddMaybeU8(builder, maybeU8) -def ScalarStuffAddDefaultU8(builder, defaultU8): builder.PrependUint8Slot(5, defaultU8, 42) + +def ScalarStuffAddDefaultU8(builder, defaultU8): + return builder.PrependUint8Slot(5, defaultU8, 42) + def AddDefaultU8(builder, defaultU8): return ScalarStuffAddDefaultU8(builder, defaultU8) -def ScalarStuffAddJustI16(builder, justI16): builder.PrependInt16Slot(6, justI16, 0) + +def ScalarStuffAddJustI16(builder, justI16): + return builder.PrependInt16Slot(6, justI16, 0) + def AddJustI16(builder, justI16): return ScalarStuffAddJustI16(builder, justI16) -def ScalarStuffAddMaybeI16(builder, maybeI16): builder.PrependInt16Slot(7, maybeI16, None) + +def ScalarStuffAddMaybeI16(builder, maybeI16): + return builder.PrependInt16Slot(7, maybeI16, None) + def AddMaybeI16(builder, maybeI16): return ScalarStuffAddMaybeI16(builder, maybeI16) -def ScalarStuffAddDefaultI16(builder, defaultI16): builder.PrependInt16Slot(8, defaultI16, 42) + +def ScalarStuffAddDefaultI16(builder, defaultI16): + return builder.PrependInt16Slot(8, defaultI16, 42) + def AddDefaultI16(builder, defaultI16): return ScalarStuffAddDefaultI16(builder, defaultI16) -def ScalarStuffAddJustU16(builder, justU16): builder.PrependUint16Slot(9, justU16, 0) + +def ScalarStuffAddJustU16(builder, justU16): + return builder.PrependUint16Slot(9, justU16, 0) + def AddJustU16(builder, justU16): return ScalarStuffAddJustU16(builder, justU16) -def ScalarStuffAddMaybeU16(builder, maybeU16): builder.PrependUint16Slot(10, maybeU16, None) + +def ScalarStuffAddMaybeU16(builder, maybeU16): + return builder.PrependUint16Slot(10, maybeU16, None) + def AddMaybeU16(builder, maybeU16): return ScalarStuffAddMaybeU16(builder, maybeU16) -def ScalarStuffAddDefaultU16(builder, defaultU16): builder.PrependUint16Slot(11, defaultU16, 42) + +def ScalarStuffAddDefaultU16(builder, defaultU16): + return builder.PrependUint16Slot(11, defaultU16, 42) + def AddDefaultU16(builder, defaultU16): return ScalarStuffAddDefaultU16(builder, defaultU16) -def ScalarStuffAddJustI32(builder, justI32): builder.PrependInt32Slot(12, justI32, 0) + +def ScalarStuffAddJustI32(builder, justI32): + return builder.PrependInt32Slot(12, justI32, 0) + def AddJustI32(builder, justI32): return ScalarStuffAddJustI32(builder, justI32) -def ScalarStuffAddMaybeI32(builder, maybeI32): builder.PrependInt32Slot(13, maybeI32, None) + +def ScalarStuffAddMaybeI32(builder, maybeI32): + return builder.PrependInt32Slot(13, maybeI32, None) + def AddMaybeI32(builder, maybeI32): return ScalarStuffAddMaybeI32(builder, maybeI32) -def ScalarStuffAddDefaultI32(builder, defaultI32): builder.PrependInt32Slot(14, defaultI32, 42) + +def ScalarStuffAddDefaultI32(builder, defaultI32): + return builder.PrependInt32Slot(14, defaultI32, 42) + def AddDefaultI32(builder, defaultI32): return ScalarStuffAddDefaultI32(builder, defaultI32) -def ScalarStuffAddJustU32(builder, justU32): builder.PrependUint32Slot(15, justU32, 0) + +def ScalarStuffAddJustU32(builder, justU32): + return builder.PrependUint32Slot(15, justU32, 0) + def AddJustU32(builder, justU32): return ScalarStuffAddJustU32(builder, justU32) -def ScalarStuffAddMaybeU32(builder, maybeU32): builder.PrependUint32Slot(16, maybeU32, None) + +def ScalarStuffAddMaybeU32(builder, maybeU32): + return builder.PrependUint32Slot(16, maybeU32, None) + def AddMaybeU32(builder, maybeU32): return ScalarStuffAddMaybeU32(builder, maybeU32) -def ScalarStuffAddDefaultU32(builder, defaultU32): builder.PrependUint32Slot(17, defaultU32, 42) + +def ScalarStuffAddDefaultU32(builder, defaultU32): + return builder.PrependUint32Slot(17, defaultU32, 42) + def AddDefaultU32(builder, defaultU32): return ScalarStuffAddDefaultU32(builder, defaultU32) -def ScalarStuffAddJustI64(builder, justI64): builder.PrependInt64Slot(18, justI64, 0) + +def ScalarStuffAddJustI64(builder, justI64): + return builder.PrependInt64Slot(18, justI64, 0) + def AddJustI64(builder, justI64): return ScalarStuffAddJustI64(builder, justI64) -def ScalarStuffAddMaybeI64(builder, maybeI64): builder.PrependInt64Slot(19, maybeI64, None) + +def ScalarStuffAddMaybeI64(builder, maybeI64): + return builder.PrependInt64Slot(19, maybeI64, None) + def AddMaybeI64(builder, maybeI64): return ScalarStuffAddMaybeI64(builder, maybeI64) -def ScalarStuffAddDefaultI64(builder, defaultI64): builder.PrependInt64Slot(20, defaultI64, 42) + +def ScalarStuffAddDefaultI64(builder, defaultI64): + return builder.PrependInt64Slot(20, defaultI64, 42) + def AddDefaultI64(builder, defaultI64): return ScalarStuffAddDefaultI64(builder, defaultI64) -def ScalarStuffAddJustU64(builder, justU64): builder.PrependUint64Slot(21, justU64, 0) + +def ScalarStuffAddJustU64(builder, justU64): + return builder.PrependUint64Slot(21, justU64, 0) + def AddJustU64(builder, justU64): return ScalarStuffAddJustU64(builder, justU64) -def ScalarStuffAddMaybeU64(builder, maybeU64): builder.PrependUint64Slot(22, maybeU64, None) + +def ScalarStuffAddMaybeU64(builder, maybeU64): + return builder.PrependUint64Slot(22, maybeU64, None) + def AddMaybeU64(builder, maybeU64): return ScalarStuffAddMaybeU64(builder, maybeU64) -def ScalarStuffAddDefaultU64(builder, defaultU64): builder.PrependUint64Slot(23, defaultU64, 42) + +def ScalarStuffAddDefaultU64(builder, defaultU64): + return builder.PrependUint64Slot(23, defaultU64, 42) + def AddDefaultU64(builder, defaultU64): return ScalarStuffAddDefaultU64(builder, defaultU64) -def ScalarStuffAddJustF32(builder, justF32): builder.PrependFloat32Slot(24, justF32, 0.0) + +def ScalarStuffAddJustF32(builder, justF32): + return builder.PrependFloat32Slot(24, justF32, 0.0) + def AddJustF32(builder, justF32): return ScalarStuffAddJustF32(builder, justF32) -def ScalarStuffAddMaybeF32(builder, maybeF32): builder.PrependFloat32Slot(25, maybeF32, None) + +def ScalarStuffAddMaybeF32(builder, maybeF32): + return builder.PrependFloat32Slot(25, maybeF32, None) + def AddMaybeF32(builder, maybeF32): return ScalarStuffAddMaybeF32(builder, maybeF32) -def ScalarStuffAddDefaultF32(builder, defaultF32): builder.PrependFloat32Slot(26, defaultF32, 42.0) + +def ScalarStuffAddDefaultF32(builder, defaultF32): + return builder.PrependFloat32Slot(26, defaultF32, 42.0) + def AddDefaultF32(builder, defaultF32): return ScalarStuffAddDefaultF32(builder, defaultF32) -def ScalarStuffAddJustF64(builder, justF64): builder.PrependFloat64Slot(27, justF64, 0.0) + +def ScalarStuffAddJustF64(builder, justF64): + return builder.PrependFloat64Slot(27, justF64, 0.0) + def AddJustF64(builder, justF64): return ScalarStuffAddJustF64(builder, justF64) -def ScalarStuffAddMaybeF64(builder, maybeF64): builder.PrependFloat64Slot(28, maybeF64, None) + +def ScalarStuffAddMaybeF64(builder, maybeF64): + return builder.PrependFloat64Slot(28, maybeF64, None) + def AddMaybeF64(builder, maybeF64): return ScalarStuffAddMaybeF64(builder, maybeF64) -def ScalarStuffAddDefaultF64(builder, defaultF64): builder.PrependFloat64Slot(29, defaultF64, 42.0) + +def ScalarStuffAddDefaultF64(builder, defaultF64): + return builder.PrependFloat64Slot(29, defaultF64, 42.0) + def AddDefaultF64(builder, defaultF64): return ScalarStuffAddDefaultF64(builder, defaultF64) -def ScalarStuffAddJustBool(builder, justBool): builder.PrependBoolSlot(30, justBool, 0) + +def ScalarStuffAddJustBool(builder, justBool): + return builder.PrependBoolSlot(30, justBool, 0) + def AddJustBool(builder, justBool): return ScalarStuffAddJustBool(builder, justBool) -def ScalarStuffAddMaybeBool(builder, maybeBool): builder.PrependBoolSlot(31, maybeBool, None) + +def ScalarStuffAddMaybeBool(builder, maybeBool): + return builder.PrependBoolSlot(31, maybeBool, None) + def AddMaybeBool(builder, maybeBool): return ScalarStuffAddMaybeBool(builder, maybeBool) -def ScalarStuffAddDefaultBool(builder, defaultBool): builder.PrependBoolSlot(32, defaultBool, 1) + +def ScalarStuffAddDefaultBool(builder, defaultBool): + return builder.PrependBoolSlot(32, defaultBool, 1) + def AddDefaultBool(builder, defaultBool): return ScalarStuffAddDefaultBool(builder, defaultBool) -def ScalarStuffAddJustEnum(builder, justEnum): builder.PrependInt8Slot(33, justEnum, 0) + +def ScalarStuffAddJustEnum(builder, justEnum): + return builder.PrependInt8Slot(33, justEnum, 0) + def AddJustEnum(builder, justEnum): return ScalarStuffAddJustEnum(builder, justEnum) -def ScalarStuffAddMaybeEnum(builder, maybeEnum): builder.PrependInt8Slot(34, maybeEnum, None) + +def ScalarStuffAddMaybeEnum(builder, maybeEnum): + return builder.PrependInt8Slot(34, maybeEnum, None) + def AddMaybeEnum(builder, maybeEnum): return ScalarStuffAddMaybeEnum(builder, maybeEnum) -def ScalarStuffAddDefaultEnum(builder, defaultEnum): builder.PrependInt8Slot(35, defaultEnum, 1) + +def ScalarStuffAddDefaultEnum(builder, defaultEnum): + return builder.PrependInt8Slot(35, defaultEnum, 1) + def AddDefaultEnum(builder, defaultEnum): return ScalarStuffAddDefaultEnum(builder, defaultEnum) -def ScalarStuffEnd(builder): return builder.EndObject() + +def ScalarStuffEnd(builder): + return builder.EndObject() + def End(builder): return ScalarStuffEnd(builder) + class ScalarStuffT(object): # ScalarStuffT diff --git a/tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/FlatBuffersMonsterWriterTests.swift b/tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/FlatBuffersMonsterWriterTests.swift index adc918a5d..b00094e2a 100644 --- a/tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/FlatBuffersMonsterWriterTests.swift +++ b/tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/FlatBuffersMonsterWriterTests.swift @@ -217,6 +217,10 @@ class FlatBuffersMonsterWriterTests: XCTestCase { XCTAssertEqual(monster.testType, .monster) + XCTAssertTrue(monster.mutate(testbool: false)) + XCTAssertEqual(monster.testbool, false) + XCTAssertTrue(monster.mutate(testbool: true)) + XCTAssertEqual(monster.mutate(inventory: 1, at: 0), true) XCTAssertEqual(monster.mutate(inventory: 2, at: 1), true) XCTAssertEqual(monster.mutate(inventory: 3, at: 2), true) diff --git a/tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/monster_test_generated.swift b/tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/monster_test_generated.swift index b11c142d7..a295a07b8 100644 --- a/tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/monster_test_generated.swift +++ b/tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/monster_test_generated.swift @@ -1221,8 +1221,8 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac public var testnestedflatbuffer: [UInt8] { return _accessor.getVector(at: VTOFFSET.testnestedflatbuffer.v) ?? [] } public func mutate(testnestedflatbuffer: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.testnestedflatbuffer.v); return _accessor.directMutate(testnestedflatbuffer, index: _accessor.vector(at: o) + index * 1) } public var testempty: MyGame_Example_Stat? { let o = _accessor.offset(VTOFFSET.testempty.v); return o == 0 ? nil : MyGame_Example_Stat(_accessor.bb, o: _accessor.indirect(o + _accessor.postion)) } - public var testbool: Bool { let o = _accessor.offset(VTOFFSET.testbool.v); return o == 0 ? false : 0 != _accessor.readBuffer(of: Byte.self, at: o) } - @discardableResult public func mutate(testbool: Byte) -> Bool {let o = _accessor.offset(VTOFFSET.testbool.v); return _accessor.mutate(testbool, index: o) } + public var testbool: Bool { let o = _accessor.offset(VTOFFSET.testbool.v); return o == 0 ? false : _accessor.readBuffer(of: Bool.self, at: o) } + @discardableResult public func mutate(testbool: Bool) -> Bool {let o = _accessor.offset(VTOFFSET.testbool.v); return _accessor.mutate(testbool, index: o) } public var testhashs32Fnv1: Int32 { let o = _accessor.offset(VTOFFSET.testhashs32Fnv1.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) } @discardableResult public func mutate(testhashs32Fnv1: Int32) -> Bool {let o = _accessor.offset(VTOFFSET.testhashs32Fnv1.v); return _accessor.mutate(testhashs32Fnv1, index: o) } public var testhashu32Fnv1: UInt32 { let o = _accessor.offset(VTOFFSET.testhashu32Fnv1.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt32.self, at: o) } diff --git a/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift b/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift index b11c142d7..a295a07b8 100644 --- a/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift +++ b/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift @@ -1221,8 +1221,8 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac public var testnestedflatbuffer: [UInt8] { return _accessor.getVector(at: VTOFFSET.testnestedflatbuffer.v) ?? [] } public func mutate(testnestedflatbuffer: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.testnestedflatbuffer.v); return _accessor.directMutate(testnestedflatbuffer, index: _accessor.vector(at: o) + index * 1) } public var testempty: MyGame_Example_Stat? { let o = _accessor.offset(VTOFFSET.testempty.v); return o == 0 ? nil : MyGame_Example_Stat(_accessor.bb, o: _accessor.indirect(o + _accessor.postion)) } - public var testbool: Bool { let o = _accessor.offset(VTOFFSET.testbool.v); return o == 0 ? false : 0 != _accessor.readBuffer(of: Byte.self, at: o) } - @discardableResult public func mutate(testbool: Byte) -> Bool {let o = _accessor.offset(VTOFFSET.testbool.v); return _accessor.mutate(testbool, index: o) } + public var testbool: Bool { let o = _accessor.offset(VTOFFSET.testbool.v); return o == 0 ? false : _accessor.readBuffer(of: Bool.self, at: o) } + @discardableResult public func mutate(testbool: Bool) -> Bool {let o = _accessor.offset(VTOFFSET.testbool.v); return _accessor.mutate(testbool, index: o) } public var testhashs32Fnv1: Int32 { let o = _accessor.offset(VTOFFSET.testhashs32Fnv1.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) } @discardableResult public func mutate(testhashs32Fnv1: Int32) -> Bool {let o = _accessor.offset(VTOFFSET.testhashs32Fnv1.v); return _accessor.mutate(testhashs32Fnv1, index: o) } public var testhashu32Fnv1: UInt32 { let o = _accessor.offset(VTOFFSET.testhashu32Fnv1.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt32.self, at: o) } diff --git a/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/optional_scalars_generated.swift b/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/optional_scalars_generated.swift index 74585a170..8758b1ef3 100644 --- a/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/optional_scalars_generated.swift +++ b/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/optional_scalars_generated.swift @@ -109,9 +109,9 @@ public struct optional_scalars_ScalarStuff: FlatBufferObject, Verifiable { public var justF64: Double { let o = _accessor.offset(VTOFFSET.justF64.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) } public var maybeF64: Double? { let o = _accessor.offset(VTOFFSET.maybeF64.v); return o == 0 ? nil : _accessor.readBuffer(of: Double.self, at: o) } public var defaultF64: Double { let o = _accessor.offset(VTOFFSET.defaultF64.v); return o == 0 ? 42.0 : _accessor.readBuffer(of: Double.self, at: o) } - public var justBool: Bool { let o = _accessor.offset(VTOFFSET.justBool.v); return o == 0 ? false : 0 != _accessor.readBuffer(of: Byte.self, at: o) } - public var maybeBool: Bool? { let o = _accessor.offset(VTOFFSET.maybeBool.v); return o == 0 ? nil : 0 != _accessor.readBuffer(of: Byte.self, at: o) } - public var defaultBool: Bool { let o = _accessor.offset(VTOFFSET.defaultBool.v); return o == 0 ? true : 0 != _accessor.readBuffer(of: Byte.self, at: o) } + public var justBool: Bool { let o = _accessor.offset(VTOFFSET.justBool.v); return o == 0 ? false : _accessor.readBuffer(of: Bool.self, at: o) } + public var maybeBool: Bool? { let o = _accessor.offset(VTOFFSET.maybeBool.v); return o == 0 ? nil : _accessor.readBuffer(of: Bool.self, at: o) } + public var defaultBool: Bool { let o = _accessor.offset(VTOFFSET.defaultBool.v); return o == 0 ? true : _accessor.readBuffer(of: Bool.self, at: o) } public var justEnum: optional_scalars_OptionalByte { let o = _accessor.offset(VTOFFSET.justEnum.v); return o == 0 ? .none_ : optional_scalars_OptionalByte(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .none_ } public var maybeEnum: optional_scalars_OptionalByte? { let o = _accessor.offset(VTOFFSET.maybeEnum.v); return o == 0 ? nil : optional_scalars_OptionalByte(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? nil } public var defaultEnum: optional_scalars_OptionalByte { let o = _accessor.offset(VTOFFSET.defaultEnum.v); return o == 0 ? .one : optional_scalars_OptionalByte(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .one } diff --git a/tests/ts/arrays_test_complex/arrays_test_complex_generated.cjs b/tests/ts/arrays_test_complex/arrays_test_complex_generated.cjs index ec2df6334..3ae6bcd00 100644 --- a/tests/ts/arrays_test_complex/arrays_test_complex_generated.cjs +++ b/tests/ts/arrays_test_complex/arrays_test_complex_generated.cjs @@ -18,10 +18,6 @@ var __copyProps = (to, from, except, desc) => { return to; }; var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( - // If the importer is in node compatibility mode or this is not an ESM - // file that has been converted to a CommonJS file using a Babel- - // compatible transform (i.e. "__esModule" has not been set), then set - // "default" to the CommonJS "module.exports" for node compatibility. isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod )); diff --git a/tests/ts/monster_test_generated.cjs b/tests/ts/monster_test_generated.cjs index 8eb338e68..3f05fd0ab 100644 --- a/tests/ts/monster_test_generated.cjs +++ b/tests/ts/monster_test_generated.cjs @@ -18,10 +18,6 @@ var __copyProps = (to, from, except, desc) => { return to; }; var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( - // If the importer is in node compatibility mode or this is not an ESM - // file that has been converted to a CommonJS file using a Babel- - // compatible transform (i.e. "__esModule" has not been set), then set - // "default" to the CommonJS "module.exports" for node compatibility. isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod )); @@ -818,7 +814,7 @@ var Vec3 = class { } }; var Vec3T = class { - constructor(x = 0, y = 0, z = 0, test1 = 0, test2 = 0, test3 = null) { + constructor(x = 0, y = 0, z = 0, test1 = 0, test2 = Color.Red, test3 = null) { this.x = x; this.y = y; this.z = z; @@ -932,10 +928,6 @@ var Monster2 = class { const offset = this.bb.__offset(this.bb_pos, 24); return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; } - /** - * an example documentation comment: this will end up in the generated code - * multiline too - */ testarrayoftables(index, obj) { const offset = this.bb.__offset(this.bb_pos, 26); return offset ? (obj || new Monster2()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; diff --git a/tests/ts/my-game/example/vec3.js b/tests/ts/my-game/example/vec3.js index 655fa7e5e..cd5b03461 100644 --- a/tests/ts/my-game/example/vec3.js +++ b/tests/ts/my-game/example/vec3.js @@ -1,4 +1,5 @@ // automatically generated by the FlatBuffers compiler, do not modify +import { Color } from '../../my-game/example/color.js'; import { Test } from '../../my-game/example/test.js'; export class Vec3 { constructor() { @@ -83,7 +84,7 @@ export class Vec3 { } } export class Vec3T { - constructor(x = 0.0, y = 0.0, z = 0.0, test1 = 0.0, test2 = 0, test3 = null) { + constructor(x = 0.0, y = 0.0, z = 0.0, test1 = 0.0, test2 = Color.Red, test3 = null) { this.x = x; this.y = y; this.z = z; diff --git a/tests/ts/my-game/example/vec3.ts b/tests/ts/my-game/example/vec3.ts index ad6cafaa7..9e31323b6 100644 --- a/tests/ts/my-game/example/vec3.ts +++ b/tests/ts/my-game/example/vec3.ts @@ -118,7 +118,7 @@ constructor( public y: number = 0.0, public z: number = 0.0, public test1: number = 0.0, - public test2: Color = 0, + public test2: Color = Color.Red, public test3: TestT|null = null ){} diff --git a/tests/ts/typescript_keywords_generated.cjs b/tests/ts/typescript_keywords_generated.cjs index 5e2e1a870..a25f9adbc 100644 --- a/tests/ts/typescript_keywords_generated.cjs +++ b/tests/ts/typescript_keywords_generated.cjs @@ -18,10 +18,6 @@ var __copyProps = (to, from, except, desc) => { return to; }; var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( - // If the importer is in node compatibility mode or this is not an ESM - // file that has been converted to a CommonJS file using a Babel- - // compatible transform (i.e. "__esModule" has not been set), then set - // "default" to the CommonJS "module.exports" for node compatibility. isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod )); @@ -250,9 +246,6 @@ var Type = class { this.bb.writeUint16(this.bb_pos + offset, value); return true; } - /** - * The size (octets) of the `base_type` field. - */ baseSize() { const offset = this.bb.__offset(this.bb_pos, 12); return offset ? this.bb.readUint32(this.bb_pos + offset) : 4; @@ -265,9 +258,6 @@ var Type = class { this.bb.writeUint32(this.bb_pos + offset, value); return true; } - /** - * The size (octets) of the `element` field, if present. - */ elementSize() { const offset = this.bb.__offset(this.bb_pos, 14); return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; @@ -789,9 +779,6 @@ var Field = class { this.bb.writeInt8(this.bb_pos + offset, +value); return true; } - /** - * Number of padding octets to always add after this field. Structs only. - */ padding() { const offset = this.bb.__offset(this.bb_pos, 28); return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; @@ -1564,10 +1551,6 @@ var Schema = class { this.bb.writeUint64(this.bb_pos + offset, value); return true; } - /** - * All the files used in this compilation. Files are relative to where - * flatc was invoked. - */ fbsFiles(index, obj) { const offset = this.bb.__offset(this.bb_pos, 18); return offset ? (obj || new SchemaFile()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null; diff --git a/tests/ts/union_vector/union_vector_generated.cjs b/tests/ts/union_vector/union_vector_generated.cjs index b63140cd6..ab4b0dcfd 100644 --- a/tests/ts/union_vector/union_vector_generated.cjs +++ b/tests/ts/union_vector/union_vector_generated.cjs @@ -18,10 +18,6 @@ var __copyProps = (to, from, except, desc) => { return to; }; var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( - // If the importer is in node compatibility mode or this is not an ESM - // file that has been converted to a CommonJS file using a Babel- - // compatible transform (i.e. "__esModule" has not been set), then set - // "default" to the CommonJS "module.exports" for node compatibility. isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod )); diff --git a/tests/type_field_collsion/Collision.cs b/tests/type_field_collsion/Collision.cs index 0d24aba91..c1a877a15 100644 --- a/tests/type_field_collsion/Collision.cs +++ b/tests/type_field_collsion/Collision.cs @@ -16,6 +16,7 @@ public struct Collision : IFlatbufferObject public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_3_3(); } public static Collision GetRootAsCollision(ByteBuffer _bb) { return GetRootAsCollision(_bb, new Collision()); } public static Collision GetRootAsCollision(ByteBuffer _bb, Collision obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); } + public static bool VerifyCollision(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("", false, CollisionVerify.Verify); } public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); } public Collision __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } @@ -70,4 +71,14 @@ public class CollisionT } +static public class CollisionVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyField(tablePos, 4 /*Collision*/, 4 /*int*/, 4, false) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/union_value_collsion/union_value_collision_generated.cs b/tests/union_value_collsion/union_value_collision_generated.cs index c49701eb0..6dc1b4061 100644 --- a/tests/union_value_collsion/union_value_collision_generated.cs +++ b/tests/union_value_collsion/union_value_collision_generated.cs @@ -37,6 +37,25 @@ public class ValueUnion { } } + + +static public class ValueVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos) + { + bool result = true; + switch((Value)typeId) + { + case Value.IntValue: + result = union_value_collsion.IntValueVerify.Verify(verifier, tablePos); + break; + default: result = true; + break; + } + return result; + } +} + public class ValueUnion_JsonConverter : Newtonsoft.Json.JsonConverter { public override bool CanConvert(System.Type objectType) { return objectType == typeof(ValueUnion) || objectType == typeof(System.Collections.Generic.List); @@ -106,6 +125,25 @@ public class OtherUnion { } } + + +static public class OtherVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos) + { + bool result = true; + switch((Other)typeId) + { + case Other.IntValue: + result = union_value_collsion.IntValueVerify.Verify(verifier, tablePos); + break; + default: result = true; + break; + } + return result; + } +} + public class OtherUnion_JsonConverter : Newtonsoft.Json.JsonConverter { public override bool CanConvert(System.Type objectType) { return objectType == typeof(OtherUnion) || objectType == typeof(System.Collections.Generic.List); @@ -198,6 +236,16 @@ public class IntValueT } } + +static public class IntValueVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyField(tablePos, 4 /*Value*/, 4 /*int*/, 4, false) + && verifier.VerifyTableEnd(tablePos); + } +} public struct Collide : IFlatbufferObject { private Table __p; @@ -302,6 +350,17 @@ public class CollideT } } + +static public class CollideVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyString(tablePos, 4 /*Collide*/, true) + && verifier.VerifyString(tablePos, 6 /*Value*/, false) + && verifier.VerifyTableEnd(tablePos); + } +} public struct Collision : IFlatbufferObject { private Table __p; @@ -309,6 +368,7 @@ public struct Collision : IFlatbufferObject public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_3_3(); } public static Collision GetRootAsCollision(ByteBuffer _bb) { return GetRootAsCollision(_bb, new Collision()); } public static Collision GetRootAsCollision(ByteBuffer _bb, Collision obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); } + public static bool VerifyCollision(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("", false, CollisionVerify.Verify); } public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); } public Collision __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } @@ -454,4 +514,18 @@ public class CollisionT } +static public class CollisionVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyField(tablePos, 4 /*SomeValueType*/, 1 /*union_value_collsion.Value*/, 1, false) + && verifier.VerifyUnion(tablePos, 4, 6 /*SomeValue*/, union_value_collsion.ValueVerify.Verify, false) + && verifier.VerifyField(tablePos, 8 /*ValueType*/, 1 /*union_value_collsion.Other*/, 1, false) + && verifier.VerifyUnion(tablePos, 8, 10 /*Value*/, union_value_collsion.OtherVerify.Verify, false) + && verifier.VerifyVectorOfTables(tablePos, 12 /*Collide*/, union_value_collsion.CollisionVerify.Verify, false) + && verifier.VerifyTableEnd(tablePos); + } +} + } diff --git a/tests/union_vector/Attacker.cs b/tests/union_vector/Attacker.cs index cb48863a0..e1716a1df 100644 --- a/tests/union_vector/Attacker.cs +++ b/tests/union_vector/Attacker.cs @@ -58,3 +58,13 @@ public class AttackerT } } + +static public class AttackerVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyField(tablePos, 4 /*SwordAttackDamage*/, 4 /*int*/, 4, false) + && verifier.VerifyTableEnd(tablePos); + } +} diff --git a/tests/union_vector/Character.cs b/tests/union_vector/Character.cs index 181f914a3..f6e7c88a7 100644 --- a/tests/union_vector/Character.cs +++ b/tests/union_vector/Character.cs @@ -50,6 +50,40 @@ public class CharacterUnion { } } + + +static public class CharacterVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos) + { + bool result = true; + switch((Character)typeId) + { + case Character.MuLan: + result = AttackerVerify.Verify(verifier, tablePos); + break; + case Character.Rapunzel: + result = verifier.VerifyUnionData(tablePos, 4, 4); + break; + case Character.Belle: + result = verifier.VerifyUnionData(tablePos, 4, 4); + break; + case Character.BookFan: + result = verifier.VerifyUnionData(tablePos, 4, 4); + break; + case Character.Other: + result = verifier.VerifyUnionString(tablePos); + break; + case Character.Unused: + result = verifier.VerifyUnionString(tablePos); + break; + default: result = true; + break; + } + return result; + } +} + public class CharacterUnion_JsonConverter : Newtonsoft.Json.JsonConverter { public override bool CanConvert(System.Type objectType) { return objectType == typeof(CharacterUnion) || objectType == typeof(System.Collections.Generic.List); diff --git a/tests/union_vector/Gadget.cs b/tests/union_vector/Gadget.cs index 8e5ca7b15..32f0d8131 100644 --- a/tests/union_vector/Gadget.cs +++ b/tests/union_vector/Gadget.cs @@ -34,6 +34,28 @@ public class GadgetUnion { } } + + +static public class GadgetVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos) + { + bool result = true; + switch((Gadget)typeId) + { + case Gadget.FallingTub: + result = verifier.VerifyUnionData(tablePos, 4, 4); + break; + case Gadget.HandFan: + result = HandFanVerify.Verify(verifier, tablePos); + break; + default: result = true; + break; + } + return result; + } +} + public class GadgetUnion_JsonConverter : Newtonsoft.Json.JsonConverter { public override bool CanConvert(System.Type objectType) { return objectType == typeof(GadgetUnion) || objectType == typeof(System.Collections.Generic.List); diff --git a/tests/union_vector/HandFan.cs b/tests/union_vector/HandFan.cs index 63e10539c..14cf69ffb 100644 --- a/tests/union_vector/HandFan.cs +++ b/tests/union_vector/HandFan.cs @@ -58,3 +58,13 @@ public class HandFanT } } + +static public class HandFanVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyField(tablePos, 4 /*Length*/, 4 /*int*/, 4, false) + && verifier.VerifyTableEnd(tablePos); + } +} diff --git a/tests/union_vector/Movie.cs b/tests/union_vector/Movie.cs index f77bc497e..faa47fe06 100644 --- a/tests/union_vector/Movie.cs +++ b/tests/union_vector/Movie.cs @@ -14,6 +14,7 @@ public struct Movie : IFlatbufferObject public static Movie GetRootAsMovie(ByteBuffer _bb) { return GetRootAsMovie(_bb, new Movie()); } public static Movie GetRootAsMovie(ByteBuffer _bb, Movie obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); } public static bool MovieBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "MOVI"); } + public static bool VerifyMovie(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("MOVI", false, MovieVerify.Verify); } public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); } public Movie __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } @@ -211,3 +212,15 @@ public class MovieT } } + +static public class MovieVerify +{ + static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos) + { + return verifier.VerifyTableStart(tablePos) + && verifier.VerifyField(tablePos, 4 /*MainCharacterType*/, 1 /*Character*/, 1, false) + && verifier.VerifyUnion(tablePos, 4, 6 /*MainCharacter*/, CharacterVerify.Verify, false) + && verifier.VerifyVectorOfData(tablePos, 8 /*CharactersType*/, 1 /*Character*/, false) + && verifier.VerifyTableEnd(tablePos); + } +} diff --git a/ts/builder.ts b/ts/builder.ts index 8f98c3def..c37929513 100644 --- a/ts/builder.ts +++ b/ts/builder.ts @@ -268,7 +268,7 @@ export class Builder { */ nested(obj: Offset): void { if (obj != this.offset()) { - throw new Error('FlatBuffers: struct must be serialized inline.'); + throw new TypeError('FlatBuffers: struct must be serialized inline.'); } } @@ -278,7 +278,7 @@ export class Builder { */ notNested(): void { if (this.isNested) { - throw new Error('FlatBuffers: object serialization must not be nested.'); + throw new TypeError('FlatBuffers: object serialization must not be nested.'); } } @@ -429,7 +429,7 @@ export class Builder { this.prep(this.minalign, SIZEOF_INT + FILE_IDENTIFIER_LENGTH + size_prefix); if (file_identifier.length != FILE_IDENTIFIER_LENGTH) { - throw new Error('FlatBuffers: file identifier must be length ' + + throw new TypeError('FlatBuffers: file identifier must be length ' + FILE_IDENTIFIER_LENGTH); } for (let i = FILE_IDENTIFIER_LENGTH - 1; i >= 0; i--) { @@ -463,7 +463,7 @@ export class Builder { // If this fails, the caller will show what field needs to be set. if (!ok) { - throw new Error('FlatBuffers: field ' + field + ' must be set'); + throw new TypeError('FlatBuffers: field ' + field + ' must be set'); } } @@ -576,7 +576,7 @@ export class Builder { if(val !== null) { ret.push(this.createObjectOffset(val)); } else { - throw new Error( + throw new TypeError( 'FlatBuffers: Argument for createObjectOffsetList cannot contain null.'); } } diff --git a/yarn.lock b/yarn.lock index 8b806a544..e65a4e918 100644 --- a/yarn.lock +++ b/yarn.lock @@ -20,135 +20,152 @@ dependencies: google-protobuf "^3.6.1" -"@esbuild/android-arm64@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.16.4.tgz#4b31b9e3da2e4c12a8170bd682f713c775f68ab1" - integrity sha512-VPuTzXFm/m2fcGfN6CiwZTlLzxrKsWbPkG7ArRFpuxyaHUm/XFHQPD4xNwZT6uUmpIHhnSjcaCmcla8COzmZ5Q== +"@esbuild/android-arm64@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.17.14.tgz#4624cea3c8941c91f9e9c1228f550d23f1cef037" + integrity sha512-eLOpPO1RvtsP71afiFTvS7tVFShJBCT0txiv/xjFBo5a7R7Gjw7X0IgIaFoLKhqXYAXhahoXm7qAmRXhY4guJg== -"@esbuild/android-arm@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.16.4.tgz#057d3e8b0ee41ff59386c33ba6dcf20f4bedd1f7" - integrity sha512-rZzb7r22m20S1S7ufIc6DC6W659yxoOrl7sKP1nCYhuvUlnCFHVSbATG4keGUtV8rDz11sRRDbWkvQZpzPaHiw== +"@esbuild/android-arm@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.17.14.tgz#74fae60fcab34c3f0e15cb56473a6091ba2b53a6" + integrity sha512-0CnlwnjDU8cks0yJLXfkaU/uoLyRf9VZJs4p1PskBr2AlAHeEsFEwJEo0of/Z3g+ilw5mpyDwThlxzNEIxOE4g== -"@esbuild/android-x64@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.16.4.tgz#62ccab8ac1d3e6ef1df3fa2e1974bc2b8528d74a" - integrity sha512-MW+B2O++BkcOfMWmuHXB15/l1i7wXhJFqbJhp82IBOais8RBEQv2vQz/jHrDEHaY2X0QY7Wfw86SBL2PbVOr0g== +"@esbuild/android-x64@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.17.14.tgz#f002fbc08d5e939d8314bd23bcfb1e95d029491f" + integrity sha512-nrfQYWBfLGfSGLvRVlt6xi63B5IbfHm3tZCdu/82zuFPQ7zez4XjmRtF/wIRYbJQ/DsZrxJdEvYFE67avYXyng== -"@esbuild/darwin-arm64@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.16.4.tgz#c19a6489d626c36fc611c85ccd8a3333c1f2a930" - integrity sha512-a28X1O//aOfxwJVZVs7ZfM8Tyih2Za4nKJrBwW5Wm4yKsnwBy9aiS/xwpxiiTRttw3EaTg4Srerhcm6z0bu9Wg== +"@esbuild/darwin-arm64@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.17.14.tgz#b8dcd79a1dd19564950b4ca51d62999011e2e168" + integrity sha512-eoSjEuDsU1ROwgBH/c+fZzuSyJUVXQTOIN9xuLs9dE/9HbV/A5IqdXHU1p2OfIMwBwOYJ9SFVGGldxeRCUJFyw== -"@esbuild/darwin-x64@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.16.4.tgz#b726bbc84a1e277f6ec2509d10b8ee03f242b776" - integrity sha512-e3doCr6Ecfwd7VzlaQqEPrnbvvPjE9uoTpxG5pyLzr2rI2NMjDHmvY1E5EO81O/e9TUOLLkXA5m6T8lfjK9yAA== +"@esbuild/darwin-x64@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.17.14.tgz#4b49f195d9473625efc3c773fc757018f2c0d979" + integrity sha512-zN0U8RWfrDttdFNkHqFYZtOH8hdi22z0pFm0aIJPsNC4QQZv7je8DWCX5iA4Zx6tRhS0CCc0XC2m7wKsbWEo5g== -"@esbuild/freebsd-arm64@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.16.4.tgz#364568e6ca2901297f247de0681c9b14bbe658c8" - integrity sha512-Oup3G/QxBgvvqnXWrBed7xxkFNwAwJVHZcklWyQt7YCAL5bfUkaa6FVWnR78rNQiM8MqqLiT6ZTZSdUFuVIg1w== +"@esbuild/freebsd-arm64@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.17.14.tgz#480923fd38f644c6342c55e916cc7c231a85eeb7" + integrity sha512-z0VcD4ibeZWVQCW1O7szaLxGsx54gcCnajEJMdYoYjLiq4g1jrP2lMq6pk71dbS5+7op/L2Aod+erw+EUr28/A== -"@esbuild/freebsd-x64@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.16.4.tgz#44701ba4a5497ba64eec0a6c9e221d8f46a25e72" - integrity sha512-vAP+eYOxlN/Bpo/TZmzEQapNS8W1njECrqkTpNgvXskkkJC2AwOXwZWai/Kc2vEFZUXQttx6UJbj9grqjD/+9Q== +"@esbuild/freebsd-x64@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.17.14.tgz#a6b6b01954ad8562461cb8a5e40e8a860af69cbe" + integrity sha512-hd9mPcxfTgJlolrPlcXkQk9BMwNBvNBsVaUe5eNUqXut6weDQH8whcNaKNF2RO8NbpT6GY8rHOK2A9y++s+ehw== -"@esbuild/linux-arm64@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.16.4.tgz#b58fb418ec9ac714d8dbb38c787ff2441eb1d9db" - integrity sha512-2zXoBhv4r5pZiyjBKrOdFP4CXOChxXiYD50LRUU+65DkdS5niPFHbboKZd/c81l0ezpw7AQnHeoCy5hFrzzs4g== +"@esbuild/linux-arm64@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.17.14.tgz#1fe2f39f78183b59f75a4ad9c48d079916d92418" + integrity sha512-FhAMNYOq3Iblcj9i+K0l1Fp/MHt+zBeRu/Qkf0LtrcFu3T45jcwB6A1iMsemQ42vR3GBhjNZJZTaCe3VFPbn9g== -"@esbuild/linux-arm@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.16.4.tgz#b37f15ecddb53eeea466e5960e31a58f33e0e87e" - integrity sha512-A47ZmtpIPyERxkSvIv+zLd6kNIOtJH03XA0Hy7jaceRDdQaQVGSDt4mZqpWqJYgDk9rg96aglbF6kCRvPGDSUA== +"@esbuild/linux-arm@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.17.14.tgz#18d594a49b64e4a3a05022c005cb384a58056a2a" + integrity sha512-BNTl+wSJ1omsH8s3TkQmIIIQHwvwJrU9u1ggb9XU2KTVM4TmthRIVyxSp2qxROJHhZuW/r8fht46/QE8hU8Qvg== -"@esbuild/linux-ia32@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.16.4.tgz#117e32a9680b5deac184ebee122f8575369fad1b" - integrity sha512-uxdSrpe9wFhz4yBwt2kl2TxS/NWEINYBUFIxQtaEVtglm1eECvsj1vEKI0KX2k2wCe17zDdQ3v+jVxfwVfvvjw== +"@esbuild/linux-ia32@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.17.14.tgz#f7f0182a9cfc0159e0922ed66c805c9c6ef1b654" + integrity sha512-91OK/lQ5y2v7AsmnFT+0EyxdPTNhov3y2CWMdizyMfxSxRqHazXdzgBKtlmkU2KYIc+9ZK3Vwp2KyXogEATYxQ== -"@esbuild/linux-loong64@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.16.4.tgz#dd504fb83c280752d4b485d9acb3cf391cb7bf5b" - integrity sha512-peDrrUuxbZ9Jw+DwLCh/9xmZAk0p0K1iY5d2IcwmnN+B87xw7kujOkig6ZRcZqgrXgeRGurRHn0ENMAjjD5DEg== +"@esbuild/linux-loong64@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.17.14.tgz#5f5305fdffe2d71dd9a97aa77d0c99c99409066f" + integrity sha512-vp15H+5NR6hubNgMluqqKza85HcGJgq7t6rMH7O3Y6ApiOWPkvW2AJfNojUQimfTp6OUrACUXfR4hmpcENXoMQ== -"@esbuild/linux-mips64el@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.16.4.tgz#9ab77e31cf3be1e35572afff94b51df8149d15bd" - integrity sha512-sD9EEUoGtVhFjjsauWjflZklTNr57KdQ6xfloO4yH1u7vNQlOfAlhEzbyBKfgbJlW7rwXYBdl5/NcZ+Mg2XhQA== +"@esbuild/linux-mips64el@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.17.14.tgz#a602e85c51b2f71d2aedfe7f4143b2f92f97f3f5" + integrity sha512-90TOdFV7N+fgi6c2+GO9ochEkmm9kBAKnuD5e08GQMgMINOdOFHuYLPQ91RYVrnWwQ5683sJKuLi9l4SsbJ7Hg== -"@esbuild/linux-ppc64@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.16.4.tgz#69d56c2a960808bee1c7b9b84a115220ec9ce05c" - integrity sha512-X1HSqHUX9D+d0l6/nIh4ZZJ94eQky8d8z6yxAptpZE3FxCWYWvTDd9X9ST84MGZEJx04VYUD/AGgciddwO0b8g== +"@esbuild/linux-ppc64@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.17.14.tgz#32d918d782105cbd9345dbfba14ee018b9c7afdf" + integrity sha512-NnBGeoqKkTugpBOBZZoktQQ1Yqb7aHKmHxsw43NddPB2YWLAlpb7THZIzsRsTr0Xw3nqiPxbA1H31ZMOG+VVPQ== -"@esbuild/linux-riscv64@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.16.4.tgz#9fc23583f4a1508a8d352bd376340e42217e8a90" - integrity sha512-97ANpzyNp0GTXCt6SRdIx1ngwncpkV/z453ZuxbnBROCJ5p/55UjhbaG23UdHj88fGWLKPFtMoU4CBacz4j9FA== +"@esbuild/linux-riscv64@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.17.14.tgz#38612e7b6c037dff7022c33f49ca17f85c5dec58" + integrity sha512-0qdlKScLXA8MGVy21JUKvMzCYWovctuP8KKqhtE5A6IVPq4onxXhSuhwDd2g5sRCzNDlDjitc5sX31BzDoL5Fw== -"@esbuild/linux-s390x@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.16.4.tgz#4cae1f70ac2943f076dd130c3c80d28f57bf75d1" - integrity sha512-pUvPQLPmbEeJRPjP0DYTC1vjHyhrnCklQmCGYbipkep+oyfTn7GTBJXoPodR7ZS5upmEyc8lzAkn2o29wD786A== +"@esbuild/linux-s390x@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.17.14.tgz#4397dff354f899e72fd035d72af59a700c465ccb" + integrity sha512-Hdm2Jo1yaaOro4v3+6/zJk6ygCqIZuSDJHdHaf8nVH/tfOuoEX5Riv03Ka15LmQBYJObUTNS1UdyoMk0WUn9Ww== -"@esbuild/linux-x64@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.16.4.tgz#fdf494de07cda23a2dc4b71ff1e0848e4ee6539c" - integrity sha512-N55Q0mJs3Sl8+utPRPBrL6NLYZKBCLLx0bme/+RbjvMforTGGzFvsRl4xLTZMUBFC1poDzBEPTEu5nxizQ9Nlw== +"@esbuild/linux-x64@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.17.14.tgz#6c5cb99891b6c3e0c08369da3ef465e8038ad9c2" + integrity sha512-8KHF17OstlK4DuzeF/KmSgzrTWQrkWj5boluiiq7kvJCiQVzUrmSkaBvcLB2UgHpKENO2i6BthPkmUhNDaJsVw== -"@esbuild/netbsd-x64@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.16.4.tgz#b59ecb49087119c575c0f64d7e66001d52799e24" - integrity sha512-LHSJLit8jCObEQNYkgsDYBh2JrJT53oJO2HVdkSYLa6+zuLJh0lAr06brXIkljrlI+N7NNW1IAXGn/6IZPi3YQ== +"@esbuild/netbsd-x64@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.17.14.tgz#5fa5255a64e9bf3947c1b3bef5e458b50b211994" + integrity sha512-nVwpqvb3yyXztxIT2+VsxJhB5GCgzPdk1n0HHSnchRAcxqKO6ghXwHhJnr0j/B+5FSyEqSxF4q03rbA2fKXtUQ== -"@esbuild/openbsd-x64@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.16.4.tgz#c51e36db875948b7b11d08bafa355605a1aa289c" - integrity sha512-nLgdc6tWEhcCFg/WVFaUxHcPK3AP/bh+KEwKtl69Ay5IBqUwKDaq/6Xk0E+fh/FGjnLwqFSsarsbPHeKM8t8Sw== +"@esbuild/openbsd-x64@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.17.14.tgz#74d14c79dcb6faf446878cc64284aa4e02f5ca6f" + integrity sha512-1RZ7uQQ9zcy/GSAJL1xPdN7NDdOOtNEGiJalg/MOzeakZeTrgH/DoCkbq7TaPDiPhWqnDF+4bnydxRqQD7il6g== -"@esbuild/sunos-x64@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.16.4.tgz#0b50e941cd44f069e9f2573321aec984244ec228" - integrity sha512-08SluG24GjPO3tXKk95/85n9kpyZtXCVwURR2i4myhrOfi3jspClV0xQQ0W0PYWHioJj+LejFMt41q+PG3mlAQ== +"@esbuild/sunos-x64@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.17.14.tgz#5c7d1c7203781d86c2a9b2ff77bd2f8036d24cfa" + integrity sha512-nqMjDsFwv7vp7msrwWRysnM38Sd44PKmW8EzV01YzDBTcTWUpczQg6mGao9VLicXSgW/iookNK6AxeogNVNDZA== -"@esbuild/win32-arm64@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.16.4.tgz#d1c93b20f17355ab2221cd18e13ae2f1b68013e3" - integrity sha512-yYiRDQcqLYQSvNQcBKN7XogbrSvBE45FEQdH8fuXPl7cngzkCvpsG2H9Uey39IjQ6gqqc+Q4VXYHsQcKW0OMjQ== +"@esbuild/win32-arm64@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.17.14.tgz#dc36ed84f1390e73b6019ccf0566c80045e5ca3d" + integrity sha512-xrD0mccTKRBBIotrITV7WVQAwNJ5+1va6L0H9zN92v2yEdjfAN7864cUaZwJS7JPEs53bDTzKFbfqVlG2HhyKQ== -"@esbuild/win32-ia32@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.16.4.tgz#df5910e76660e0acbbdceb8d4ae6bf1efeade6ae" - integrity sha512-5rabnGIqexekYkh9zXG5waotq8mrdlRoBqAktjx2W3kb0zsI83mdCwrcAeKYirnUaTGztR5TxXcXmQrEzny83w== +"@esbuild/win32-ia32@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.17.14.tgz#0802a107afa9193c13e35de15a94fe347c588767" + integrity sha512-nXpkz9bbJrLLyUTYtRotSS3t5b+FOuljg8LgLdINWFs3FfqZMtbnBCZFUmBzQPyxqU87F8Av+3Nco/M3hEcu1w== -"@esbuild/win32-x64@0.16.4": - version "0.16.4" - resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.16.4.tgz#6ec594468610c176933da1387c609558371d37e0" - integrity sha512-sN/I8FMPtmtT2Yw+Dly8Ur5vQ5a/RmC8hW7jO9PtPSQUPkowxWpcUZnqOggU7VwyT3Xkj6vcXWd3V/qTXwultQ== +"@esbuild/win32-x64@0.17.14": + version "0.17.14" + resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.17.14.tgz#e81fb49de05fed91bf74251c9ca0343f4fc77d31" + integrity sha512-gPQmsi2DKTaEgG14hc3CHXHp62k8g6qr0Pas+I4lUxRMugGSATh/Bi8Dgusoz9IQ0IfdrvLpco6kujEIBoaogA== -"@eslint/eslintrc@^1.3.3": - version "1.3.3" - resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-1.3.3.tgz#2b044ab39fdfa75b4688184f9e573ce3c5b0ff95" - integrity sha512-uj3pT6Mg+3t39fvLrj8iuCIJ38zKO9FpGtJ4BBJebJhEwjoT+KLVNCcHT5QC9NGRIEi7fZ0ZR8YRb884auB4Lg== +"@eslint-community/eslint-utils@^4.2.0": + version "4.4.0" + resolved "https://registry.yarnpkg.com/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz#a23514e8fb9af1269d5f7788aa556798d61c6b59" + integrity sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA== + dependencies: + eslint-visitor-keys "^3.3.0" + +"@eslint-community/regexpp@^4.4.0": + version "4.5.0" + resolved "https://registry.yarnpkg.com/@eslint-community/regexpp/-/regexpp-4.5.0.tgz#f6f729b02feee2c749f57e334b7a1b5f40a81724" + integrity sha512-vITaYzIcNmjn5tF5uxcZ/ft7/RXGrMUIS9HalWckEOF6ESiwXKoMzAQf2UW0aVd6rnOeExTJVd5hmWXucBKGXQ== + +"@eslint/eslintrc@^2.0.2": + version "2.0.2" + resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-2.0.2.tgz#01575e38707add677cf73ca1589abba8da899a02" + integrity sha512-3W4f5tDUra+pA+FzgugqL2pRimUTDJWKr7BINqOpkZrC0uYI0NIc0/JFgBROCU07HR6GieA5m3/rsPIhDmCXTQ== dependencies: ajv "^6.12.4" debug "^4.3.2" - espree "^9.4.0" - globals "^13.15.0" + espree "^9.5.1" + globals "^13.19.0" ignore "^5.2.0" import-fresh "^3.2.1" js-yaml "^4.1.0" minimatch "^3.1.2" strip-json-comments "^3.1.1" -"@humanwhocodes/config-array@^0.11.6": - version "0.11.7" - resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.11.7.tgz#38aec044c6c828f6ed51d5d7ae3d9b9faf6dbb0f" - integrity sha512-kBbPWzN8oVMLb0hOUYXhmxggL/1cJE6ydvjDIGi9EnAGUyA7cLVKQg+d/Dsm+KZwx2czGHrCmMVLiyg8s5JPKw== +"@eslint/js@8.37.0": + version "8.37.0" + resolved "https://registry.yarnpkg.com/@eslint/js/-/js-8.37.0.tgz#cf1b5fa24217fe007f6487a26d765274925efa7d" + integrity sha512-x5vzdtOOGgFVDCUs81QRB2+liax8rFg3+7hqM+QhBG0/G3F1ZsoYl97UrqgHgQ9KKT7G6c4V+aTUCgu/n22v1A== + +"@humanwhocodes/config-array@^0.11.8": + version "0.11.8" + resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.11.8.tgz#03595ac2075a4dc0f191cc2131de14fbd7d410b9" + integrity sha512-UybHIJzJnR5Qc/MsD9Kr+RpO2h+/P1GhOwdiLPXK5TWk5sgTdu88bTD9UP+CKbPPh5Rni1u0GjAdYQLemG8g+g== dependencies: "@humanwhocodes/object-schema" "^1.2.1" debug "^4.1.1" @@ -248,10 +265,10 @@ resolved "https://registry.yarnpkg.com/@types/long/-/long-4.0.2.tgz#b74129719fc8d11c01868010082d483b7545591a" integrity sha512-MqTGEo5bj5t157U6fA/BiDynNkn0YknVdh48CMPkTSpFTVmvao5UQmm7uEF6xBEo7qIMAlY/JSleYaE6VOdpaA== -"@types/node@18.7.16": - version "18.7.16" - resolved "https://registry.yarnpkg.com/@types/node/-/node-18.7.16.tgz#0eb3cce1e37c79619943d2fd903919fc30850601" - integrity sha512-EQHhixfu+mkqHMZl1R2Ovuvn47PUw18azMJOTwSZr9/fhzHNGXAJ0ma0dayRVchprpCj0Kc1K1xKoWaATWF1qg== +"@types/node@18.15.11": + version "18.15.11" + resolved "https://registry.yarnpkg.com/@types/node/-/node-18.15.11.tgz#b3b790f09cb1696cffcec605de025b088fa4225f" + integrity sha512-E5Kwq2n4SbMzQOn6wnmBjuK9ouqlURrcZDVfbo9ftDDTFt3nk7ZKK4GMOzoYgnpQJKcxwQw+lGaBvvlMo0qN/Q== "@types/node@^10.1.0": version "10.17.60" @@ -263,87 +280,88 @@ resolved "https://registry.yarnpkg.com/@types/semver/-/semver-7.3.13.tgz#da4bfd73f49bd541d28920ab0e2bf0ee80f71c91" integrity sha512-21cFJr9z3g5dW8B0CVI9g2O9beqaThGQ6ZFBqHfwhzLDKUxaqTIy3vnfah/UPkfOiF2pLq+tGz+W8RyCskuslw== -"@typescript-eslint/eslint-plugin@^5.46.0": - version "5.46.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.46.0.tgz#9a96a713b9616c783501a3c1774c9e2b40217ad0" - integrity sha512-QrZqaIOzJAjv0sfjY4EjbXUi3ZOFpKfzntx22gPGr9pmFcTjcFw/1sS1LJhEubfAGwuLjNrPV0rH+D1/XZFy7Q== +"@typescript-eslint/eslint-plugin@^5.57.0": + version "5.57.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.57.0.tgz#52c8a7a4512f10e7249ca1e2e61f81c62c34365c" + integrity sha512-itag0qpN6q2UMM6Xgk6xoHa0D0/P+M17THnr4SVgqn9Rgam5k/He33MA7/D7QoJcdMxHFyX7U9imaBonAX/6qA== dependencies: - "@typescript-eslint/scope-manager" "5.46.0" - "@typescript-eslint/type-utils" "5.46.0" - "@typescript-eslint/utils" "5.46.0" + "@eslint-community/regexpp" "^4.4.0" + "@typescript-eslint/scope-manager" "5.57.0" + "@typescript-eslint/type-utils" "5.57.0" + "@typescript-eslint/utils" "5.57.0" debug "^4.3.4" + grapheme-splitter "^1.0.4" ignore "^5.2.0" natural-compare-lite "^1.4.0" - regexpp "^3.2.0" semver "^7.3.7" tsutils "^3.21.0" -"@typescript-eslint/parser@^5.46.0": - version "5.46.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-5.46.0.tgz#002d8e67122947922a62547acfed3347cbf2c0b6" - integrity sha512-joNO6zMGUZg+C73vwrKXCd8usnsmOYmgW/w5ZW0pG0RGvqeznjtGDk61EqqTpNrFLUYBW2RSBFrxdAZMqA4OZA== +"@typescript-eslint/parser@^5.57.0": + version "5.57.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-5.57.0.tgz#f675bf2cd1a838949fd0de5683834417b757e4fa" + integrity sha512-orrduvpWYkgLCyAdNtR1QIWovcNZlEm6yL8nwH/eTxWLd8gsP+25pdLHYzL2QdkqrieaDwLpytHqycncv0woUQ== dependencies: - "@typescript-eslint/scope-manager" "5.46.0" - "@typescript-eslint/types" "5.46.0" - "@typescript-eslint/typescript-estree" "5.46.0" + "@typescript-eslint/scope-manager" "5.57.0" + "@typescript-eslint/types" "5.57.0" + "@typescript-eslint/typescript-estree" "5.57.0" debug "^4.3.4" -"@typescript-eslint/scope-manager@5.46.0": - version "5.46.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-5.46.0.tgz#60790b14d0c687dd633b22b8121374764f76ce0d" - integrity sha512-7wWBq9d/GbPiIM6SqPK9tfynNxVbfpihoY5cSFMer19OYUA3l4powA2uv0AV2eAZV6KoAh6lkzxv4PoxOLh1oA== +"@typescript-eslint/scope-manager@5.57.0": + version "5.57.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-5.57.0.tgz#79ccd3fa7bde0758059172d44239e871e087ea36" + integrity sha512-NANBNOQvllPlizl9LatX8+MHi7bx7WGIWYjPHDmQe5Si/0YEYfxSljJpoTyTWFTgRy3X8gLYSE4xQ2U+aCozSw== dependencies: - "@typescript-eslint/types" "5.46.0" - "@typescript-eslint/visitor-keys" "5.46.0" + "@typescript-eslint/types" "5.57.0" + "@typescript-eslint/visitor-keys" "5.57.0" -"@typescript-eslint/type-utils@5.46.0": - version "5.46.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-5.46.0.tgz#3a4507b3b437e2fd9e95c3e5eea5ae16f79d64b3" - integrity sha512-dwv4nimVIAsVS2dTA0MekkWaRnoYNXY26dKz8AN5W3cBFYwYGFQEqm/cG+TOoooKlncJS4RTbFKgcFY/pOiBCg== +"@typescript-eslint/type-utils@5.57.0": + version "5.57.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-5.57.0.tgz#98e7531c4e927855d45bd362de922a619b4319f2" + integrity sha512-kxXoq9zOTbvqzLbdNKy1yFrxLC6GDJFE2Yuo3KqSwTmDOFjUGeWSakgoXT864WcK5/NAJkkONCiKb1ddsqhLXQ== dependencies: - "@typescript-eslint/typescript-estree" "5.46.0" - "@typescript-eslint/utils" "5.46.0" + "@typescript-eslint/typescript-estree" "5.57.0" + "@typescript-eslint/utils" "5.57.0" debug "^4.3.4" tsutils "^3.21.0" -"@typescript-eslint/types@5.46.0": - version "5.46.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-5.46.0.tgz#f4d76622a996b88153bbd829ea9ccb9f7a5d28bc" - integrity sha512-wHWgQHFB+qh6bu0IAPAJCdeCdI0wwzZnnWThlmHNY01XJ9Z97oKqKOzWYpR2I83QmshhQJl6LDM9TqMiMwJBTw== +"@typescript-eslint/types@5.57.0": + version "5.57.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-5.57.0.tgz#727bfa2b64c73a4376264379cf1f447998eaa132" + integrity sha512-mxsod+aZRSyLT+jiqHw1KK6xrANm19/+VFALVFP5qa/aiJnlP38qpyaTd0fEKhWvQk6YeNZ5LGwI1pDpBRBhtQ== -"@typescript-eslint/typescript-estree@5.46.0": - version "5.46.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-5.46.0.tgz#a6c2b84b9351f78209a1d1f2d99ca553f7fa29a5" - integrity sha512-kDLNn/tQP+Yp8Ro2dUpyyVV0Ksn2rmpPpB0/3MO874RNmXtypMwSeazjEN/Q6CTp8D7ExXAAekPEcCEB/vtJkw== +"@typescript-eslint/typescript-estree@5.57.0": + version "5.57.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-5.57.0.tgz#ebcd0ee3e1d6230e888d88cddf654252d41e2e40" + integrity sha512-LTzQ23TV82KpO8HPnWuxM2V7ieXW8O142I7hQTxWIHDcCEIjtkat6H96PFkYBQqGFLW/G/eVVOB9Z8rcvdY/Vw== dependencies: - "@typescript-eslint/types" "5.46.0" - "@typescript-eslint/visitor-keys" "5.46.0" + "@typescript-eslint/types" "5.57.0" + "@typescript-eslint/visitor-keys" "5.57.0" debug "^4.3.4" globby "^11.1.0" is-glob "^4.0.3" semver "^7.3.7" tsutils "^3.21.0" -"@typescript-eslint/utils@5.46.0": - version "5.46.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-5.46.0.tgz#600cd873ba471b7d8b0b9f35de34cf852c6fcb31" - integrity sha512-4O+Ps1CRDw+D+R40JYh5GlKLQERXRKW5yIQoNDpmXPJ+C7kaPF9R7GWl+PxGgXjB3PQCqsaaZUpZ9dG4U6DO7g== +"@typescript-eslint/utils@5.57.0": + version "5.57.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-5.57.0.tgz#eab8f6563a2ac31f60f3e7024b91bf75f43ecef6" + integrity sha512-ps/4WohXV7C+LTSgAL5CApxvxbMkl9B9AUZRtnEFonpIxZDIT7wC1xfvuJONMidrkB9scs4zhtRyIwHh4+18kw== dependencies: + "@eslint-community/eslint-utils" "^4.2.0" "@types/json-schema" "^7.0.9" "@types/semver" "^7.3.12" - "@typescript-eslint/scope-manager" "5.46.0" - "@typescript-eslint/types" "5.46.0" - "@typescript-eslint/typescript-estree" "5.46.0" + "@typescript-eslint/scope-manager" "5.57.0" + "@typescript-eslint/types" "5.57.0" + "@typescript-eslint/typescript-estree" "5.57.0" eslint-scope "^5.1.1" - eslint-utils "^3.0.0" semver "^7.3.7" -"@typescript-eslint/visitor-keys@5.46.0": - version "5.46.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-5.46.0.tgz#36d87248ae20c61ef72404bcd61f14aa2563915f" - integrity sha512-E13gBoIXmaNhwjipuvQg1ByqSAu/GbEpP/qzFihugJ+MomtoJtFAJG/+2DRPByf57B863m0/q7Zt16V9ohhANw== +"@typescript-eslint/visitor-keys@5.57.0": + version "5.57.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-5.57.0.tgz#e2b2f4174aff1d15eef887ce3d019ecc2d7a8ac1" + integrity sha512-ery2g3k0hv5BLiKpPuwYt9KBkAp2ugT6VvyShXdLOkax895EC55sP0Tx5L0fZaQueiK3fBLvHVvEl3jFS5ia+g== dependencies: - "@typescript-eslint/types" "5.46.0" + "@typescript-eslint/types" "5.57.0" eslint-visitor-keys "^3.3.0" acorn-jsx@^5.3.2: @@ -352,9 +370,9 @@ acorn-jsx@^5.3.2: integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ== acorn@^8.8.0: - version "8.8.0" - resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.8.0.tgz#88c0187620435c7f6015803f5539dae05a9dbea8" - integrity sha512-QOxyigPVrpZ2GXT+PFyZTl6TtOFc5egxHIP9IlQ+RbupQuX4RkT/Bee4/kQuC02Xkzg84JcT7oLYtDIQxp+v7w== + version "8.8.2" + resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.8.2.tgz#1b2f25db02af965399b9776b0c2c391276d37c4a" + integrity sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw== ajv@^6.10.0, ajv@^6.12.4: version "6.12.6" @@ -478,33 +496,33 @@ doctrine@^3.0.0: dependencies: esutils "^2.0.2" -esbuild@^0.16.4: - version "0.16.4" - resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.16.4.tgz#06c86298d233386f5e41bcc14d36086daf3f40bd" - integrity sha512-qQrPMQpPTWf8jHugLWHoGqZjApyx3OEm76dlTXobHwh/EBbavbRdjXdYi/GWr43GyN0sfpap14GPkb05NH3ROA== +esbuild@^0.17.14: + version "0.17.14" + resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.17.14.tgz#d61a22de751a3133f3c6c7f9c1c3e231e91a3245" + integrity sha512-vOO5XhmVj/1XQR9NQ1UPq6qvMYL7QFJU57J5fKBKBKxp17uDt5PgxFDb4A2nEiXhr1qQs4x0F5+66hVVw4ruNw== optionalDependencies: - "@esbuild/android-arm" "0.16.4" - "@esbuild/android-arm64" "0.16.4" - "@esbuild/android-x64" "0.16.4" - "@esbuild/darwin-arm64" "0.16.4" - "@esbuild/darwin-x64" "0.16.4" - "@esbuild/freebsd-arm64" "0.16.4" - "@esbuild/freebsd-x64" "0.16.4" - "@esbuild/linux-arm" "0.16.4" - "@esbuild/linux-arm64" "0.16.4" - "@esbuild/linux-ia32" "0.16.4" - "@esbuild/linux-loong64" "0.16.4" - "@esbuild/linux-mips64el" "0.16.4" - "@esbuild/linux-ppc64" "0.16.4" - "@esbuild/linux-riscv64" "0.16.4" - "@esbuild/linux-s390x" "0.16.4" - "@esbuild/linux-x64" "0.16.4" - "@esbuild/netbsd-x64" "0.16.4" - "@esbuild/openbsd-x64" "0.16.4" - "@esbuild/sunos-x64" "0.16.4" - "@esbuild/win32-arm64" "0.16.4" - "@esbuild/win32-ia32" "0.16.4" - "@esbuild/win32-x64" "0.16.4" + "@esbuild/android-arm" "0.17.14" + "@esbuild/android-arm64" "0.17.14" + "@esbuild/android-x64" "0.17.14" + "@esbuild/darwin-arm64" "0.17.14" + "@esbuild/darwin-x64" "0.17.14" + "@esbuild/freebsd-arm64" "0.17.14" + "@esbuild/freebsd-x64" "0.17.14" + "@esbuild/linux-arm" "0.17.14" + "@esbuild/linux-arm64" "0.17.14" + "@esbuild/linux-ia32" "0.17.14" + "@esbuild/linux-loong64" "0.17.14" + "@esbuild/linux-mips64el" "0.17.14" + "@esbuild/linux-ppc64" "0.17.14" + "@esbuild/linux-riscv64" "0.17.14" + "@esbuild/linux-s390x" "0.17.14" + "@esbuild/linux-x64" "0.17.14" + "@esbuild/netbsd-x64" "0.17.14" + "@esbuild/openbsd-x64" "0.17.14" + "@esbuild/sunos-x64" "0.17.14" + "@esbuild/win32-arm64" "0.17.14" + "@esbuild/win32-ia32" "0.17.14" + "@esbuild/win32-x64" "0.17.14" escape-string-regexp@^4.0.0: version "4.0.0" @@ -527,30 +545,21 @@ eslint-scope@^7.1.1: esrecurse "^4.3.0" estraverse "^5.2.0" -eslint-utils@^3.0.0: - version "3.0.0" - resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-3.0.0.tgz#8aebaface7345bb33559db0a1f13a1d2d48c3672" - integrity sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA== +eslint-visitor-keys@^3.3.0, eslint-visitor-keys@^3.4.0: + version "3.4.0" + resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-3.4.0.tgz#c7f0f956124ce677047ddbc192a68f999454dedc" + integrity sha512-HPpKPUBQcAsZOsHAFwTtIKcYlCje62XB7SEAcxjtmW6TD1WVpkS6i6/hOVtTZIl4zGj/mBqpFVGvaDneik+VoQ== + +eslint@^8.37.0: + version "8.37.0" + resolved "https://registry.yarnpkg.com/eslint/-/eslint-8.37.0.tgz#1f660ef2ce49a0bfdec0b0d698e0b8b627287412" + integrity sha512-NU3Ps9nI05GUoVMxcZx1J8CNR6xOvUT4jAUMH5+z8lpp3aEdPVCImKw6PWG4PY+Vfkpr+jvMpxs/qoE7wq0sPw== dependencies: - eslint-visitor-keys "^2.0.0" - -eslint-visitor-keys@^2.0.0: - version "2.1.0" - resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz#f65328259305927392c938ed44eb0a5c9b2bd303" - integrity sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw== - -eslint-visitor-keys@^3.3.0: - version "3.3.0" - resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz#f6480fa6b1f30efe2d1968aa8ac745b862469826" - integrity sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA== - -eslint@^8.29.0: - version "8.29.0" - resolved "https://registry.yarnpkg.com/eslint/-/eslint-8.29.0.tgz#d74a88a20fb44d59c51851625bc4ee8d0ec43f87" - integrity sha512-isQ4EEiyUjZFbEKvEGJKKGBwXtvXX+zJbkVKCgTuB9t/+jUBcy8avhkEwWJecI15BkRkOYmvIM5ynbhRjEkoeg== - dependencies: - "@eslint/eslintrc" "^1.3.3" - "@humanwhocodes/config-array" "^0.11.6" + "@eslint-community/eslint-utils" "^4.2.0" + "@eslint-community/regexpp" "^4.4.0" + "@eslint/eslintrc" "^2.0.2" + "@eslint/js" "8.37.0" + "@humanwhocodes/config-array" "^0.11.8" "@humanwhocodes/module-importer" "^1.0.1" "@nodelib/fs.walk" "^1.2.8" ajv "^6.10.0" @@ -560,16 +569,15 @@ eslint@^8.29.0: doctrine "^3.0.0" escape-string-regexp "^4.0.0" eslint-scope "^7.1.1" - eslint-utils "^3.0.0" - eslint-visitor-keys "^3.3.0" - espree "^9.4.0" - esquery "^1.4.0" + eslint-visitor-keys "^3.4.0" + espree "^9.5.1" + esquery "^1.4.2" esutils "^2.0.2" fast-deep-equal "^3.1.3" file-entry-cache "^6.0.1" find-up "^5.0.0" glob-parent "^6.0.2" - globals "^13.15.0" + globals "^13.19.0" grapheme-splitter "^1.0.4" ignore "^5.2.0" import-fresh "^3.0.0" @@ -584,24 +592,23 @@ eslint@^8.29.0: minimatch "^3.1.2" natural-compare "^1.4.0" optionator "^0.9.1" - regexpp "^3.2.0" strip-ansi "^6.0.1" strip-json-comments "^3.1.0" text-table "^0.2.0" -espree@^9.4.0: - version "9.4.0" - resolved "https://registry.yarnpkg.com/espree/-/espree-9.4.0.tgz#cd4bc3d6e9336c433265fc0aa016fc1aaf182f8a" - integrity sha512-DQmnRpLj7f6TgN/NYb0MTzJXL+vJF9h3pHy4JhCIs3zwcgez8xmGg3sXHcEO97BrmO2OSvCwMdfdlyl+E9KjOw== +espree@^9.5.1: + version "9.5.1" + resolved "https://registry.yarnpkg.com/espree/-/espree-9.5.1.tgz#4f26a4d5f18905bf4f2e0bd99002aab807e96dd4" + integrity sha512-5yxtHSZXRSW5pvv3hAlXM5+/Oswi1AUFqBmbibKb5s6bp3rGIDkyXU6xCoyuuLhijr4SFwPrXRoZjz0AZDN9tg== dependencies: acorn "^8.8.0" acorn-jsx "^5.3.2" - eslint-visitor-keys "^3.3.0" + eslint-visitor-keys "^3.4.0" -esquery@^1.4.0: - version "1.4.0" - resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.4.0.tgz#2148ffc38b82e8c7057dfed48425b3e61f0f24a5" - integrity sha512-cCDispWt5vHHtwMY2YrAQ4ibFkAL8RbH5YGBnZBc90MolvvfkkQcJro/aZiAQUlQ3qgrYS6D6v8Gc5G5CQsc9w== +esquery@^1.4.2: + version "1.5.0" + resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.5.0.tgz#6ce17738de8577694edd7361c57182ac8cb0db0b" + integrity sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg== dependencies: estraverse "^5.1.0" @@ -633,9 +640,9 @@ fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3: integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q== fast-glob@^3.2.9: - version "3.2.11" - resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.11.tgz#a1172ad95ceb8a16e20caa5c5e56480e5129c1d9" - integrity sha512-xrO3+1bxSo3ZVHAnqzyuewYT6aMFHRAd4Kcs92MAonjwQZLsK9d0SF1IyQ3k5PoirxTW0Oe/RqFgMQ6TcNE5Ew== + version "3.2.12" + resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.12.tgz#7f39ec99c2e6ab030337142da9e0c18f37afae80" + integrity sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w== dependencies: "@nodelib/fs.stat" "^2.0.2" "@nodelib/fs.walk" "^1.2.3" @@ -654,9 +661,9 @@ fast-levenshtein@^2.0.6: integrity sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw== fastq@^1.6.0: - version "1.13.0" - resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.13.0.tgz#616760f88a7526bdfc596b7cab8c18938c36b98c" - integrity sha512-YpkpUnK8od0o1hmeSc7UUs/eB/vIPWJYjKck2QKIzAf71Vm1AAQ3EbuZB3g2JIy+pg+ERD0vqI79KyZiB2e2Nw== + version "1.15.0" + resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.15.0.tgz#d04d07c6a2a68fe4599fea8d2e103a937fae6b3a" + integrity sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw== dependencies: reusify "^1.0.4" @@ -726,10 +733,10 @@ glob@^7.1.3: once "^1.3.0" path-is-absolute "^1.0.0" -globals@^13.15.0: - version "13.17.0" - resolved "https://registry.yarnpkg.com/globals/-/globals-13.17.0.tgz#902eb1e680a41da93945adbdcb5a9f361ba69bd4" - integrity sha512-1C+6nQRb1GwGMKm2dH/E7enFAMxGTmGI7/dEdhy/DNelv85w9B72t3uc5frtMNXIbzrarJJ/lTCjcaZwbLJmyw== +globals@^13.19.0: + version "13.20.0" + resolved "https://registry.yarnpkg.com/globals/-/globals-13.20.0.tgz#ea276a1e508ffd4f1612888f9d1bad1e2717bf82" + integrity sha512-Qg5QtVkCy/kv3FUSlu4ukeZDVf9ee0iXLAUYX13gbR17bnejFTzr4iS9bY7kwCf1NztRNm1t91fjOiyx4CSwPQ== dependencies: type-fest "^0.20.2" @@ -746,9 +753,9 @@ globby@^11.1.0: slash "^3.0.0" google-protobuf@^3.6.1: - version "3.21.0" - resolved "https://registry.yarnpkg.com/google-protobuf/-/google-protobuf-3.21.0.tgz#8dfa3fca16218618d373d414d3c1139e28034d6e" - integrity sha512-byR7MBTK4tZ5PZEb+u5ZTzpt4SfrTxv5682MjPlHN16XeqgZE2/8HOIWeiXe8JKnT9OVbtBGhbq8mtvkK8cd5g== + version "3.21.2" + resolved "https://registry.yarnpkg.com/google-protobuf/-/google-protobuf-3.21.2.tgz#4580a2bea8bbb291ee579d1fefb14d6fa3070ea4" + integrity sha512-3MSOYFO5U9mPGikIYCzK0SaThypfGgS6bHqrUGXG3DPHCrb+txNqeEcns1W0lkGfk0rCyNXm7xB9rMxnCiZOoA== grapheme-splitter@^1.0.4: version "1.0.4" @@ -761,9 +768,9 @@ has-flag@^4.0.0: integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ== ignore@^5.2.0: - version "5.2.0" - resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.2.0.tgz#6d3bac8fa7fe0d45d9f9be7bac2fc279577e345a" - integrity sha512-CmxgYGiEPCLhfLnpPp1MoRmifwEIOgjcHXxOBjv7mY96c+eWScsOP9c112ZyLdWHi0FxHjI+4uVhKYp/gcdRmQ== + version "5.2.4" + resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.2.4.tgz#a291c0c6178ff1b960befe47fcdec301674a6324" + integrity sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ== import-fresh@^3.0.0, import-fresh@^3.2.1: version "3.3.0" @@ -819,9 +826,9 @@ isexe@^2.0.0: integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw== js-sdsl@^4.1.4: - version "4.1.4" - resolved "https://registry.yarnpkg.com/js-sdsl/-/js-sdsl-4.1.4.tgz#78793c90f80e8430b7d8dc94515b6c77d98a26a6" - integrity sha512-Y2/yD55y5jteOAmY50JbUZYwk3CP3wnLPEZnlR1w9oKhITrBEtAxwuWKebFf8hMrPMgbYwFoWK/lH2sBkErELw== + version "4.4.0" + resolved "https://registry.yarnpkg.com/js-sdsl/-/js-sdsl-4.4.0.tgz#8b437dbe642daa95760400b602378ed8ffea8430" + integrity sha512-FfVSdx6pJ41Oa+CF7RDaFmTnCaFhua+SNYQX74riGOpl96x+2jQCqEfQ2bnXu/5DPCqlRuiqyvTJM0Qjz26IVg== js-yaml@^4.1.0: version "4.1.0" @@ -997,20 +1004,15 @@ protobufjs@6.8.8: long "^4.0.0" punycode@^2.1.0: - version "2.1.1" - resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec" - integrity sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A== + version "2.3.0" + resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.3.0.tgz#f67fa67c94da8f4d0cfff981aee4118064199b8f" + integrity sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA== queue-microtask@^1.2.2: version "1.2.3" resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243" integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A== -regexpp@^3.2.0: - version "3.2.0" - resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-3.2.0.tgz#0425a2768d8f23bad70ca4b90461fa2f1213e1b2" - integrity sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg== - resolve-from@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6" @@ -1041,9 +1043,9 @@ semver@5.6.0: integrity sha512-RS9R6R35NYgQn++fkDWaOmqGoj4Ek9gGs+DPxNUZKuwE183xjJroKvyo1IzVFeXvUrvmALy6FWD5xrdJT25gMg== semver@^7.3.7: - version "7.3.7" - resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.7.tgz#12c5b649afdbf9049707796e22a4028814ce523f" - integrity sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g== + version "7.3.8" + resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.8.tgz#07a78feafb3f7b32347d725e33de7e2a2df67798" + integrity sha512-NB1ctGL5rlHrPJtFDVIVzTyQylMLu9N9VICA6HSFJo8MCGVTMW6gfpicwKmmK/dAjTOrqu5l63JJOpDSrAis3A== dependencies: lru-cache "^6.0.0" @@ -1132,10 +1134,10 @@ type-fest@^0.20.2: resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.20.2.tgz#1bf207f4b28f91583666cb5fbd327887301cd5f4" integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ== -typescript@^4.8.3: - version "4.8.3" - resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.8.3.tgz#d59344522c4bc464a65a730ac695007fdb66dd88" - integrity sha512-goMHfm00nWPa8UvR/CPSvykqf6dVV8x/dp0c5mFTMTIu0u0FlGWRioyy7Nn0PGAdHxpJZnuO/ut+PpQ8UiHAig== +typescript@^5.0.3: + version "5.0.3" + resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.0.3.tgz#fe976f0c826a88d0a382007681cbb2da44afdedf" + integrity sha512-xv8mOEDnigb/tN9PSMTwSEqAnUvkoXMQlicOb0IUVDBSQCgBSaAAROUZYy2IcUy5qU6XajK5jjjO7TMWqBTKZA== uri-js@^4.2.2: version "4.4.1" @@ -1169,4 +1171,4 @@ yallist@^4.0.0: yocto-queue@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b" - integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q== \ No newline at end of file + integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==