Squashed 'third_party/flatbuffers/' changes from acc9990ab..d6a8dbd26
d6a8dbd26 Experimental fix for failing oss-fuzz coverage build (#6259)
ed391e177 BREAKING: Rust flexbuffers serde human readable set to false (#6257)
a49531414 Update to flags in fuzzing-cmake file (#6256)
de1f0342c Remove _POSIX_C_SOURCE and _XOPEN_SOURCE definitions when compiling o… (#6205)
d0d51e2a5 flatc should support --binary --schema with optional scalar fields. (#6252)
33ab26017 Bump version of rules_go to 0.24.5 (#6234)
febb9d87c Union As Accessors for C# (#6251)
8778dc7c2 Resets buffer without deallocating current pointer (#6247)
aae376e9a Add GetBufferSpan() function to bufferbuilder (#6235)
0ff047148 Modernize android build and sample (#6229)
46a8c7e95 Added required-nested-flatbuffer to monster_test and fixed rust (#6236)
bc56c553e Notify based on Labelling issues and PR (#6241)
07d7cd78a Converted globs to use single quotes (#6240)
cdef70e24 More adjustments to the auto labeler (#6239)
9dd44df35 Updated Lua labeller glob (#6238)
c9b29d088 Support size-prefixed buffers and add tests for size-prefixed messages (#6232)
fba93e0ab Removes duplicate swift in labeler (#6228)
d1a545b1f Added more labels for auto labeler (#6227)
ea92a668d [C#] Optional Scalars (#6217)
6034de286 [Label Bot] Add Java and Kotlin support for the label bot (#6226)
b08b0a440 Implement `Debug` trait for Rust flatbuffers. (#6207)
17ae48dec [Label Bot] Adds some languages to labeler bot (#6222)
fc8097925 Auto Labeler Setup, Just C# for now (#6221)
55658f523 Auto Labeler Setup, Just C# for now (#6218)
14ecfe423 Updated comments and fixed a fundamental type error. (#6214)
a0182cdb1 optional scalars for ts/js (#6215)
0dfcc0a37 Adds NetTest.bat to run .NET Core tests on Windows (#6216)
f9a18ea63 [Java] Implement optional scalars (#6212)
c7586e85a Empties the sharedString map on reset on go and csharp (#6187)
914c64601 Removed C# references from java generator. Move annotations closer to definitions (#6204)
42d7c7997 Adds readable size to asserts in read functions (#6210)
e68e8d7de Refactor idl_gen_rust (#6206)
84809be7e Fix typo in flatbuffers::span declaration. (#6202)
1606fb637 Kotlin test optional enum (#6201)
fe8e3c7e5 Mass Refactoring to use `IsString` and other BASE_TYPE helpers (#6193)
8f6fa4b71 Updated SupportsAdvancedUnionFeatures to look out for string (#6190)
b46db38f5 [JS/TS] Rewrite flexbuffers JS to TS (#6148)
9fa1d2705 Rework enums in rust. (#6098)
a402b3aba idl_gen_json_schema Fix generation of arrays of enums (#6184)
0e1415b99 fix(go_test): remove deprecated grpc call (#6183)
5cd713710 Add generation of JSON Schema to library (#6165)
5be777e1d Bump junit from 4.12 to 4.13.1 in /grpc/tests (#6173)
a49d440ec Bump junit from 4.12 to 4.13.1 in /grpc (#6172)
4ec5e8db9 [C++] Add option to not generate direct copy methods. (#6166)
04bec23a3 Add Array initialization from struct constructor (#5865) (#6147)
77d57fd07 Cast to right type for reserved_ subtraction (#6167)
543c1bbeb Fixed rust nested flatbuffers for tables other than self (#6062)
cb971eece [C++] Fix -Wnarrowing and -Woverflow due to signed bitfields on G++ ARM (#6163)
7b9e61fcc [TS] GRPC Implementation (#6141)
3359e3042 Moved C++ to optional_scalars2 and added some tests. (#6162)
187a4787f [Rust] Upgrade flatbuffers library to 2018 edition (#6159)
08943aa26 Flatbuffer C++ UnpackTo optimization for vectors of non-bool bytes. (#6154)
5975658eb Enables optional enums in swift (#6160)
5d3cf440e Updated Lobster test for optional bools/enums
8ec8322f0 Ruopt enum (#6156)
bbcc85fd4 Fix generation of C++ code with Optional<Enum> (#6155)
0bdf2fa15 [C#] Fix and improve project files (#6142)
2eedc769d possibility to create a vector from an iterator (#6135)
ab01ae162 flatc should output a warning, when an attribute is attached more than once (#6146)
689bfafa7 [Python/JS/TS] Codegen SizeOf method for structs (#6136)
641309a5b unix2dos on tests/FlatBuffers.Test/FlatBuffers.Core.Test.csproj (#6133)
52e362879 SpanT is available in .Net Standard 2.0. (#6137)
dca12522a Add static cast to avoid implicit double promotion. (#6132)
e0bbaa6f9 [C#]Change to ENABLE_SPAN_T that doesn't require UNSAFE_BYTEBUFFER. (#6073)
ab139d6be Revert "[C#] Fix and improve project files (#6116)" (#6130)
34d67b425 Minireflect fixed array (#6129)
96d5e3597 [JS/TS] fix flatbuffers default export (#6123)
eb686a86f Add missed file generated by optional_scalar.fbs (#6125)
750281630 [C#] Fix and improve project files (#6116)
fb4e1c34f Add CharToLower and CharToUpper into util.s (#6126)
8c67b5b12 Add support of Optional<T> scalars to C++ code generator (#6092)
6228b66d3 [Kotlin] Support for optional scalars. (#6115)
e1be8aaad Bump version for latest swift version (#6121)
94873e595 [JS/TS] Modernize TypeScript / JavaScript flatbuffers support (#6095)
b8e87fafe [JS] Add getFullyQualifiedName() (#6119)
f96d1ef74 [Java] allowing larger buffer sizes when growing a byte buffer (#6118)
89435303b [Swift] Migrates struct write APIS to write directly to the buffer (#6093)
c75ae2429 Optional-ness in reflection (#6097)
338944d3d Rename Nullable scalars to Optional scalars (#6112)
f5ab24bc4 Avoid memcpy call for empty vectors (#6111)
92a8c1a0f [JS] FlexBuffers Fix for wrong type of offset and length values (#6107)
6cea45dcd fix c# json serializer commandline argument docs (#6104)
fec58aa12 Fix for issue 6100: incorrect shrinking logic in ResizeContext() (#6102)
71aca81ff [JS] FlexBuffers Support (#5973)
04d87ffec [C++] Small refactoring of the C++ code generator (#6091)
bb25956f0 Wrap verify file id condition in Check call (#6085)
49f4948f0 + Add `removable-media` plug to the snapcraft config (#6083)
eeacc53d2 Adds proper access types for swift object api & flatbuffers & grpc (#6081)
f3003e08d [Lobster] missed a test
d713a0084 [CMake] enabled multi-core builds in VS projects
77f966f89 [Lobster] optional scalars support
e86d5b8e9 [Kotlin] Attach JvmStatic annotation to each method in companion object (#6052)
db2aa9b4e [C#] Cleaned up .NET testing script for Mono (#6016)
63cc0eec4 Adds a serialize helper function to native table (#6059)
c30a87de6 [TS] Fix four bugs with imported types in TypeScript. (#6054)
a0fb30575 [Swift] Append namespace for Swift Grpc implementation (#6049)
77c18c1d6 export a __version__ variable for python module (#5309)
f1f23d08e adding fb import when no other imports are present (#6030)
f1025b284 [Feature] Checks for Nullable strings (#6050)
5d052f4e5 [Swift] RFC: Switch Swift namespace from public enum to ordinary concat with _ (#6045)
18b015d25 Rust codegen improvements and lint fixes (#6046)
d76e93f27 adds code gen for optional scalars in swift (#6038)
82fac326c [C++] Fix compiler error from deleted assignment operator (#6036) (#6047)
043b52bd4 Optional Scalars support for Rust (#6034)
c8fa0afdf Allow to run cpp tests under grpc/tests/ using bazel. (#6040)
6d0aae73c Fix git command executed in wrong folder when doing cmake superbuild (#6039)
ff1b73128 [Swift] Optional Scalars Preparation (#6028)
2e48c8dd3 tests: Check for both quiet and signaling NaN on mipsel/hppa (#6029)
6942704f2 support deprecated flag in json schema (#6022)
9ecd2e16c Flatc parser support for nullable scalars (#6026)
33e2d8079 [Dart] Generate constant values map for enums (#6025)
969d0f7a6 Using proper symbol name for reexport (#6021)
515a4052a Silence false positive "-Wstringop-overflow" on GCC 10.0 to 11.0 (#6020)
36fbe6f13 Updated FB import (#6019)
b69fc8cc9 [Java] Add support for shared strings on FlatBufferBuilder. (#6012)
ab6af18d9 Not using non-existent create method for obj api (#6015)
37a5dee10 Code cleanup + updates test and readme (#6004)
8a721f69a Serde with bytes maps to Blob (#6009)
e810635ea [Swift] FlatBuffers createMonster method doesn't treat struct properly (#5992)
4995e1527 Manage grpc dependency in Bazel's WORKSPACE file. (#5995)
60b6066fe Add warning to schema parser if field name is not snake_case. (#6005)
35d45cac7 [Rust] Flexbuffers dependency cleanup and fixes (#5998)
165a6e3d1 Re-added Evolution Schema Code Generation Command (#5999)
13d3fb2ea Fix RPM install conflict (#6003)
d64078eb2 [Swift] Initialize memory when clear ByteBuffer (#5982)
ca1190a3d [TS] Use proper TypedArray in create*Vector (#5991)
7571b2ac5 [C++] Updates real_path to be truly portable (#5787)
e5a8f76a4 [C++] Generate default member initializers for >= C++11 (#5989)
413bb9b55 [Kotlin] Fix Access to union of vector element (#5994)
f35184aef [Swift] Add parsing from unowned UnsafeMutableRawPointer for ByteBuffer (#5981)
b124b7625 Removed requirement that enums be declared in ascending order. (#5887)
0ec7600c6 Do not remove the last digit from float values (#5974)
14baf45c9 Mark GetBufferMinAlignment() const (#5985)
9abb2ec2c TypeScript/JavaScript docs improvements (#5984)
2e57d80b1 [Swift] Internal library improvements (#5965)
cfc7753a4 [Doc] Added missing letters to compiler options (#5976)
12ddc8a92 Rust Flexbuffers Documentation update (#5979)
24ad35709 [docs] typo: updates monsterdata.json to be valid json (#5978)
cc44a4442 [idl_parser] Mark typefield as deprecated (#5958)
9ab4a5c0e Deleted old stale bot
6682cfe87 Increased Operations per run in stale.yml
64922904b Adding Stale Action to clean up PR and Issues
8e505cb67 [C++] Fixed/Enabled --cpp-ptr-type std::shared_ptr [#5813] (#5959)
a28357d7a Propagate boolean default values from proto to fbs (#5964)
7cb4762a6 [Swift] Improving reallocation time by using memcpy and moving reallocation code to storage (#5960)
4e45f7c9e Fix error in SimpleQSort (#5955)
7ac026405 fix error on GRPC Python - ignore namespace tree if not specified (#5862) (#5922)
108e981db Required is now implemented in swift (#5952)
94a78e385 Fixed: Access violation and ASAN/UNSAN failures with sorted tables
53fb453e0 [rust] Add FlatBufferBuilder::force_defaults API (#5946)
17c1f35fa [FlexBuffer][Java] ReadWriteBuf and ReadBuf interface public (#5948)
2eaf57778 [Java] Grow ArrayReadWriteBuf enough to match requested capacity. (#5921)
666800da3 Adds bool support in structs + updates grpc support + CI upgrades (#5943)
38ed69eb3 fixed mutating inline values (#5942)
d026e6f07 Add static asserts to ensure that reflection API arrays are kept in sync (#5934)
988164f6e [C++] Got rid of memset's in constructors (#5938)
7179a5a8b General Codebase clean up (#5939)
a0da0c08c Add GetStringView like GetString, GetCstring (#5937)
ac203b209 [C#] Add file identifier to ObjectAPI Serialization Utility. (#5920)
8dd1bf25b not creating creation methods when using structs (#5919)
5aa443d98 [Dart] Adding FlexBuffers support (#5853)
0fa087657 [Dart] Getting tests/DartTest.sh to work on master. (#5915)
424a473e1 Schema parser: prohibit declaration of an array of pointers inside structs (#5907)
c3faa8346 Fix Cargo.toml dependencies (#5911)
91399ad05 fix union type names (#5902)
32782e4ad Update Rust Flexbuffers metadata before publishing (#5905)
e7f3b1690 [TS] Make Obj-API work with --short-names (#5898)
12ed1fe4a fixed invalid imports with --gen-all (#5895)
85ee4df7a [C#] Thread safe reads of Double and Float values from a ByteBuffer (#5900)
de89bd193 Implement flexbuffers in python (#5880)
8be05f6bd Rust Flexbuffers (#5669)
870ecbc09 [swift] Moves code to use VTablesStorage (#5888)
c2da8d5d8 [Java][FlexBuffers] Make FlexBuffersBuilder reusable by adding clear() (#5889) (#5890)
e84cbff67 Align package name to FindFlatBuffers.cmake (#5899)
f94e6c84e Small tutorial improvements - documentation only (#5894)
f12cca8bc Attempt at adding Github Actions CI
7e4124d6e Handle git program or .git folder absence (#5878)
a875d247a only add native_include_files if object based api is enabled (#5886)
6e9f5d981 Respect shared attribute in Parser (#5885)
ff1c78233 include/flatbuffers: typo fixes in comments (#5884)
2e9a19673 Updates swift docs for package management (#5883)
e3cb07d32 [Rust] idl_gen_rust.cpp: (Option/required-aware codegen for unions) (#5850)
712866d57 Propagate use_string_pooling in CopyTable (#5879)
44c919a9e Not using reexports with --gen-all (#5873)
99aa1ef21 Added INCLUDE_PREFIX option for flatbuffers_generate_headers (#5866)
40ba170c9 Fixed text in internals doc that implied structs can be root
cb4d0f72e [Swift] Object API support (#5826)
003e16405 [TS] Add Obj API (#5788)
21cf300f4 fix cpp usage markdown error (#5845)
9655e12d6 Upgraded swift implementation for grpc (#5843)
fb96fadc2 [C#] Fix nested structs and arrays in Object API (#5765)
408f11fbd [ts] Fix empty source/dest namespaces when reexporting. (#5841)
a83caf591 Improves performance for the swift library by using structs + a storage class (#5835)
925fab6b1 [Java][FlexBuffers] Optimize Map access (#5735)
d9fecc332 [CMake] : Add precompiled header support with FLATBUFFERS_ENABLE_PCH (#5827)
e9d453240 Added flatbuffers_generate_headers and flatbuffers_generate_binary_files cmake functions. (#5830)
c37c989ed Correct calculation of vector element size (#5831)
6b271b7ec Fix Clang-trunk warnings about special members deprecated in C++20. (#5829)
90f3b8e8c Fix `float_constant` definition in './doc/Grammar.md` (#5828)
3af735934 [csharp] flatc should generate a 'Create…' method for tables with struct field… (#5818)
c4231c3cb Updated doxyfile - added missing files (#5824)
9657df184 Update Grammar.md (#5820)
97ffc590e Include CPack only when explictly packaging (#5817)
8b52af65b [C++] Add max_depth and max_tables parameters to reflection::Verify (#5815)
9b034eee1 Fix interpretation of 'nan(number)' by the idl_parser (#5810)
3e9ac3cff [Scripts] Adds swift to generated code (#5806)
697147a2e updated maven build files
6df40a247 pre-tag version bump for 1.12
0dba63909 Removes the inner loop in the endtable check written tables (#5803)
0e3fdd0ee Escape characters in jsonschema descriptions (#5644)
45a2b07cb Remove `noexcept` qualifier copy-ctor of `union` type (#5800) (#5802)
d10c16314 Replace 'assert' by 'FLATBUFFERS_ASSERT' inside idl_parser.cpp (#5799)
35abb7f89 Add non-nullable modifier to return type of functions never returning null (#5797)
9954e09ab [C++] Generate code for vector force_align attribute. (#5796)
95a21327f rust: pub export the VectorIter type (#5736)
89b6183ee Fix Python min alignment
5a98d65e8 [Rust] Add gen-name-strings for Rust (#5757)
f73d205bc Removed assert that wasn't backwards compatible.
7c37abe92 [C#] add ObjectAPI Serialization Utility (#5785)
4749e77b0 Fixed docs on how to obtain parser error.
6ff189841 Added --filename-suffix and --filename-ext to flatc (#5778)
c9a30c9ca Fixed refractoring issue in reflection/generate_code.sh. Also, mv deletes the original file, so I don't need to clean it up manually in that case. (#5777)
8c02d17be Skip writing reflection_generated.h if not changed (#5776)
34305c4ce [Swift] Adds GRPC to Swift (#5758)
cd88e6b2a [Java][FlexBuffers] Abstract buffer access from ByteBuffer (#5743)
3ec7a53c6 Adds cocoapods and a readme of how to get the package (#5771)
6d44cede7 [snap] Fix versioning (#5727)
cc08c0835 [Python] Fixed potential allignment issue (#5768)
54f8b787c Fix memory leak on cpp object api (#5761)
17557f913 [Python] Fixed issue #5499 (#5764)
d54af8cd4 [C++] Use strong enum type for vectors when scoped-enums is on. (#5750)
173e10fdf [C#] support Json Serialization (#5752)
8f56990f6 FlexBuffers: C++: scalar-only typed vectors were not aligned.
6400c9b05 Bump Rust port to 0.6.1 (#5747)
7418d8587 [C#] support Object API (#5710)
c580fa284 Adds min and max, comments, and all of swift's keywords + fix docs (#5737)
f2a127230 Use VS 2017 and 2019 on CI, fix cast issue in dart_idl (#5740)
316d7c208 Creates a flatbuffers validation function + small fix (#5725)
47026ea6b Added the code to embed the binary schema to the source (--bfbs-gen-embed). (#5701)
3f677f241 [Java][FlexBuffers] Deprecate typed vector strings due to design flaw (#5722)
a593a11e5 [Go] Implements a SharedStrings function (#5733)
7cdfc8475 [Swift] Fix padding function overflow when bufSize is 0 (#5721)
bab2b0db4 Add vcpkg installation instructions (#5732)
89418eb84 [Dart] Fix deprecated field support, inf/nan (#5724)
9cadf05d8 [typescript] Size-prefixed root accessors not taking into account size prefix (#5717)
6da1cf79d [rust] Add use declarations to Rust-generated bindings for imported FB definitions (#5645)
bee1df96d [Go] Replace references to hardcoded ”Monster" etc with idiomatic go wherever possible (#5716)
01189d7ed [C++] Fix for printing of enum in case output_enum_identifiers=1. (#5706)
c4b2b0a25 [Swift] Support create long string (#5709)
a4b2884e4 Added create function for swift (#5707)
04d80f255 [Swift] Swift implementation 🎉🎉 (#5603)
55686100a Changed direct calls to strtod to use StringToNumber
718351831 Document JSON compatibility guarantees. (#5704)
d1b34f0f2 Add CMake 'generated_code' target to simplify resolution of build dependencies (#5697)
21b706196 (Optionally) add an additional suffix namespace to generated fbs files. (#5698)
35daaf83d [Java] Replace Table.UTF8_CHARSET with StandardCharsets.UTF_8 (#5696)
3b458f7a1 Rust: Temporarily disable 2 endianness unit tests (#5695)
a5d9d0f7d [C++17] Add Traits class for Tables and Factory function within it. (#5678)
3cd9b6434 Removed code_generators.cpp from library targets
355dfd48d [rust] Make enum names public (#5690)
bcd58a159 Correct inverted logic around include prefixes. (#5689)
a2c12900a Optimize Pack method using numpy (#5662)
901b89e73 [C++] Add Builder and Table typedefs (#5685)
31f879908 Minor doc updates: FlexBuffers C#, Discord, CppUsage.
8023d99e2 Upgrade rules_go (#5684)
b4154405d Fix --incompatible_load_cc_rules_from_bzl (#5683)
04c17c7a7 Add support for absl::string_view when available (#5682)
62ec7d52c [Bazel] Add support for compatible_with and restricted_to (#5681)
7de668053 CI: New Docker tests for Python with numpy (#5677)
3a70e0b30 Fixed struct initialization error on older versions of C#
9b1320135 Fixed warnings in FlexBuffers.java
5e3916050 Fixed out of date licenses on gRPC Python files.
c95755051 Removed test proto output.
44bf71988 Add flatc '--cpp_std' switch (#5656)
3e8f15df9 Fix for FlexBuffers FBT_VECTOR_STRING size bit-width.
602721a73 Added Check to VerifyAlignment (#5675)
13c05f4da Improve import handling for proto conversion (#5673)
ce3a1c43a [Dart] Fix prepare space for writeListInt64 and writeListUint64 (#5654)
aa75e5734 Make Rust constants public (#5659)
2790fee25 Add namespace qualification to union types (#5666)
eddebec1b Bugfix for Rust generation of union fields named with language keywords (#5592)
030fee36a wrap multiple statements in do {} while(!IsConstTrue(true)) (#5655)
f9724d1bd [gRPC] Uncomment MessageBuilder (#5658)
b20801ca4 Supress unsigned-integer-overflow for PaddingBytes (#5647)
a8e800bd7 Add --force-empty-vectors option (#5653)
d7530ae96 Fixed enum min/max values not properly escaped.
99d11e279 Split Bazel targets into multiple packages (#5640)
4fd8eb214 Remove a static_assert (#5643)
65f870357 Flatbuffers Python Object API (#5616)
75823cc27 [Clang 10]: definition of implicit copy constructor for 'TableKeyComparatoris deprecated #5649 (#5650)
58e279244 [docs]: add missing semicolon (#5648)
3c964e10a [GO] Fix support for enums with underscores and Unions with imported members (#5600)
c3c32ec94 Fix ambiguity of a type deduction in TEST_EQ macro if arguments have `enum class` type. (#5630)
075e8d676 Simplify declarations of x-macro FLATBUFFERS_TD (#5638)
bcf1bd5c9 read vtable size through ReadScalar() (#5636)
136d75fa6 Changed null checks in test. Removed verifier pointer usage (#5634)
091fa1fd1 Add testing of C++ with sanitizers (CI-Docker) (#5631)
ff3781dc2 add namespace prefix in FLATBUFFERS_MAX_BUFFER_SIZE (#5629)
6beb9f49c Support for python grpc - continuing the work from the pull request #4270 #4705 (#5613)
80988ea86 Removed idl_gen_general.cpp and move contents to code_generators.cpp (#5625)
0f2ff7eaa Lua cleanup (#5624)
dda095023 [C++] Adds basic schema evolution tests (#5611)
adbcbba5d [C++, C#, Java] Separated C# and Java generators into their own classes (#5618)
cbbd6aca0 add check for root_type specified for json schema generation (#5622)
405c64e07 [Rust] Bump smallvec version to 1.0 (#5621)
42c08cbca Ran src/clang-format-all.sh (#5617)
33d5dd9bd Improved pull request & clang-format instructions.
105dd528e Change monster_extra generation to use flatbuffers::unique_ptr (#5612)
f0f0efe7b [C++] Refactor to conform to Google C++ style guide (#5608)
e837d5a29 Fixed deprecated method in GRPC Java test.
9834ee978 Fixed Apache license not using canonical version.
44b2ab087 include/flatbuffers/base.h: fix no_sanitize issue with old clang (#5610)
46ae3f80a [C++, Java, C#, TypeScript, JavaScript] Skip generation of mutable union types (#5599)
7b38aa71e flatbuffers.h: fix documentation warning (#5607)
661bedd83 Add Lua FlatbufferBuilder Clean() method to enable reuseable builders (#5606)
8526e12d7 [Kotlin] Fix union vector accessor after change in Java API (#5605)
3c7b660d6 [flatc] Remove an always true condition for flexbuffers (#5604)
964365ba6 [Go] Add UnPackTo functions (#5598)
32254b7ac [Go] Object API support (#5339)
521e255ad Rust: Add idiomatic iterator for Vector type (#5579)
1b85292fd Fix typos in comments (#5590)
480815447 C++ verifier for evolved union fields should return true (#5586)
8d5e424c6 Add ByteBuffer copy for vector of bytes in Java (#5587)
b4774d235 Rust: Fix Copy and Clone impls for a few generic types (#5577)
26f238c24 Add `--clean-first` to the cmake-build command (travis) (#5574)
e93c8c46e Fix Follow implementation for bool (#5554)
e21516b9d Fix issue #5557 (#5573)
fbc11e8ae Avoid intentional unsigned integer overflow getting caught by sanitizers (#5572)
e9d29c21a Python: Add forceDefaults opt to python Builder (#5564)
8bfafc76d Java: Don't annotate vector-of-tables item getters with @nullable. (#5562)
df3e8bf4a Fixed warnings generated by recent JSON sorting feature.
5665cfe49 [Java] byte buffer factory returned buffer capcity is used instead of the requested size (#5558)
5797540ed #5544 Fix of Array of table is not sorted if Create<type>Direct() is used (#5546)
7f1af7cb0 Fix build with gcc version 7.4.0 (#5570)
32f47ad24 Fixed JSON parser not sorting vectors of tables/structs with key.
842f672ba [FlexBuffers][Java] Cache size of Sized objects in FlexBuffers (#5551)
d4cae0a62 Fix issue #5542 (#5543)
f1147f65b Fixed Android STLPort related error.
69d3fec48 Fix namespaced struct/field name collision detection (#5540) (#5545)
cfb4ecf6f [flac] Add FlexBuffers option for generating data (#5519)
a92039687 Update Rust versions under test from 1.30.1 to 1.37.0 (#5538)
625338d09 Adds XOPEN_SOURCE for PATH_MAX and POSIX 1993 for stat (#5529)
3f8ce99c5 [FlexBuffers][Java] Add override Key::toString (#5533)
0798b7b69 [FlexBuffers][Java] Fix wrong access to a string using Reference::asString(). (#5532)
cbdf82e2f Fix Mutate() methods of Array<scalar/struct> (override 5508) (#5526)
e365c502f Java: Added access object for vector of struct and vector of tables. (#5233)
97f3aa917 Fixed DetachedBuffer self move assignment (#5521)
2f5bb2eec Fix buildifier warnings found in new bazel (#5517)
917687c7a Fixed Reflection Verifier not handling vectors of unions.
f9277e691 Fixed GenerateText not handling vectors of unions.
2706381ee Add element size parameter to __vector_as_arraysegment [c#] (#5512)
b5560fcd5 [Java][FlexBuffers] Improve documentation for FlexBuffers in Java. (#5506)
782b865c5 Annotate getters with @Pure when --java-checkerframework is specified. (#5510)
3bfc86eaf [Dart]fix: segment fault with empty namespace when generating dart file (#5507)
c0282873f Rust: Fixed cargo clippy on non-generated code (#5485)
4b870aca9 [Javascript] Fix syntax error for signed enum (#5503)
d0e3870c0 [C#] Fix retrieving enumeration vectors as arrays (#5457)
fb25eb87f Doc typo fixes (#5505)
cb35d3a0e Use all of the available space in the buffer returned by ByteBufferFactory to allow the factory to keep a pool of larger than initialsize sized buffers. (#5500)
8e6cabb31 [FlexBuffers][Java] Implementation of FlexBuffers API (#5476)
bd31dd242 Clarified value reuse in FlexBuffers
65b67d213 Fixed test build invocation of arrays_test.fbs
1fbb71132 FlexBuffers: allow any values to be shared.
cd75a3658 Android: remove app_dummy() calls
ec6b0bf29 Fixed STLPort Android compile error
c11b5d744 [bugfix]flexbuffers isvector bugfix (#5488)
4525c91be Fix incorrect padding in arrays of structs (Issue #5484) (#5491)
b97b342f5 Fixed missing generated code.
c1058a903 C++ IDL generation adds superfluous semicolon in GenTablePost, causing (#5483)
303044934 [go]add Name() for ForceCodec interface (#5486)
a2485d4ec reflection: check for valid union enum value during object verification (#5475)
a20e71ac9 has_method support for primitive fields in java runtime. Changed: idl.h, FlatBufferBuilder.java , idl_gen_general.cpp, idl_parser.cpp, flatc.cpp (#5468)
Change-Id: I836f4b43e6818bb16425a87899e6234ac86242aa
git-subtree-dir: third_party/flatbuffers
git-subtree-split: d6a8dbd26ff08a8868e0d0c1b4b67d31b40e4a7f
diff --git a/tests/MyGame/Example/Ability.cs b/tests/MyGame/Example/Ability.cs
index 8315985..bd49ccd 100644
--- a/tests/MyGame/Example/Ability.cs
+++ b/tests/MyGame/Example/Ability.cs
@@ -6,6 +6,7 @@
{
using global::System;
+using global::System.Collections.Generic;
using global::FlatBuffers;
public struct Ability : IFlatbufferObject
@@ -26,7 +27,36 @@
builder.PutUint(Id);
return new Offset<MyGame.Example.Ability>(builder.Offset);
}
+ public AbilityT UnPack() {
+ var _o = new AbilityT();
+ this.UnPackTo(_o);
+ return _o;
+ }
+ public void UnPackTo(AbilityT _o) {
+ _o.Id = this.Id;
+ _o.Distance = this.Distance;
+ }
+ public static Offset<MyGame.Example.Ability> Pack(FlatBufferBuilder builder, AbilityT _o) {
+ if (_o == null) return default(Offset<MyGame.Example.Ability>);
+ return CreateAbility(
+ builder,
+ _o.Id,
+ _o.Distance);
+ }
};
+public class AbilityT
+{
+ [Newtonsoft.Json.JsonProperty("id")]
+ public uint Id { get; set; }
+ [Newtonsoft.Json.JsonProperty("distance")]
+ public uint Distance { get; set; }
+
+ public AbilityT() {
+ this.Id = 0;
+ this.Distance = 0;
+ }
+}
+
}
diff --git a/tests/MyGame/Example/Ability.go b/tests/MyGame/Example/Ability.go
index a56b445..9852a75 100644
--- a/tests/MyGame/Example/Ability.go
+++ b/tests/MyGame/Example/Ability.go
@@ -6,6 +6,27 @@
flatbuffers "github.com/google/flatbuffers/go"
)
+type AbilityT struct {
+ Id uint32
+ Distance uint32
+}
+
+func (t *AbilityT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil { return 0 }
+ return CreateAbility(builder, t.Id, t.Distance)
+}
+func (rcv *Ability) UnPackTo(t *AbilityT) {
+ t.Id = rcv.Id()
+ t.Distance = rcv.Distance()
+}
+
+func (rcv *Ability) UnPack() *AbilityT {
+ if rcv == nil { return nil }
+ t := &AbilityT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
type Ability struct {
_tab flatbuffers.Struct
}
diff --git a/tests/MyGame/Example/Ability.java b/tests/MyGame/Example/Ability.java
index 1a8ef03..df5fe71 100644
--- a/tests/MyGame/Example/Ability.java
+++ b/tests/MyGame/Example/Ability.java
@@ -23,5 +23,12 @@
builder.putInt((int)id);
return builder.offset();
}
+
+ public static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+ public Ability get(int j) { return get(new Ability(), j); }
+ public Ability get(Ability obj, int j) { return obj.__assign(__element(j), bb); }
+ }
}
diff --git a/tests/MyGame/Example/Ability.py b/tests/MyGame/Example/Ability.py
index 3c4776e..e57dfd7 100644
--- a/tests/MyGame/Example/Ability.py
+++ b/tests/MyGame/Example/Ability.py
@@ -3,10 +3,16 @@
# namespace: Example
import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
class Ability(object):
__slots__ = ['_tab']
+ @classmethod
+ def SizeOf(cls):
+ return 8
+
# Ability
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
@@ -21,3 +27,34 @@
builder.PrependUint32(distance)
builder.PrependUint32(id)
return builder.Offset()
+
+
+class AbilityT(object):
+
+ # AbilityT
+ def __init__(self):
+ self.id = 0 # type: int
+ self.distance = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ ability = Ability()
+ ability.Init(buf, pos)
+ return cls.InitFromObj(ability)
+
+ @classmethod
+ def InitFromObj(cls, ability):
+ x = AbilityT()
+ x._UnPack(ability)
+ return x
+
+ # AbilityT
+ def _UnPack(self, ability):
+ if ability is None:
+ return
+ self.id = ability.Id()
+ self.distance = ability.Distance()
+
+ # AbilityT
+ def Pack(self, builder):
+ return CreateAbility(builder, self.id, self.distance)
diff --git a/tests/MyGame/Example/Any.cs b/tests/MyGame/Example/Any.cs
index f95c6bc..edf98ef 100644
--- a/tests/MyGame/Example/Any.cs
+++ b/tests/MyGame/Example/Any.cs
@@ -5,6 +5,7 @@
namespace MyGame.Example
{
+[Newtonsoft.Json.JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
public enum Any : byte
{
NONE = 0,
@@ -13,5 +14,72 @@
MyGame_Example2_Monster = 3,
};
+public class AnyUnion {
+ public Any Type { get; set; }
+ public object Value { get; set; }
+
+ public AnyUnion() {
+ this.Type = Any.NONE;
+ this.Value = null;
+ }
+
+ public T As<T>() where T : class { return this.Value as T; }
+ public MyGame.Example.MonsterT AsMonster() { return this.As<MyGame.Example.MonsterT>(); }
+ internal MyGame.Example.TestSimpleTableWithEnumT AsTestSimpleTableWithEnum() { return this.As<MyGame.Example.TestSimpleTableWithEnumT>(); }
+ public MyGame.Example2.MonsterT AsMyGame_Example2_Monster() { return this.As<MyGame.Example2.MonsterT>(); }
+
+ public static int Pack(FlatBuffers.FlatBufferBuilder builder, AnyUnion _o) {
+ switch (_o.Type) {
+ default: return 0;
+ case Any.Monster: return MyGame.Example.Monster.Pack(builder, _o.AsMonster()).Value;
+ case Any.TestSimpleTableWithEnum: return MyGame.Example.TestSimpleTableWithEnum.Pack(builder, _o.AsTestSimpleTableWithEnum()).Value;
+ case Any.MyGame_Example2_Monster: return MyGame.Example2.Monster.Pack(builder, _o.AsMyGame_Example2_Monster()).Value;
+ }
+ }
+}
+
+public class AnyUnion_JsonConverter : Newtonsoft.Json.JsonConverter {
+ public override bool CanConvert(System.Type objectType) {
+ return objectType == typeof(AnyUnion) || objectType == typeof(System.Collections.Generic.List<AnyUnion>);
+ }
+ public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer) {
+ var _olist = value as System.Collections.Generic.List<AnyUnion>;
+ if (_olist != null) {
+ writer.WriteStartArray();
+ foreach (var _o in _olist) { this.WriteJson(writer, _o, serializer); }
+ writer.WriteEndArray();
+ } else {
+ this.WriteJson(writer, value as AnyUnion, serializer);
+ }
+ }
+ public void WriteJson(Newtonsoft.Json.JsonWriter writer, AnyUnion _o, Newtonsoft.Json.JsonSerializer serializer) {
+ if (_o == null) return;
+ serializer.Serialize(writer, _o.Value);
+ }
+ public override object ReadJson(Newtonsoft.Json.JsonReader reader, System.Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer) {
+ var _olist = existingValue as System.Collections.Generic.List<AnyUnion>;
+ if (_olist != null) {
+ for (var _j = 0; _j < _olist.Count; ++_j) {
+ reader.Read();
+ _olist[_j] = this.ReadJson(reader, _olist[_j], serializer);
+ }
+ reader.Read();
+ return _olist;
+ } else {
+ return this.ReadJson(reader, existingValue as AnyUnion, serializer);
+ }
+ }
+ public AnyUnion ReadJson(Newtonsoft.Json.JsonReader reader, AnyUnion _o, Newtonsoft.Json.JsonSerializer serializer) {
+ if (_o == null) return null;
+ switch (_o.Type) {
+ default: break;
+ case Any.Monster: _o.Value = serializer.Deserialize<MyGame.Example.MonsterT>(reader); break;
+ case Any.TestSimpleTableWithEnum: _o.Value = serializer.Deserialize<MyGame.Example.TestSimpleTableWithEnumT>(reader); break;
+ case Any.MyGame_Example2_Monster: _o.Value = serializer.Deserialize<MyGame.Example2.MonsterT>(reader); break;
+ }
+ return _o;
+ }
+}
+
}
diff --git a/tests/MyGame/Example/Any.go b/tests/MyGame/Example/Any.go
index 8d9067e..14b66b5 100644
--- a/tests/MyGame/Example/Any.go
+++ b/tests/MyGame/Example/Any.go
@@ -2,7 +2,13 @@
package Example
-import "strconv"
+import (
+ "strconv"
+
+ flatbuffers "github.com/google/flatbuffers/go"
+
+ MyGame__Example2 "MyGame/Example2"
+)
type Any byte
@@ -33,3 +39,38 @@
}
return "Any(" + strconv.FormatInt(int64(v), 10) + ")"
}
+
+type AnyT struct {
+ Type Any
+ Value interface{}
+}
+
+func (t *AnyT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ switch t.Type {
+ case AnyMonster:
+ return t.Value.(*MonsterT).Pack(builder)
+ case AnyTestSimpleTableWithEnum:
+ return t.Value.(*TestSimpleTableWithEnumT).Pack(builder)
+ case AnyMyGame_Example2_Monster:
+ return t.Value.(*MyGame__Example2.MonsterT).Pack(builder)
+ }
+ return 0
+}
+
+func (rcv Any) UnPack(table flatbuffers.Table) *AnyT {
+ switch rcv {
+ case AnyMonster:
+ x := Monster{_tab: table}
+ return &AnyT{ Type: AnyMonster, Value: x.UnPack() }
+ case AnyTestSimpleTableWithEnum:
+ x := TestSimpleTableWithEnum{_tab: table}
+ return &AnyT{ Type: AnyTestSimpleTableWithEnum, Value: x.UnPack() }
+ case AnyMyGame_Example2_Monster:
+ x := Monster{_tab: table}
+ return &AnyT{ Type: AnyMyGame_Example2_Monster, Value: x.UnPack() }
+ }
+ return nil
+}
diff --git a/tests/MyGame/Example/Any.py b/tests/MyGame/Example/Any.py
index f1b8d51..b10d35d 100644
--- a/tests/MyGame/Example/Any.py
+++ b/tests/MyGame/Example/Any.py
@@ -8,3 +8,18 @@
TestSimpleTableWithEnum = 2
MyGame_Example2_Monster = 3
+
+def AnyCreator(unionType, table):
+ from flatbuffers.table import Table
+ if not isinstance(table, Table):
+ return None
+ if unionType == Any().Monster:
+ import MyGame.Example.Monster
+ return MyGame.Example.Monster.MonsterT.InitFromBuf(table.Bytes, table.Pos)
+ if unionType == Any().TestSimpleTableWithEnum:
+ import MyGame.Example.TestSimpleTableWithEnum
+ return MyGame.Example.TestSimpleTableWithEnum.TestSimpleTableWithEnumT.InitFromBuf(table.Bytes, table.Pos)
+ if unionType == Any().MyGame_Example2_Monster:
+ import MyGame.Example2.Monster
+ return MyGame.Example2.Monster.MonsterT.InitFromBuf(table.Bytes, table.Pos)
+ return None
diff --git a/tests/MyGame/Example/AnyAmbiguousAliases.cs b/tests/MyGame/Example/AnyAmbiguousAliases.cs
index c727b88..07deadc 100644
--- a/tests/MyGame/Example/AnyAmbiguousAliases.cs
+++ b/tests/MyGame/Example/AnyAmbiguousAliases.cs
@@ -5,6 +5,7 @@
namespace MyGame.Example
{
+[Newtonsoft.Json.JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
public enum AnyAmbiguousAliases : byte
{
NONE = 0,
@@ -13,5 +14,72 @@
M3 = 3,
};
+public class AnyAmbiguousAliasesUnion {
+ public AnyAmbiguousAliases Type { get; set; }
+ public object Value { get; set; }
+
+ public AnyAmbiguousAliasesUnion() {
+ this.Type = AnyAmbiguousAliases.NONE;
+ this.Value = null;
+ }
+
+ public T As<T>() where T : class { return this.Value as T; }
+ public MyGame.Example.MonsterT AsM1() { return this.As<MyGame.Example.MonsterT>(); }
+ public MyGame.Example.MonsterT AsM2() { return this.As<MyGame.Example.MonsterT>(); }
+ public MyGame.Example.MonsterT AsM3() { return this.As<MyGame.Example.MonsterT>(); }
+
+ public static int Pack(FlatBuffers.FlatBufferBuilder builder, AnyAmbiguousAliasesUnion _o) {
+ switch (_o.Type) {
+ default: return 0;
+ case AnyAmbiguousAliases.M1: return MyGame.Example.Monster.Pack(builder, _o.AsM1()).Value;
+ case AnyAmbiguousAliases.M2: return MyGame.Example.Monster.Pack(builder, _o.AsM2()).Value;
+ case AnyAmbiguousAliases.M3: return MyGame.Example.Monster.Pack(builder, _o.AsM3()).Value;
+ }
+ }
+}
+
+public class AnyAmbiguousAliasesUnion_JsonConverter : Newtonsoft.Json.JsonConverter {
+ public override bool CanConvert(System.Type objectType) {
+ return objectType == typeof(AnyAmbiguousAliasesUnion) || objectType == typeof(System.Collections.Generic.List<AnyAmbiguousAliasesUnion>);
+ }
+ public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer) {
+ var _olist = value as System.Collections.Generic.List<AnyAmbiguousAliasesUnion>;
+ if (_olist != null) {
+ writer.WriteStartArray();
+ foreach (var _o in _olist) { this.WriteJson(writer, _o, serializer); }
+ writer.WriteEndArray();
+ } else {
+ this.WriteJson(writer, value as AnyAmbiguousAliasesUnion, serializer);
+ }
+ }
+ public void WriteJson(Newtonsoft.Json.JsonWriter writer, AnyAmbiguousAliasesUnion _o, Newtonsoft.Json.JsonSerializer serializer) {
+ if (_o == null) return;
+ serializer.Serialize(writer, _o.Value);
+ }
+ public override object ReadJson(Newtonsoft.Json.JsonReader reader, System.Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer) {
+ var _olist = existingValue as System.Collections.Generic.List<AnyAmbiguousAliasesUnion>;
+ if (_olist != null) {
+ for (var _j = 0; _j < _olist.Count; ++_j) {
+ reader.Read();
+ _olist[_j] = this.ReadJson(reader, _olist[_j], serializer);
+ }
+ reader.Read();
+ return _olist;
+ } else {
+ return this.ReadJson(reader, existingValue as AnyAmbiguousAliasesUnion, serializer);
+ }
+ }
+ public AnyAmbiguousAliasesUnion ReadJson(Newtonsoft.Json.JsonReader reader, AnyAmbiguousAliasesUnion _o, Newtonsoft.Json.JsonSerializer serializer) {
+ if (_o == null) return null;
+ switch (_o.Type) {
+ default: break;
+ case AnyAmbiguousAliases.M1: _o.Value = serializer.Deserialize<MyGame.Example.MonsterT>(reader); break;
+ case AnyAmbiguousAliases.M2: _o.Value = serializer.Deserialize<MyGame.Example.MonsterT>(reader); break;
+ case AnyAmbiguousAliases.M3: _o.Value = serializer.Deserialize<MyGame.Example.MonsterT>(reader); break;
+ }
+ return _o;
+ }
+}
+
}
diff --git a/tests/MyGame/Example/AnyAmbiguousAliases.go b/tests/MyGame/Example/AnyAmbiguousAliases.go
index b9c3793..8a088db 100644
--- a/tests/MyGame/Example/AnyAmbiguousAliases.go
+++ b/tests/MyGame/Example/AnyAmbiguousAliases.go
@@ -2,7 +2,11 @@
package Example
-import "strconv"
+import (
+ "strconv"
+
+ flatbuffers "github.com/google/flatbuffers/go"
+)
type AnyAmbiguousAliases byte
@@ -33,3 +37,38 @@
}
return "AnyAmbiguousAliases(" + strconv.FormatInt(int64(v), 10) + ")"
}
+
+type AnyAmbiguousAliasesT struct {
+ Type AnyAmbiguousAliases
+ Value interface{}
+}
+
+func (t *AnyAmbiguousAliasesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ switch t.Type {
+ case AnyAmbiguousAliasesM1:
+ return t.Value.(*MonsterT).Pack(builder)
+ case AnyAmbiguousAliasesM2:
+ return t.Value.(*MonsterT).Pack(builder)
+ case AnyAmbiguousAliasesM3:
+ return t.Value.(*MonsterT).Pack(builder)
+ }
+ return 0
+}
+
+func (rcv AnyAmbiguousAliases) UnPack(table flatbuffers.Table) *AnyAmbiguousAliasesT {
+ switch rcv {
+ case AnyAmbiguousAliasesM1:
+ x := Monster{_tab: table}
+ return &AnyAmbiguousAliasesT{ Type: AnyAmbiguousAliasesM1, Value: x.UnPack() }
+ case AnyAmbiguousAliasesM2:
+ x := Monster{_tab: table}
+ return &AnyAmbiguousAliasesT{ Type: AnyAmbiguousAliasesM2, Value: x.UnPack() }
+ case AnyAmbiguousAliasesM3:
+ x := Monster{_tab: table}
+ return &AnyAmbiguousAliasesT{ Type: AnyAmbiguousAliasesM3, Value: x.UnPack() }
+ }
+ return nil
+}
diff --git a/tests/MyGame/Example/AnyAmbiguousAliases.py b/tests/MyGame/Example/AnyAmbiguousAliases.py
index de6e9d0..3fb4830 100644
--- a/tests/MyGame/Example/AnyAmbiguousAliases.py
+++ b/tests/MyGame/Example/AnyAmbiguousAliases.py
@@ -8,3 +8,18 @@
M2 = 2
M3 = 3
+
+def AnyAmbiguousAliasesCreator(unionType, table):
+ from flatbuffers.table import Table
+ if not isinstance(table, Table):
+ return None
+ if unionType == AnyAmbiguousAliases().M1:
+ import MyGame.Example.Monster
+ return MyGame.Example.Monster.MonsterT.InitFromBuf(table.Bytes, table.Pos)
+ if unionType == AnyAmbiguousAliases().M2:
+ import MyGame.Example.Monster
+ return MyGame.Example.Monster.MonsterT.InitFromBuf(table.Bytes, table.Pos)
+ if unionType == AnyAmbiguousAliases().M3:
+ import MyGame.Example.Monster
+ return MyGame.Example.Monster.MonsterT.InitFromBuf(table.Bytes, table.Pos)
+ return None
diff --git a/tests/MyGame/Example/AnyUniqueAliases.cs b/tests/MyGame/Example/AnyUniqueAliases.cs
index 42a3e0b..3594952 100644
--- a/tests/MyGame/Example/AnyUniqueAliases.cs
+++ b/tests/MyGame/Example/AnyUniqueAliases.cs
@@ -5,6 +5,7 @@
namespace MyGame.Example
{
+[Newtonsoft.Json.JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
public enum AnyUniqueAliases : byte
{
NONE = 0,
@@ -13,5 +14,72 @@
M2 = 3,
};
+public class AnyUniqueAliasesUnion {
+ public AnyUniqueAliases Type { get; set; }
+ public object Value { get; set; }
+
+ public AnyUniqueAliasesUnion() {
+ this.Type = AnyUniqueAliases.NONE;
+ this.Value = null;
+ }
+
+ public T As<T>() where T : class { return this.Value as T; }
+ public MyGame.Example.MonsterT AsM() { return this.As<MyGame.Example.MonsterT>(); }
+ internal MyGame.Example.TestSimpleTableWithEnumT AsTS() { return this.As<MyGame.Example.TestSimpleTableWithEnumT>(); }
+ public MyGame.Example2.MonsterT AsM2() { return this.As<MyGame.Example2.MonsterT>(); }
+
+ public static int Pack(FlatBuffers.FlatBufferBuilder builder, AnyUniqueAliasesUnion _o) {
+ switch (_o.Type) {
+ default: return 0;
+ case AnyUniqueAliases.M: return MyGame.Example.Monster.Pack(builder, _o.AsM()).Value;
+ case AnyUniqueAliases.TS: return MyGame.Example.TestSimpleTableWithEnum.Pack(builder, _o.AsTS()).Value;
+ case AnyUniqueAliases.M2: return MyGame.Example2.Monster.Pack(builder, _o.AsM2()).Value;
+ }
+ }
+}
+
+public class AnyUniqueAliasesUnion_JsonConverter : Newtonsoft.Json.JsonConverter {
+ public override bool CanConvert(System.Type objectType) {
+ return objectType == typeof(AnyUniqueAliasesUnion) || objectType == typeof(System.Collections.Generic.List<AnyUniqueAliasesUnion>);
+ }
+ public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer) {
+ var _olist = value as System.Collections.Generic.List<AnyUniqueAliasesUnion>;
+ if (_olist != null) {
+ writer.WriteStartArray();
+ foreach (var _o in _olist) { this.WriteJson(writer, _o, serializer); }
+ writer.WriteEndArray();
+ } else {
+ this.WriteJson(writer, value as AnyUniqueAliasesUnion, serializer);
+ }
+ }
+ public void WriteJson(Newtonsoft.Json.JsonWriter writer, AnyUniqueAliasesUnion _o, Newtonsoft.Json.JsonSerializer serializer) {
+ if (_o == null) return;
+ serializer.Serialize(writer, _o.Value);
+ }
+ public override object ReadJson(Newtonsoft.Json.JsonReader reader, System.Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer) {
+ var _olist = existingValue as System.Collections.Generic.List<AnyUniqueAliasesUnion>;
+ if (_olist != null) {
+ for (var _j = 0; _j < _olist.Count; ++_j) {
+ reader.Read();
+ _olist[_j] = this.ReadJson(reader, _olist[_j], serializer);
+ }
+ reader.Read();
+ return _olist;
+ } else {
+ return this.ReadJson(reader, existingValue as AnyUniqueAliasesUnion, serializer);
+ }
+ }
+ public AnyUniqueAliasesUnion ReadJson(Newtonsoft.Json.JsonReader reader, AnyUniqueAliasesUnion _o, Newtonsoft.Json.JsonSerializer serializer) {
+ if (_o == null) return null;
+ switch (_o.Type) {
+ default: break;
+ case AnyUniqueAliases.M: _o.Value = serializer.Deserialize<MyGame.Example.MonsterT>(reader); break;
+ case AnyUniqueAliases.TS: _o.Value = serializer.Deserialize<MyGame.Example.TestSimpleTableWithEnumT>(reader); break;
+ case AnyUniqueAliases.M2: _o.Value = serializer.Deserialize<MyGame.Example2.MonsterT>(reader); break;
+ }
+ return _o;
+ }
+}
+
}
diff --git a/tests/MyGame/Example/AnyUniqueAliases.go b/tests/MyGame/Example/AnyUniqueAliases.go
index 23d8649..2a52ebe 100644
--- a/tests/MyGame/Example/AnyUniqueAliases.go
+++ b/tests/MyGame/Example/AnyUniqueAliases.go
@@ -2,7 +2,13 @@
package Example
-import "strconv"
+import (
+ "strconv"
+
+ flatbuffers "github.com/google/flatbuffers/go"
+
+ MyGame__Example2 "MyGame/Example2"
+)
type AnyUniqueAliases byte
@@ -33,3 +39,38 @@
}
return "AnyUniqueAliases(" + strconv.FormatInt(int64(v), 10) + ")"
}
+
+type AnyUniqueAliasesT struct {
+ Type AnyUniqueAliases
+ Value interface{}
+}
+
+func (t *AnyUniqueAliasesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ switch t.Type {
+ case AnyUniqueAliasesM:
+ return t.Value.(*MonsterT).Pack(builder)
+ case AnyUniqueAliasesTS:
+ return t.Value.(*TestSimpleTableWithEnumT).Pack(builder)
+ case AnyUniqueAliasesM2:
+ return t.Value.(*MyGame__Example2.MonsterT).Pack(builder)
+ }
+ return 0
+}
+
+func (rcv AnyUniqueAliases) UnPack(table flatbuffers.Table) *AnyUniqueAliasesT {
+ switch rcv {
+ case AnyUniqueAliasesM:
+ x := Monster{_tab: table}
+ return &AnyUniqueAliasesT{ Type: AnyUniqueAliasesM, Value: x.UnPack() }
+ case AnyUniqueAliasesTS:
+ x := TestSimpleTableWithEnum{_tab: table}
+ return &AnyUniqueAliasesT{ Type: AnyUniqueAliasesTS, Value: x.UnPack() }
+ case AnyUniqueAliasesM2:
+ x := Monster{_tab: table}
+ return &AnyUniqueAliasesT{ Type: AnyUniqueAliasesM2, Value: x.UnPack() }
+ }
+ return nil
+}
diff --git a/tests/MyGame/Example/AnyUniqueAliases.py b/tests/MyGame/Example/AnyUniqueAliases.py
index a6da355..cf89fc2 100644
--- a/tests/MyGame/Example/AnyUniqueAliases.py
+++ b/tests/MyGame/Example/AnyUniqueAliases.py
@@ -8,3 +8,18 @@
TS = 2
M2 = 3
+
+def AnyUniqueAliasesCreator(unionType, table):
+ from flatbuffers.table import Table
+ if not isinstance(table, Table):
+ return None
+ if unionType == AnyUniqueAliases().M:
+ import MyGame.Example.Monster
+ return MyGame.Example.Monster.MonsterT.InitFromBuf(table.Bytes, table.Pos)
+ if unionType == AnyUniqueAliases().TS:
+ import MyGame.Example.TestSimpleTableWithEnum
+ return MyGame.Example.TestSimpleTableWithEnum.TestSimpleTableWithEnumT.InitFromBuf(table.Bytes, table.Pos)
+ if unionType == AnyUniqueAliases().M2:
+ import MyGame.Example2.Monster
+ return MyGame.Example2.Monster.MonsterT.InitFromBuf(table.Bytes, table.Pos)
+ return None
diff --git a/tests/MyGame/Example/ArrayStruct.cs b/tests/MyGame/Example/ArrayStruct.cs
index 28815e7..41c088d 100644
--- a/tests/MyGame/Example/ArrayStruct.cs
+++ b/tests/MyGame/Example/ArrayStruct.cs
@@ -6,6 +6,7 @@
{
using global::System;
+using global::System.Collections.Generic;
using global::FlatBuffers;
public struct ArrayStruct : IFlatbufferObject
@@ -21,13 +22,25 @@
public void MutateB(int j, int b) { __p.bb.PutInt(__p.bb_pos + 4 + j * 4, b); }
public sbyte C { get { return __p.bb.GetSbyte(__p.bb_pos + 64); } }
public void MutateC(sbyte c) { __p.bb.PutSbyte(__p.bb_pos + 64, c); }
- public MyGame.Example.NestedStruct D(int j) { return (new MyGame.Example.NestedStruct()).__assign(__p.bb_pos + 68 + j * 12, __p.bb); }
+ public MyGame.Example.NestedStruct D(int j) { return (new MyGame.Example.NestedStruct()).__assign(__p.bb_pos + 72 + j * 32, __p.bb); }
+ public int E { get { return __p.bb.GetInt(__p.bb_pos + 136); } }
+ public void MutateE(int e) { __p.bb.PutInt(__p.bb_pos + 136, e); }
+ public long F(int j) { return __p.bb.GetLong(__p.bb_pos + 144 + j * 8); }
+ public void MutateF(int j, long f) { __p.bb.PutLong(__p.bb_pos + 144 + j * 8, f); }
- public static Offset<MyGame.Example.ArrayStruct> CreateArrayStruct(FlatBufferBuilder builder, float A, int[] B, sbyte C, int[,] d_A, MyGame.Example.TestEnum[] d_B, MyGame.Example.TestEnum[,] d_C) {
- builder.Prep(4, 92);
+ public static Offset<MyGame.Example.ArrayStruct> CreateArrayStruct(FlatBufferBuilder builder, float A, int[] B, sbyte C, int[,] d_A, MyGame.Example.TestEnum[] d_B, MyGame.Example.TestEnum[,] d_C, long[,] d_D, int E, long[] F) {
+ builder.Prep(8, 160);
for (int _idx0 = 2; _idx0 > 0; _idx0--) {
- builder.Prep(4, 12);
- builder.Pad(1);
+ builder.PutLong(F[_idx0-1]);
+ }
+ builder.Pad(4);
+ builder.PutInt(E);
+ for (int _idx0 = 2; _idx0 > 0; _idx0--) {
+ builder.Prep(8, 32);
+ for (int _idx1 = 2; _idx1 > 0; _idx1--) {
+ builder.PutLong(d_D[_idx0-1,_idx1-1]);
+ }
+ builder.Pad(5);
for (int _idx1 = 2; _idx1 > 0; _idx1--) {
builder.PutSbyte((sbyte)d_C[_idx0-1,_idx1-1]);
}
@@ -36,7 +49,7 @@
builder.PutInt(d_A[_idx0-1,_idx1-1]);
}
}
- builder.Pad(3);
+ builder.Pad(7);
builder.PutSbyte(C);
for (int _idx0 = 15; _idx0 > 0; _idx0--) {
builder.PutInt(B[_idx0-1]);
@@ -44,7 +57,72 @@
builder.PutFloat(A);
return new Offset<MyGame.Example.ArrayStruct>(builder.Offset);
}
+ public ArrayStructT UnPack() {
+ var _o = new ArrayStructT();
+ this.UnPackTo(_o);
+ return _o;
+ }
+ public void UnPackTo(ArrayStructT _o) {
+ _o.A = this.A;
+ _o.B = new int[15];
+ for (var _j = 0; _j < 15; ++_j) { _o.B[_j] = this.B(_j); }
+ _o.C = this.C;
+ _o.D = new MyGame.Example.NestedStructT[2];
+ for (var _j = 0; _j < 2; ++_j) { _o.D[_j] = this.D(_j).UnPack(); }
+ _o.E = this.E;
+ _o.F = new long[2];
+ for (var _j = 0; _j < 2; ++_j) { _o.F[_j] = this.F(_j); }
+ }
+ public static Offset<MyGame.Example.ArrayStruct> Pack(FlatBufferBuilder builder, ArrayStructT _o) {
+ if (_o == null) return default(Offset<MyGame.Example.ArrayStruct>);
+ var _b = _o.B;
+ var _d_a = new int[2,2];
+ for (var idx0 = 0; idx0 < 2; ++idx0) {for (var idx1 = 0; idx1 < 2; ++idx1) {_d_a[idx0,idx1] = _o.D[idx0].A[idx1];}}
+ var _d_b = new MyGame.Example.TestEnum[2];
+ for (var idx0 = 0; idx0 < 2; ++idx0) {_d_b[idx0] = _o.D[idx0].B;}
+ var _d_c = new MyGame.Example.TestEnum[2,2];
+ for (var idx0 = 0; idx0 < 2; ++idx0) {for (var idx1 = 0; idx1 < 2; ++idx1) {_d_c[idx0,idx1] = _o.D[idx0].C[idx1];}}
+ var _d_d = new long[2,2];
+ for (var idx0 = 0; idx0 < 2; ++idx0) {for (var idx1 = 0; idx1 < 2; ++idx1) {_d_d[idx0,idx1] = _o.D[idx0].D[idx1];}}
+ var _f = _o.F;
+ return CreateArrayStruct(
+ builder,
+ _o.A,
+ _b,
+ _o.C,
+ _d_a,
+ _d_b,
+ _d_c,
+ _d_d,
+ _o.E,
+ _f);
+ }
};
+public class ArrayStructT
+{
+ [Newtonsoft.Json.JsonProperty("a")]
+ public float A { get; set; }
+ [Newtonsoft.Json.JsonProperty("b")]
+ public int[] B { get; set; }
+ [Newtonsoft.Json.JsonProperty("c")]
+ public sbyte C { get; set; }
+ [Newtonsoft.Json.JsonProperty("d")]
+ public MyGame.Example.NestedStructT[] D { get; set; }
+ [Newtonsoft.Json.JsonProperty("e")]
+ public int E { get; set; }
+ [Newtonsoft.Json.JsonProperty("f")]
+ public long[] F { get; set; }
+
+ public ArrayStructT() {
+ this.A = 0.0f;
+ this.B = new int[15];
+ this.C = 0;
+ this.D = new MyGame.Example.NestedStructT[2];
+ this.E = 0;
+ this.F = new long[2];
+ }
+}
+
}
diff --git a/tests/MyGame/Example/ArrayStruct.java b/tests/MyGame/Example/ArrayStruct.java
index 0098c55..5c5b3f6 100644
--- a/tests/MyGame/Example/ArrayStruct.java
+++ b/tests/MyGame/Example/ArrayStruct.java
@@ -18,13 +18,25 @@
public void mutateB(int j, int b) { bb.putInt(bb_pos + 4 + j * 4, b); }
public byte c() { return bb.get(bb_pos + 64); }
public void mutateC(byte c) { bb.put(bb_pos + 64, c); }
- public MyGame.Example.NestedStruct d(MyGame.Example.NestedStruct obj, int j) { return obj.__assign(bb_pos + 68 + j * 12, bb); }
+ public MyGame.Example.NestedStruct d(MyGame.Example.NestedStruct obj, int j) { return obj.__assign(bb_pos + 72 + j * 32, bb); }
+ public int e() { return bb.getInt(bb_pos + 136); }
+ public void mutateE(int e) { bb.putInt(bb_pos + 136, e); }
+ public long f(int j) { return bb.getLong(bb_pos + 144 + j * 8); }
+ public void mutateF(int j, long f) { bb.putLong(bb_pos + 144 + j * 8, f); }
- public static int createArrayStruct(FlatBufferBuilder builder, float a, int[] b, byte c, int[][] d_a, byte[] d_b, byte[][] d_c) {
- builder.prep(4, 92);
+ public static int createArrayStruct(FlatBufferBuilder builder, float a, int[] b, byte c, int[][] d_a, byte[] d_b, byte[][] d_c, long[][] d_d, int e, long[] f) {
+ builder.prep(8, 160);
for (int _idx0 = 2; _idx0 > 0; _idx0--) {
- builder.prep(4, 12);
- builder.pad(1);
+ builder.putLong(f[_idx0-1]);
+ }
+ builder.pad(4);
+ builder.putInt(e);
+ for (int _idx0 = 2; _idx0 > 0; _idx0--) {
+ builder.prep(8, 32);
+ for (int _idx1 = 2; _idx1 > 0; _idx1--) {
+ builder.putLong(d_d[_idx0-1][_idx1-1]);
+ }
+ builder.pad(5);
for (int _idx1 = 2; _idx1 > 0; _idx1--) {
builder.putByte(d_c[_idx0-1][_idx1-1]);
}
@@ -33,7 +45,7 @@
builder.putInt(d_a[_idx0-1][_idx1-1]);
}
}
- builder.pad(3);
+ builder.pad(7);
builder.putByte(c);
for (int _idx0 = 15; _idx0 > 0; _idx0--) {
builder.putInt(b[_idx0-1]);
@@ -41,5 +53,12 @@
builder.putFloat(a);
return builder.offset();
}
+
+ public static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+ public ArrayStruct get(int j) { return get(new ArrayStruct(), j); }
+ public ArrayStruct get(ArrayStruct obj, int j) { return obj.__assign(__element(j), bb); }
+ }
}
diff --git a/tests/MyGame/Example/ArrayStruct.py b/tests/MyGame/Example/ArrayStruct.py
index 79dda31..c80bf68 100644
--- a/tests/MyGame/Example/ArrayStruct.py
+++ b/tests/MyGame/Example/ArrayStruct.py
@@ -3,10 +3,16 @@
# namespace: Example
import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
class ArrayStruct(object):
__slots__ = ['_tab']
+ @classmethod
+ def SizeOf(cls):
+ return 160
+
# ArrayStruct
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
@@ -16,26 +22,131 @@
# ArrayStruct
def B(self): return [self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4 + i * 4)) for i in range(15)]
# ArrayStruct
+ def BLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # ArrayStruct
+ def BIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ return o == 0
+
+ # ArrayStruct
def C(self): return self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(64))
# ArrayStruct
def D(self, obj, i):
- obj.Init(self._tab.Bytes, self._tab.Pos + 68 + i * 12)
+ obj.Init(self._tab.Bytes, self._tab.Pos + 72 + i * 32)
return obj
+ # ArrayStruct
+ def DLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
-def CreateArrayStruct(builder, a, b, c, d_a, d_b, d_c):
- builder.Prep(4, 92)
+ # ArrayStruct
+ def DIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
+ return o == 0
+
+ # ArrayStruct
+ def E(self): return self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(136))
+ # ArrayStruct
+ def F(self): return [self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(144 + i * 8)) for i in range(2)]
+ # ArrayStruct
+ def FLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(144))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # ArrayStruct
+ def FIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(144))
+ return o == 0
+
+
+def CreateArrayStruct(builder, a, b, c, d_a, d_b, d_c, d_d, e, f):
+ builder.Prep(8, 160)
for _idx0 in range(2 , 0, -1):
- builder.Prep(4, 12)
- builder.Pad(1)
+ builder.PrependInt64(f[_idx0-1])
+ builder.Pad(4)
+ builder.PrependInt32(e)
+ for _idx0 in range(2 , 0, -1):
+ builder.Prep(8, 32)
+ for _idx1 in range(2 , 0, -1):
+ builder.PrependInt64(d_d[_idx0-1][_idx1-1])
+ builder.Pad(5)
for _idx1 in range(2 , 0, -1):
builder.PrependInt8(d_c[_idx0-1][_idx1-1])
builder.PrependInt8(d_b[_idx0-1])
for _idx1 in range(2 , 0, -1):
builder.PrependInt32(d_a[_idx0-1][_idx1-1])
- builder.Pad(3)
+ builder.Pad(7)
builder.PrependInt8(c)
for _idx0 in range(15 , 0, -1):
builder.PrependInt32(b[_idx0-1])
builder.PrependFloat32(a)
return builder.Offset()
+
+import MyGame.Example.NestedStruct
+try:
+ from typing import List
+except:
+ pass
+
+class ArrayStructT(object):
+
+ # ArrayStructT
+ def __init__(self):
+ self.a = 0.0 # type: float
+ self.b = None # type: List[int]
+ self.c = 0 # type: int
+ self.d = None # type: List[MyGame.Example.NestedStruct.NestedStructT]
+ self.e = 0 # type: int
+ self.f = None # type: List[int]
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ arrayStruct = ArrayStruct()
+ arrayStruct.Init(buf, pos)
+ return cls.InitFromObj(arrayStruct)
+
+ @classmethod
+ def InitFromObj(cls, arrayStruct):
+ x = ArrayStructT()
+ x._UnPack(arrayStruct)
+ return x
+
+ # ArrayStructT
+ def _UnPack(self, arrayStruct):
+ if arrayStruct is None:
+ return
+ self.a = arrayStruct.A()
+ if not arrayStruct.BIsNone():
+ if np is None:
+ self.b = []
+ for i in range(arrayStruct.BLength()):
+ self.b.append(arrayStruct.B(i))
+ else:
+ self.b = arrayStruct.BAsNumpy()
+ self.c = arrayStruct.C()
+ if not arrayStruct.DIsNone():
+ self.d = []
+ for i in range(arrayStruct.DLength()):
+ self.d.append(arrayStruct.D(i))
+ self.e = arrayStruct.E()
+ if not arrayStruct.FIsNone():
+ if np is None:
+ self.f = []
+ for i in range(arrayStruct.FLength()):
+ self.f.append(arrayStruct.F(i))
+ else:
+ self.f = arrayStruct.FAsNumpy()
+
+ # ArrayStructT
+ def Pack(self, builder):
+ return CreateArrayStruct(builder, self.a, self.b, self.c, self.d.a, self.d.b, self.d.c, self.d.d, self.e, self.f)
diff --git a/tests/MyGame/Example/ArrayTable.cs b/tests/MyGame/Example/ArrayTable.cs
index e303211..b5b599f 100644
--- a/tests/MyGame/Example/ArrayTable.cs
+++ b/tests/MyGame/Example/ArrayTable.cs
@@ -6,13 +6,14 @@
{
using global::System;
+using global::System.Collections.Generic;
using global::FlatBuffers;
public struct ArrayTable : IFlatbufferObject
{
private Table __p;
public ByteBuffer ByteBuffer { get { return __p.bb; } }
- public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_11_1(); }
+ public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_12_0(); }
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"); }
@@ -29,7 +30,46 @@
}
public static void FinishArrayTableBuffer(FlatBufferBuilder builder, Offset<MyGame.Example.ArrayTable> offset) { builder.Finish(offset.Value, "ARRT"); }
public static void FinishSizePrefixedArrayTableBuffer(FlatBufferBuilder builder, Offset<MyGame.Example.ArrayTable> offset) { builder.FinishSizePrefixed(offset.Value, "ARRT"); }
+ public ArrayTableT UnPack() {
+ var _o = new ArrayTableT();
+ this.UnPackTo(_o);
+ return _o;
+ }
+ public void UnPackTo(ArrayTableT _o) {
+ _o.A = this.A.HasValue ? this.A.Value.UnPack() : null;
+ }
+ public static Offset<MyGame.Example.ArrayTable> Pack(FlatBufferBuilder builder, ArrayTableT _o) {
+ if (_o == null) return default(Offset<MyGame.Example.ArrayTable>);
+ StartArrayTable(builder);
+ AddA(builder, MyGame.Example.ArrayStruct.Pack(builder, _o.A));
+ return EndArrayTable(builder);
+ }
};
+public class ArrayTableT
+{
+ [Newtonsoft.Json.JsonProperty("a")]
+ public MyGame.Example.ArrayStructT A { get; set; }
+
+ public ArrayTableT() {
+ this.A = new MyGame.Example.ArrayStructT();
+ }
+
+ public static ArrayTableT DeserializeFromJson(string jsonText) {
+ return Newtonsoft.Json.JsonConvert.DeserializeObject<ArrayTableT>(jsonText);
+ }
+ public string SerializeToJson() {
+ return Newtonsoft.Json.JsonConvert.SerializeObject(this, Newtonsoft.Json.Formatting.Indented);
+ }
+ public static ArrayTableT DeserializeFromBinary(byte[] fbBuffer) {
+ return ArrayTable.GetRootAsArrayTable(new ByteBuffer(fbBuffer)).UnPack();
+ }
+ public byte[] SerializeToBinary() {
+ var fbb = new FlatBufferBuilder(0x10000);
+ ArrayTable.FinishArrayTableBuffer(fbb, ArrayTable.Pack(fbb, this));
+ return fbb.DataBuffer.ToSizedArray();
+ }
+}
+
}
diff --git a/tests/MyGame/Example/ArrayTable.java b/tests/MyGame/Example/ArrayTable.java
index 74ce86a..41730d3 100644
--- a/tests/MyGame/Example/ArrayTable.java
+++ b/tests/MyGame/Example/ArrayTable.java
@@ -9,7 +9,7 @@
@SuppressWarnings("unused")
public final class ArrayTable extends Table {
- public static void ValidateVersion() { Constants.FLATBUFFERS_1_11_1(); }
+ public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
public static ArrayTable getRootAsArrayTable(ByteBuffer _bb) { return getRootAsArrayTable(_bb, new ArrayTable()); }
public static ArrayTable getRootAsArrayTable(ByteBuffer _bb, ArrayTable obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
public static boolean ArrayTableBufferHasIdentifier(ByteBuffer _bb) { return __has_identifier(_bb, "ARRT"); }
@@ -27,5 +27,12 @@
}
public static void finishArrayTableBuffer(FlatBufferBuilder builder, int offset) { builder.finish(offset, "ARRT"); }
public static void finishSizePrefixedArrayTableBuffer(FlatBufferBuilder builder, int offset) { builder.finishSizePrefixed(offset, "ARRT"); }
+
+ public static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+ public ArrayTable get(int j) { return get(new ArrayTable(), j); }
+ public ArrayTable get(ArrayTable obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); }
+ }
}
diff --git a/tests/MyGame/Example/ArrayTable.py b/tests/MyGame/Example/ArrayTable.py
index 6d583f9..83905e6 100644
--- a/tests/MyGame/Example/ArrayTable.py
+++ b/tests/MyGame/Example/ArrayTable.py
@@ -3,6 +3,8 @@
# namespace: Example
import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
class ArrayTable(object):
__slots__ = ['_tab']
@@ -27,7 +29,7 @@
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
x = o + self._tab.Pos
- from .ArrayStruct import ArrayStruct
+ from MyGame.Example.ArrayStruct import ArrayStruct
obj = ArrayStruct()
obj.Init(self._tab.Bytes, x)
return obj
@@ -36,3 +38,43 @@
def ArrayTableStart(builder): builder.StartObject(1)
def ArrayTableAddA(builder, a): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0)
def ArrayTableEnd(builder): return builder.EndObject()
+
+import MyGame.Example.ArrayStruct
+try:
+ from typing import Optional
+except:
+ pass
+
+class ArrayTableT(object):
+
+ # ArrayTableT
+ def __init__(self):
+ self.a = None # type: Optional[MyGame.Example.ArrayStruct.ArrayStructT]
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ arrayTable = ArrayTable()
+ arrayTable.Init(buf, pos)
+ return cls.InitFromObj(arrayTable)
+
+ @classmethod
+ def InitFromObj(cls, arrayTable):
+ x = ArrayTableT()
+ x._UnPack(arrayTable)
+ return x
+
+ # ArrayTableT
+ def _UnPack(self, arrayTable):
+ if arrayTable is None:
+ return
+ if arrayTable.A() is not None:
+ self.a = MyGame.Example.ArrayStruct.ArrayStructT.InitFromObj(arrayTable.A())
+
+ # ArrayTableT
+ def Pack(self, builder):
+ ArrayTableStart(builder)
+ if self.a is not None:
+ a = self.a.Pack(builder)
+ ArrayTableAddA(builder, a)
+ arrayTable = ArrayTableEnd(builder)
+ return arrayTable
diff --git a/tests/MyGame/Example/Color.cs b/tests/MyGame/Example/Color.cs
index 5981cf8..1137a27 100644
--- a/tests/MyGame/Example/Color.cs
+++ b/tests/MyGame/Example/Color.cs
@@ -6,6 +6,7 @@
{
/// Composite components of Monster color.
+[Newtonsoft.Json.JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
[System.FlagsAttribute]
public enum Color : byte
{
diff --git a/tests/MyGame/Example/Monster.cs b/tests/MyGame/Example/Monster.cs
index 5dc669e..acfb394 100644
--- a/tests/MyGame/Example/Monster.cs
+++ b/tests/MyGame/Example/Monster.cs
@@ -6,14 +6,15 @@
{
using global::System;
+using global::System.Collections.Generic;
using global::FlatBuffers;
-/// an example documentation comment: monster object
+/// an example documentation comment: "monster object"
public struct Monster : IFlatbufferObject
{
private Table __p;
public ByteBuffer ByteBuffer { get { return __p.bb; } }
- public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_11_1(); }
+ public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_12_0(); }
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"); }
@@ -27,7 +28,7 @@
public bool MutateHp(short hp) { int o = __p.__offset(8); if (o != 0) { __p.bb.PutShort(o + __p.bb_pos, hp); return true; } else { return false; } }
public string Name { get { int o = __p.__offset(10); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
#if ENABLE_SPAN_T
- public Span<byte> GetNameBytes() { return __p.__vector_as_span(10); }
+ public Span<byte> GetNameBytes() { return __p.__vector_as_span<byte>(10, 1); }
#else
public ArraySegment<byte>? GetNameBytes() { return __p.__vector_as_arraysegment(10); }
#endif
@@ -35,7 +36,7 @@
public byte Inventory(int j) { int o = __p.__offset(14); return o != 0 ? __p.bb.Get(__p.__vector(o) + j * 1) : (byte)0; }
public int InventoryLength { get { int o = __p.__offset(14); return o != 0 ? __p.__vector_len(o) : 0; } }
#if ENABLE_SPAN_T
- public Span<byte> GetInventoryBytes() { return __p.__vector_as_span(14); }
+ public Span<byte> GetInventoryBytes() { return __p.__vector_as_span<byte>(14, 1); }
#else
public ArraySegment<byte>? GetInventoryBytes() { return __p.__vector_as_arraysegment(14); }
#endif
@@ -44,8 +45,10 @@
public MyGame.Example.Color Color { get { int o = __p.__offset(16); return o != 0 ? (MyGame.Example.Color)__p.bb.Get(o + __p.bb_pos) : MyGame.Example.Color.Blue; } }
public bool MutateColor(MyGame.Example.Color color) { int o = __p.__offset(16); if (o != 0) { __p.bb.Put(o + __p.bb_pos, (byte)color); return true; } else { return false; } }
public MyGame.Example.Any TestType { get { int o = __p.__offset(18); return o != 0 ? (MyGame.Example.Any)__p.bb.Get(o + __p.bb_pos) : MyGame.Example.Any.NONE; } }
- public bool MutateTestType(MyGame.Example.Any test_type) { int o = __p.__offset(18); if (o != 0) { __p.bb.Put(o + __p.bb_pos, (byte)test_type); return true; } else { return false; } }
- public TTable? Test<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(20); return o != 0 ? (TTable?)__p.__union<TTable>(o) : null; }
+ public TTable? Test<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(20); return o != 0 ? (TTable?)__p.__union<TTable>(o + __p.bb_pos) : null; }
+ public MyGame.Example.Monster TestAsMonster() { return Test<MyGame.Example.Monster>().Value; }
+ internal MyGame.Example.TestSimpleTableWithEnum TestAsTestSimpleTableWithEnum() { return Test<MyGame.Example.TestSimpleTableWithEnum>().Value; }
+ public MyGame.Example2.Monster TestAsMyGame_Example2_Monster() { return Test<MyGame.Example2.Monster>().Value; }
public MyGame.Example.Test? Test4(int j) { int o = __p.__offset(22); return o != 0 ? (MyGame.Example.Test?)(new MyGame.Example.Test()).__assign(__p.__vector(o) + j * 4, __p.bb) : null; }
public int Test4Length { get { int o = __p.__offset(22); return o != 0 ? __p.__vector_len(o) : 0; } }
public string Testarrayofstring(int j) { int o = __p.__offset(24); return o != 0 ? __p.__string(__p.__vector(o) + j * 4) : null; }
@@ -59,7 +62,7 @@
public byte Testnestedflatbuffer(int j) { int o = __p.__offset(30); return o != 0 ? __p.bb.Get(__p.__vector(o) + j * 1) : (byte)0; }
public int TestnestedflatbufferLength { get { int o = __p.__offset(30); return o != 0 ? __p.__vector_len(o) : 0; } }
#if ENABLE_SPAN_T
- public Span<byte> GetTestnestedflatbufferBytes() { return __p.__vector_as_span(30); }
+ public Span<byte> GetTestnestedflatbufferBytes() { return __p.__vector_as_span<byte>(30, 1); }
#else
public ArraySegment<byte>? GetTestnestedflatbufferBytes() { return __p.__vector_as_arraysegment(30); }
#endif
@@ -88,7 +91,7 @@
public bool Testarrayofbools(int j) { int o = __p.__offset(52); return o != 0 ? 0!=__p.bb.Get(__p.__vector(o) + j * 1) : false; }
public int TestarrayofboolsLength { get { int o = __p.__offset(52); return o != 0 ? __p.__vector_len(o) : 0; } }
#if ENABLE_SPAN_T
- public Span<byte> GetTestarrayofboolsBytes() { return __p.__vector_as_span(52); }
+ public Span<bool> GetTestarrayofboolsBytes() { return __p.__vector_as_span<bool>(52, 1); }
#else
public ArraySegment<byte>? GetTestarrayofboolsBytes() { return __p.__vector_as_arraysegment(52); }
#endif
@@ -107,7 +110,7 @@
public byte Flex(int j) { int o = __p.__offset(64); return o != 0 ? __p.bb.Get(__p.__vector(o) + j * 1) : (byte)0; }
public int FlexLength { get { int o = __p.__offset(64); return o != 0 ? __p.__vector_len(o) : 0; } }
#if ENABLE_SPAN_T
- public Span<byte> GetFlexBytes() { return __p.__vector_as_span(64); }
+ public Span<byte> GetFlexBytes() { return __p.__vector_as_span<byte>(64, 1); }
#else
public ArraySegment<byte>? GetFlexBytes() { return __p.__vector_as_arraysegment(64); }
#endif
@@ -118,7 +121,7 @@
public long VectorOfLongs(int j) { int o = __p.__offset(68); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
public int VectorOfLongsLength { get { int o = __p.__offset(68); return o != 0 ? __p.__vector_len(o) : 0; } }
#if ENABLE_SPAN_T
- public Span<byte> GetVectorOfLongsBytes() { return __p.__vector_as_span(68); }
+ public Span<long> GetVectorOfLongsBytes() { return __p.__vector_as_span<long>(68, 8); }
#else
public ArraySegment<byte>? GetVectorOfLongsBytes() { return __p.__vector_as_arraysegment(68); }
#endif
@@ -127,7 +130,7 @@
public double VectorOfDoubles(int j) { int o = __p.__offset(70); return o != 0 ? __p.bb.GetDouble(__p.__vector(o) + j * 8) : (double)0; }
public int VectorOfDoublesLength { get { int o = __p.__offset(70); return o != 0 ? __p.__vector_len(o) : 0; } }
#if ENABLE_SPAN_T
- public Span<byte> GetVectorOfDoublesBytes() { return __p.__vector_as_span(70); }
+ public Span<double> GetVectorOfDoublesBytes() { return __p.__vector_as_span<double>(70, 8); }
#else
public ArraySegment<byte>? GetVectorOfDoublesBytes() { return __p.__vector_as_arraysegment(70); }
#endif
@@ -142,7 +145,7 @@
public ulong VectorOfWeakReferences(int j) { int o = __p.__offset(78); return o != 0 ? __p.bb.GetUlong(__p.__vector(o) + j * 8) : (ulong)0; }
public int VectorOfWeakReferencesLength { get { int o = __p.__offset(78); return o != 0 ? __p.__vector_len(o) : 0; } }
#if ENABLE_SPAN_T
- public Span<byte> GetVectorOfWeakReferencesBytes() { return __p.__vector_as_span(78); }
+ public Span<ulong> GetVectorOfWeakReferencesBytes() { return __p.__vector_as_span<ulong>(78, 8); }
#else
public ArraySegment<byte>? GetVectorOfWeakReferencesBytes() { return __p.__vector_as_arraysegment(78); }
#endif
@@ -156,7 +159,7 @@
public ulong VectorOfCoOwningReferences(int j) { int o = __p.__offset(84); return o != 0 ? __p.bb.GetUlong(__p.__vector(o) + j * 8) : (ulong)0; }
public int VectorOfCoOwningReferencesLength { get { int o = __p.__offset(84); return o != 0 ? __p.__vector_len(o) : 0; } }
#if ENABLE_SPAN_T
- public Span<byte> GetVectorOfCoOwningReferencesBytes() { return __p.__vector_as_span(84); }
+ public Span<ulong> GetVectorOfCoOwningReferencesBytes() { return __p.__vector_as_span<ulong>(84, 8); }
#else
public ArraySegment<byte>? GetVectorOfCoOwningReferencesBytes() { return __p.__vector_as_arraysegment(84); }
#endif
@@ -167,29 +170,148 @@
public ulong VectorOfNonOwningReferences(int j) { int o = __p.__offset(88); return o != 0 ? __p.bb.GetUlong(__p.__vector(o) + j * 8) : (ulong)0; }
public int VectorOfNonOwningReferencesLength { get { int o = __p.__offset(88); return o != 0 ? __p.__vector_len(o) : 0; } }
#if ENABLE_SPAN_T
- public Span<byte> GetVectorOfNonOwningReferencesBytes() { return __p.__vector_as_span(88); }
+ public Span<ulong> GetVectorOfNonOwningReferencesBytes() { return __p.__vector_as_span<ulong>(88, 8); }
#else
public ArraySegment<byte>? GetVectorOfNonOwningReferencesBytes() { return __p.__vector_as_arraysegment(88); }
#endif
public ulong[] GetVectorOfNonOwningReferencesArray() { return __p.__vector_as_array<ulong>(88); }
public bool MutateVectorOfNonOwningReferences(int j, ulong vector_of_non_owning_references) { int o = __p.__offset(88); if (o != 0) { __p.bb.PutUlong(__p.__vector(o) + j * 8, vector_of_non_owning_references); return true; } else { return false; } }
public MyGame.Example.AnyUniqueAliases AnyUniqueType { get { int o = __p.__offset(90); return o != 0 ? (MyGame.Example.AnyUniqueAliases)__p.bb.Get(o + __p.bb_pos) : MyGame.Example.AnyUniqueAliases.NONE; } }
- public bool MutateAnyUniqueType(MyGame.Example.AnyUniqueAliases any_unique_type) { int o = __p.__offset(90); if (o != 0) { __p.bb.Put(o + __p.bb_pos, (byte)any_unique_type); return true; } else { return false; } }
- public TTable? AnyUnique<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(92); return o != 0 ? (TTable?)__p.__union<TTable>(o) : null; }
+ public TTable? AnyUnique<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(92); return o != 0 ? (TTable?)__p.__union<TTable>(o + __p.bb_pos) : null; }
+ public MyGame.Example.Monster AnyUniqueAsM() { return AnyUnique<MyGame.Example.Monster>().Value; }
+ internal MyGame.Example.TestSimpleTableWithEnum AnyUniqueAsTS() { return AnyUnique<MyGame.Example.TestSimpleTableWithEnum>().Value; }
+ public MyGame.Example2.Monster AnyUniqueAsM2() { return AnyUnique<MyGame.Example2.Monster>().Value; }
public MyGame.Example.AnyAmbiguousAliases AnyAmbiguousType { get { int o = __p.__offset(94); return o != 0 ? (MyGame.Example.AnyAmbiguousAliases)__p.bb.Get(o + __p.bb_pos) : MyGame.Example.AnyAmbiguousAliases.NONE; } }
- public bool MutateAnyAmbiguousType(MyGame.Example.AnyAmbiguousAliases any_ambiguous_type) { int o = __p.__offset(94); if (o != 0) { __p.bb.Put(o + __p.bb_pos, (byte)any_ambiguous_type); return true; } else { return false; } }
- public TTable? AnyAmbiguous<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(96); return o != 0 ? (TTable?)__p.__union<TTable>(o) : null; }
+ public TTable? AnyAmbiguous<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(96); return o != 0 ? (TTable?)__p.__union<TTable>(o + __p.bb_pos) : null; }
+ public MyGame.Example.Monster AnyAmbiguousAsM1() { return AnyAmbiguous<MyGame.Example.Monster>().Value; }
+ public MyGame.Example.Monster AnyAmbiguousAsM2() { return AnyAmbiguous<MyGame.Example.Monster>().Value; }
+ public MyGame.Example.Monster AnyAmbiguousAsM3() { return AnyAmbiguous<MyGame.Example.Monster>().Value; }
public MyGame.Example.Color VectorOfEnums(int j) { int o = __p.__offset(98); return o != 0 ? (MyGame.Example.Color)__p.bb.Get(__p.__vector(o) + j * 1) : (MyGame.Example.Color)0; }
public int VectorOfEnumsLength { get { int o = __p.__offset(98); return o != 0 ? __p.__vector_len(o) : 0; } }
#if ENABLE_SPAN_T
- public Span<byte> GetVectorOfEnumsBytes() { return __p.__vector_as_span(98); }
+ public Span<MyGame.Example.Color> GetVectorOfEnumsBytes() { return __p.__vector_as_span<MyGame.Example.Color>(98, 1); }
#else
public ArraySegment<byte>? GetVectorOfEnumsBytes() { return __p.__vector_as_arraysegment(98); }
#endif
- public MyGame.Example.Color[] GetVectorOfEnumsArray() { return __p.__vector_as_array<MyGame.Example.Color>(98); }
+ public MyGame.Example.Color[] GetVectorOfEnumsArray() { int o = __p.__offset(98); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); MyGame.Example.Color[] a = new MyGame.Example.Color[l]; for (int i = 0; i < l; i++) { a[i] = (MyGame.Example.Color)__p.bb.Get(p + i * 1); } return a; }
public bool MutateVectorOfEnums(int j, MyGame.Example.Color vector_of_enums) { int o = __p.__offset(98); if (o != 0) { __p.bb.Put(__p.__vector(o) + j * 1, (byte)vector_of_enums); return true; } else { return false; } }
+ public MyGame.Example.Race SignedEnum { get { int o = __p.__offset(100); return o != 0 ? (MyGame.Example.Race)__p.bb.GetSbyte(o + __p.bb_pos) : MyGame.Example.Race.None; } }
+ public bool MutateSignedEnum(MyGame.Example.Race signed_enum) { int o = __p.__offset(100); if (o != 0) { __p.bb.PutSbyte(o + __p.bb_pos, (sbyte)signed_enum); return true; } else { return false; } }
+ public byte Testrequirednestedflatbuffer(int j) { int o = __p.__offset(102); return o != 0 ? __p.bb.Get(__p.__vector(o) + j * 1) : (byte)0; }
+ public int TestrequirednestedflatbufferLength { get { int o = __p.__offset(102); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+ public Span<byte> GetTestrequirednestedflatbufferBytes() { return __p.__vector_as_span<byte>(102, 1); }
+#else
+ public ArraySegment<byte>? GetTestrequirednestedflatbufferBytes() { return __p.__vector_as_arraysegment(102); }
+#endif
+ public byte[] GetTestrequirednestedflatbufferArray() { return __p.__vector_as_array<byte>(102); }
+ public MyGame.Example.Monster? GetTestrequirednestedflatbufferAsMonster() { int o = __p.__offset(102); return o != 0 ? (MyGame.Example.Monster?)(new MyGame.Example.Monster()).__assign(__p.__indirect(__p.__vector(o)), __p.bb) : null; }
+ public bool MutateTestrequirednestedflatbuffer(int j, byte testrequirednestedflatbuffer) { int o = __p.__offset(102); if (o != 0) { __p.bb.Put(__p.__vector(o) + j * 1, testrequirednestedflatbuffer); return true; } else { return false; } }
- public static void StartMonster(FlatBufferBuilder builder) { builder.StartTable(48); }
+ public static Offset<MyGame.Example.Monster> CreateMonster(FlatBufferBuilder builder,
+ MyGame.Example.Vec3T pos = null,
+ short mana = 150,
+ short hp = 100,
+ StringOffset nameOffset = default(StringOffset),
+ VectorOffset inventoryOffset = default(VectorOffset),
+ MyGame.Example.Color color = MyGame.Example.Color.Blue,
+ MyGame.Example.Any test_type = MyGame.Example.Any.NONE,
+ int testOffset = 0,
+ VectorOffset test4Offset = default(VectorOffset),
+ VectorOffset testarrayofstringOffset = default(VectorOffset),
+ VectorOffset testarrayoftablesOffset = default(VectorOffset),
+ Offset<MyGame.Example.Monster> enemyOffset = default(Offset<MyGame.Example.Monster>),
+ VectorOffset testnestedflatbufferOffset = default(VectorOffset),
+ Offset<MyGame.Example.Stat> testemptyOffset = default(Offset<MyGame.Example.Stat>),
+ bool testbool = false,
+ int testhashs32_fnv1 = 0,
+ uint testhashu32_fnv1 = 0,
+ long testhashs64_fnv1 = 0,
+ ulong testhashu64_fnv1 = 0,
+ int testhashs32_fnv1a = 0,
+ uint testhashu32_fnv1a = 0,
+ long testhashs64_fnv1a = 0,
+ ulong testhashu64_fnv1a = 0,
+ VectorOffset testarrayofboolsOffset = default(VectorOffset),
+ float testf = 3.14159f,
+ float testf2 = 3.0f,
+ float testf3 = 0.0f,
+ VectorOffset testarrayofstring2Offset = default(VectorOffset),
+ VectorOffset testarrayofsortedstructOffset = default(VectorOffset),
+ VectorOffset flexOffset = default(VectorOffset),
+ VectorOffset test5Offset = default(VectorOffset),
+ VectorOffset vector_of_longsOffset = default(VectorOffset),
+ VectorOffset vector_of_doublesOffset = default(VectorOffset),
+ Offset<MyGame.InParentNamespace> parent_namespace_testOffset = default(Offset<MyGame.InParentNamespace>),
+ VectorOffset vector_of_referrablesOffset = default(VectorOffset),
+ ulong single_weak_reference = 0,
+ VectorOffset vector_of_weak_referencesOffset = default(VectorOffset),
+ VectorOffset vector_of_strong_referrablesOffset = default(VectorOffset),
+ ulong co_owning_reference = 0,
+ VectorOffset vector_of_co_owning_referencesOffset = default(VectorOffset),
+ ulong non_owning_reference = 0,
+ VectorOffset vector_of_non_owning_referencesOffset = default(VectorOffset),
+ MyGame.Example.AnyUniqueAliases any_unique_type = MyGame.Example.AnyUniqueAliases.NONE,
+ int any_uniqueOffset = 0,
+ MyGame.Example.AnyAmbiguousAliases any_ambiguous_type = MyGame.Example.AnyAmbiguousAliases.NONE,
+ int any_ambiguousOffset = 0,
+ VectorOffset vector_of_enumsOffset = default(VectorOffset),
+ MyGame.Example.Race signed_enum = MyGame.Example.Race.None,
+ VectorOffset testrequirednestedflatbufferOffset = default(VectorOffset)) {
+ builder.StartTable(50);
+ Monster.AddNonOwningReference(builder, non_owning_reference);
+ Monster.AddCoOwningReference(builder, co_owning_reference);
+ Monster.AddSingleWeakReference(builder, single_weak_reference);
+ Monster.AddTesthashu64Fnv1a(builder, testhashu64_fnv1a);
+ Monster.AddTesthashs64Fnv1a(builder, testhashs64_fnv1a);
+ Monster.AddTesthashu64Fnv1(builder, testhashu64_fnv1);
+ Monster.AddTesthashs64Fnv1(builder, testhashs64_fnv1);
+ Monster.AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbufferOffset);
+ Monster.AddVectorOfEnums(builder, vector_of_enumsOffset);
+ Monster.AddAnyAmbiguous(builder, any_ambiguousOffset);
+ Monster.AddAnyUnique(builder, any_uniqueOffset);
+ Monster.AddVectorOfNonOwningReferences(builder, vector_of_non_owning_referencesOffset);
+ Monster.AddVectorOfCoOwningReferences(builder, vector_of_co_owning_referencesOffset);
+ Monster.AddVectorOfStrongReferrables(builder, vector_of_strong_referrablesOffset);
+ Monster.AddVectorOfWeakReferences(builder, vector_of_weak_referencesOffset);
+ Monster.AddVectorOfReferrables(builder, vector_of_referrablesOffset);
+ Monster.AddParentNamespaceTest(builder, parent_namespace_testOffset);
+ Monster.AddVectorOfDoubles(builder, vector_of_doublesOffset);
+ Monster.AddVectorOfLongs(builder, vector_of_longsOffset);
+ Monster.AddTest5(builder, test5Offset);
+ Monster.AddFlex(builder, flexOffset);
+ Monster.AddTestarrayofsortedstruct(builder, testarrayofsortedstructOffset);
+ Monster.AddTestarrayofstring2(builder, testarrayofstring2Offset);
+ Monster.AddTestf3(builder, testf3);
+ Monster.AddTestf2(builder, testf2);
+ Monster.AddTestf(builder, testf);
+ Monster.AddTestarrayofbools(builder, testarrayofboolsOffset);
+ Monster.AddTesthashu32Fnv1a(builder, testhashu32_fnv1a);
+ Monster.AddTesthashs32Fnv1a(builder, testhashs32_fnv1a);
+ Monster.AddTesthashu32Fnv1(builder, testhashu32_fnv1);
+ Monster.AddTesthashs32Fnv1(builder, testhashs32_fnv1);
+ Monster.AddTestempty(builder, testemptyOffset);
+ Monster.AddTestnestedflatbuffer(builder, testnestedflatbufferOffset);
+ Monster.AddEnemy(builder, enemyOffset);
+ Monster.AddTestarrayoftables(builder, testarrayoftablesOffset);
+ Monster.AddTestarrayofstring(builder, testarrayofstringOffset);
+ Monster.AddTest4(builder, test4Offset);
+ Monster.AddTest(builder, testOffset);
+ Monster.AddInventory(builder, inventoryOffset);
+ Monster.AddName(builder, nameOffset);
+ Monster.AddPos(builder, MyGame.Example.Vec3.Pack(builder, pos));
+ Monster.AddHp(builder, hp);
+ Monster.AddMana(builder, mana);
+ Monster.AddSignedEnum(builder, signed_enum);
+ Monster.AddAnyAmbiguousType(builder, any_ambiguous_type);
+ Monster.AddAnyUniqueType(builder, any_unique_type);
+ Monster.AddTestbool(builder, testbool);
+ Monster.AddTestType(builder, test_type);
+ Monster.AddColor(builder, color);
+ return Monster.EndMonster(builder);
+ }
+
+ public static void StartMonster(FlatBufferBuilder builder) { builder.StartTable(50); }
public static void AddPos(FlatBufferBuilder builder, Offset<MyGame.Example.Vec3> posOffset) { builder.AddStruct(0, posOffset.Value, 0); }
public static void AddMana(FlatBufferBuilder builder, short mana) { builder.AddShort(1, mana, 150); }
public static void AddHp(FlatBufferBuilder builder, short hp) { builder.AddShort(2, hp, 100); }
@@ -285,6 +407,11 @@
public static VectorOffset CreateVectorOfEnumsVector(FlatBufferBuilder builder, MyGame.Example.Color[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddByte((byte)data[i]); return builder.EndVector(); }
public static VectorOffset CreateVectorOfEnumsVectorBlock(FlatBufferBuilder builder, MyGame.Example.Color[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); }
public static void StartVectorOfEnumsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); }
+ public static void AddSignedEnum(FlatBufferBuilder builder, MyGame.Example.Race signedEnum) { builder.AddSbyte(48, (sbyte)signedEnum, -1); }
+ public static void AddTestrequirednestedflatbuffer(FlatBufferBuilder builder, VectorOffset testrequirednestedflatbufferOffset) { builder.AddOffset(49, testrequirednestedflatbufferOffset.Value, 0); }
+ public static VectorOffset CreateTestrequirednestedflatbufferVector(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddByte(data[i]); return builder.EndVector(); }
+ public static VectorOffset CreateTestrequirednestedflatbufferVectorBlock(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); }
+ public static void StartTestrequirednestedflatbufferVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); }
public static Offset<MyGame.Example.Monster> EndMonster(FlatBufferBuilder builder) {
int o = builder.EndTable();
builder.Required(o, 10); // name
@@ -318,7 +445,492 @@
}
return null;
}
+ public MonsterT UnPack() {
+ var _o = new MonsterT();
+ this.UnPackTo(_o);
+ return _o;
+ }
+ public void UnPackTo(MonsterT _o) {
+ _o.Pos = this.Pos.HasValue ? this.Pos.Value.UnPack() : null;
+ _o.Mana = this.Mana;
+ _o.Hp = this.Hp;
+ _o.Name = this.Name;
+ _o.Inventory = new List<byte>();
+ for (var _j = 0; _j < this.InventoryLength; ++_j) {_o.Inventory.Add(this.Inventory(_j));}
+ _o.Color = this.Color;
+ _o.Test = new MyGame.Example.AnyUnion();
+ _o.Test.Type = this.TestType;
+ switch (this.TestType) {
+ default: break;
+ case MyGame.Example.Any.Monster:
+ _o.Test.Value = this.Test<MyGame.Example.Monster>().HasValue ? this.Test<MyGame.Example.Monster>().Value.UnPack() : null;
+ break;
+ case MyGame.Example.Any.TestSimpleTableWithEnum:
+ _o.Test.Value = this.Test<MyGame.Example.TestSimpleTableWithEnum>().HasValue ? this.Test<MyGame.Example.TestSimpleTableWithEnum>().Value.UnPack() : null;
+ break;
+ case MyGame.Example.Any.MyGame_Example2_Monster:
+ _o.Test.Value = this.Test<MyGame.Example2.Monster>().HasValue ? this.Test<MyGame.Example2.Monster>().Value.UnPack() : null;
+ break;
+ }
+ _o.Test4 = new List<MyGame.Example.TestT>();
+ for (var _j = 0; _j < this.Test4Length; ++_j) {_o.Test4.Add(this.Test4(_j).HasValue ? this.Test4(_j).Value.UnPack() : null);}
+ _o.Testarrayofstring = new List<string>();
+ for (var _j = 0; _j < this.TestarrayofstringLength; ++_j) {_o.Testarrayofstring.Add(this.Testarrayofstring(_j));}
+ _o.Testarrayoftables = new List<MyGame.Example.MonsterT>();
+ for (var _j = 0; _j < this.TestarrayoftablesLength; ++_j) {_o.Testarrayoftables.Add(this.Testarrayoftables(_j).HasValue ? this.Testarrayoftables(_j).Value.UnPack() : null);}
+ _o.Enemy = this.Enemy.HasValue ? this.Enemy.Value.UnPack() : null;
+ _o.Testnestedflatbuffer = new List<byte>();
+ for (var _j = 0; _j < this.TestnestedflatbufferLength; ++_j) {_o.Testnestedflatbuffer.Add(this.Testnestedflatbuffer(_j));}
+ _o.Testempty = this.Testempty.HasValue ? this.Testempty.Value.UnPack() : null;
+ _o.Testbool = this.Testbool;
+ _o.Testhashs32Fnv1 = this.Testhashs32Fnv1;
+ _o.Testhashu32Fnv1 = this.Testhashu32Fnv1;
+ _o.Testhashs64Fnv1 = this.Testhashs64Fnv1;
+ _o.Testhashu64Fnv1 = this.Testhashu64Fnv1;
+ _o.Testhashs32Fnv1a = this.Testhashs32Fnv1a;
+ _o.Testhashu32Fnv1a = this.Testhashu32Fnv1a;
+ _o.Testhashs64Fnv1a = this.Testhashs64Fnv1a;
+ _o.Testhashu64Fnv1a = this.Testhashu64Fnv1a;
+ _o.Testarrayofbools = new List<bool>();
+ for (var _j = 0; _j < this.TestarrayofboolsLength; ++_j) {_o.Testarrayofbools.Add(this.Testarrayofbools(_j));}
+ _o.Testf = this.Testf;
+ _o.Testf2 = this.Testf2;
+ _o.Testf3 = this.Testf3;
+ _o.Testarrayofstring2 = new List<string>();
+ for (var _j = 0; _j < this.Testarrayofstring2Length; ++_j) {_o.Testarrayofstring2.Add(this.Testarrayofstring2(_j));}
+ _o.Testarrayofsortedstruct = new List<MyGame.Example.AbilityT>();
+ for (var _j = 0; _j < this.TestarrayofsortedstructLength; ++_j) {_o.Testarrayofsortedstruct.Add(this.Testarrayofsortedstruct(_j).HasValue ? this.Testarrayofsortedstruct(_j).Value.UnPack() : null);}
+ _o.Flex = new List<byte>();
+ for (var _j = 0; _j < this.FlexLength; ++_j) {_o.Flex.Add(this.Flex(_j));}
+ _o.Test5 = new List<MyGame.Example.TestT>();
+ for (var _j = 0; _j < this.Test5Length; ++_j) {_o.Test5.Add(this.Test5(_j).HasValue ? this.Test5(_j).Value.UnPack() : null);}
+ _o.VectorOfLongs = new List<long>();
+ for (var _j = 0; _j < this.VectorOfLongsLength; ++_j) {_o.VectorOfLongs.Add(this.VectorOfLongs(_j));}
+ _o.VectorOfDoubles = new List<double>();
+ for (var _j = 0; _j < this.VectorOfDoublesLength; ++_j) {_o.VectorOfDoubles.Add(this.VectorOfDoubles(_j));}
+ _o.ParentNamespaceTest = this.ParentNamespaceTest.HasValue ? this.ParentNamespaceTest.Value.UnPack() : null;
+ _o.VectorOfReferrables = new List<MyGame.Example.ReferrableT>();
+ for (var _j = 0; _j < this.VectorOfReferrablesLength; ++_j) {_o.VectorOfReferrables.Add(this.VectorOfReferrables(_j).HasValue ? this.VectorOfReferrables(_j).Value.UnPack() : null);}
+ _o.SingleWeakReference = this.SingleWeakReference;
+ _o.VectorOfWeakReferences = new List<ulong>();
+ for (var _j = 0; _j < this.VectorOfWeakReferencesLength; ++_j) {_o.VectorOfWeakReferences.Add(this.VectorOfWeakReferences(_j));}
+ _o.VectorOfStrongReferrables = new List<MyGame.Example.ReferrableT>();
+ for (var _j = 0; _j < this.VectorOfStrongReferrablesLength; ++_j) {_o.VectorOfStrongReferrables.Add(this.VectorOfStrongReferrables(_j).HasValue ? this.VectorOfStrongReferrables(_j).Value.UnPack() : null);}
+ _o.CoOwningReference = this.CoOwningReference;
+ _o.VectorOfCoOwningReferences = new List<ulong>();
+ for (var _j = 0; _j < this.VectorOfCoOwningReferencesLength; ++_j) {_o.VectorOfCoOwningReferences.Add(this.VectorOfCoOwningReferences(_j));}
+ _o.NonOwningReference = this.NonOwningReference;
+ _o.VectorOfNonOwningReferences = new List<ulong>();
+ for (var _j = 0; _j < this.VectorOfNonOwningReferencesLength; ++_j) {_o.VectorOfNonOwningReferences.Add(this.VectorOfNonOwningReferences(_j));}
+ _o.AnyUnique = new MyGame.Example.AnyUniqueAliasesUnion();
+ _o.AnyUnique.Type = this.AnyUniqueType;
+ switch (this.AnyUniqueType) {
+ default: break;
+ case MyGame.Example.AnyUniqueAliases.M:
+ _o.AnyUnique.Value = this.AnyUnique<MyGame.Example.Monster>().HasValue ? this.AnyUnique<MyGame.Example.Monster>().Value.UnPack() : null;
+ break;
+ case MyGame.Example.AnyUniqueAliases.TS:
+ _o.AnyUnique.Value = this.AnyUnique<MyGame.Example.TestSimpleTableWithEnum>().HasValue ? this.AnyUnique<MyGame.Example.TestSimpleTableWithEnum>().Value.UnPack() : null;
+ break;
+ case MyGame.Example.AnyUniqueAliases.M2:
+ _o.AnyUnique.Value = this.AnyUnique<MyGame.Example2.Monster>().HasValue ? this.AnyUnique<MyGame.Example2.Monster>().Value.UnPack() : null;
+ break;
+ }
+ _o.AnyAmbiguous = new MyGame.Example.AnyAmbiguousAliasesUnion();
+ _o.AnyAmbiguous.Type = this.AnyAmbiguousType;
+ switch (this.AnyAmbiguousType) {
+ default: break;
+ case MyGame.Example.AnyAmbiguousAliases.M1:
+ _o.AnyAmbiguous.Value = this.AnyAmbiguous<MyGame.Example.Monster>().HasValue ? this.AnyAmbiguous<MyGame.Example.Monster>().Value.UnPack() : null;
+ break;
+ case MyGame.Example.AnyAmbiguousAliases.M2:
+ _o.AnyAmbiguous.Value = this.AnyAmbiguous<MyGame.Example.Monster>().HasValue ? this.AnyAmbiguous<MyGame.Example.Monster>().Value.UnPack() : null;
+ break;
+ case MyGame.Example.AnyAmbiguousAliases.M3:
+ _o.AnyAmbiguous.Value = this.AnyAmbiguous<MyGame.Example.Monster>().HasValue ? this.AnyAmbiguous<MyGame.Example.Monster>().Value.UnPack() : null;
+ break;
+ }
+ _o.VectorOfEnums = new List<MyGame.Example.Color>();
+ for (var _j = 0; _j < this.VectorOfEnumsLength; ++_j) {_o.VectorOfEnums.Add(this.VectorOfEnums(_j));}
+ _o.SignedEnum = this.SignedEnum;
+ _o.Testrequirednestedflatbuffer = new List<byte>();
+ for (var _j = 0; _j < this.TestrequirednestedflatbufferLength; ++_j) {_o.Testrequirednestedflatbuffer.Add(this.Testrequirednestedflatbuffer(_j));}
+ }
+ public static Offset<MyGame.Example.Monster> Pack(FlatBufferBuilder builder, MonsterT _o) {
+ if (_o == null) return default(Offset<MyGame.Example.Monster>);
+ var _name = _o.Name == null ? default(StringOffset) : builder.CreateString(_o.Name);
+ var _inventory = default(VectorOffset);
+ if (_o.Inventory != null) {
+ var __inventory = _o.Inventory.ToArray();
+ _inventory = CreateInventoryVector(builder, __inventory);
+ }
+ var _test_type = _o.Test == null ? MyGame.Example.Any.NONE : _o.Test.Type;
+ var _test = _o.Test == null ? 0 : MyGame.Example.AnyUnion.Pack(builder, _o.Test);
+ var _test4 = default(VectorOffset);
+ if (_o.Test4 != null) {
+ StartTest4Vector(builder, _o.Test4.Count);
+ for (var _j = _o.Test4.Count - 1; _j >= 0; --_j) { MyGame.Example.Test.Pack(builder, _o.Test4[_j]); }
+ _test4 = builder.EndVector();
+ }
+ var _testarrayofstring = default(VectorOffset);
+ if (_o.Testarrayofstring != null) {
+ var __testarrayofstring = new StringOffset[_o.Testarrayofstring.Count];
+ for (var _j = 0; _j < __testarrayofstring.Length; ++_j) { __testarrayofstring[_j] = builder.CreateString(_o.Testarrayofstring[_j]); }
+ _testarrayofstring = CreateTestarrayofstringVector(builder, __testarrayofstring);
+ }
+ var _testarrayoftables = default(VectorOffset);
+ if (_o.Testarrayoftables != null) {
+ var __testarrayoftables = new Offset<MyGame.Example.Monster>[_o.Testarrayoftables.Count];
+ for (var _j = 0; _j < __testarrayoftables.Length; ++_j) { __testarrayoftables[_j] = MyGame.Example.Monster.Pack(builder, _o.Testarrayoftables[_j]); }
+ _testarrayoftables = CreateTestarrayoftablesVector(builder, __testarrayoftables);
+ }
+ var _enemy = _o.Enemy == null ? default(Offset<MyGame.Example.Monster>) : MyGame.Example.Monster.Pack(builder, _o.Enemy);
+ var _testnestedflatbuffer = default(VectorOffset);
+ if (_o.Testnestedflatbuffer != null) {
+ var __testnestedflatbuffer = _o.Testnestedflatbuffer.ToArray();
+ _testnestedflatbuffer = CreateTestnestedflatbufferVector(builder, __testnestedflatbuffer);
+ }
+ var _testempty = _o.Testempty == null ? default(Offset<MyGame.Example.Stat>) : MyGame.Example.Stat.Pack(builder, _o.Testempty);
+ var _testarrayofbools = default(VectorOffset);
+ if (_o.Testarrayofbools != null) {
+ var __testarrayofbools = _o.Testarrayofbools.ToArray();
+ _testarrayofbools = CreateTestarrayofboolsVector(builder, __testarrayofbools);
+ }
+ var _testarrayofstring2 = default(VectorOffset);
+ if (_o.Testarrayofstring2 != null) {
+ var __testarrayofstring2 = new StringOffset[_o.Testarrayofstring2.Count];
+ for (var _j = 0; _j < __testarrayofstring2.Length; ++_j) { __testarrayofstring2[_j] = builder.CreateString(_o.Testarrayofstring2[_j]); }
+ _testarrayofstring2 = CreateTestarrayofstring2Vector(builder, __testarrayofstring2);
+ }
+ var _testarrayofsortedstruct = default(VectorOffset);
+ if (_o.Testarrayofsortedstruct != null) {
+ StartTestarrayofsortedstructVector(builder, _o.Testarrayofsortedstruct.Count);
+ for (var _j = _o.Testarrayofsortedstruct.Count - 1; _j >= 0; --_j) { MyGame.Example.Ability.Pack(builder, _o.Testarrayofsortedstruct[_j]); }
+ _testarrayofsortedstruct = builder.EndVector();
+ }
+ var _flex = default(VectorOffset);
+ if (_o.Flex != null) {
+ var __flex = _o.Flex.ToArray();
+ _flex = CreateFlexVector(builder, __flex);
+ }
+ var _test5 = default(VectorOffset);
+ if (_o.Test5 != null) {
+ StartTest5Vector(builder, _o.Test5.Count);
+ for (var _j = _o.Test5.Count - 1; _j >= 0; --_j) { MyGame.Example.Test.Pack(builder, _o.Test5[_j]); }
+ _test5 = builder.EndVector();
+ }
+ var _vector_of_longs = default(VectorOffset);
+ if (_o.VectorOfLongs != null) {
+ var __vector_of_longs = _o.VectorOfLongs.ToArray();
+ _vector_of_longs = CreateVectorOfLongsVector(builder, __vector_of_longs);
+ }
+ var _vector_of_doubles = default(VectorOffset);
+ if (_o.VectorOfDoubles != null) {
+ var __vector_of_doubles = _o.VectorOfDoubles.ToArray();
+ _vector_of_doubles = CreateVectorOfDoublesVector(builder, __vector_of_doubles);
+ }
+ var _parent_namespace_test = _o.ParentNamespaceTest == null ? default(Offset<MyGame.InParentNamespace>) : MyGame.InParentNamespace.Pack(builder, _o.ParentNamespaceTest);
+ var _vector_of_referrables = default(VectorOffset);
+ if (_o.VectorOfReferrables != null) {
+ var __vector_of_referrables = new Offset<MyGame.Example.Referrable>[_o.VectorOfReferrables.Count];
+ for (var _j = 0; _j < __vector_of_referrables.Length; ++_j) { __vector_of_referrables[_j] = MyGame.Example.Referrable.Pack(builder, _o.VectorOfReferrables[_j]); }
+ _vector_of_referrables = CreateVectorOfReferrablesVector(builder, __vector_of_referrables);
+ }
+ var _vector_of_weak_references = default(VectorOffset);
+ if (_o.VectorOfWeakReferences != null) {
+ var __vector_of_weak_references = _o.VectorOfWeakReferences.ToArray();
+ _vector_of_weak_references = CreateVectorOfWeakReferencesVector(builder, __vector_of_weak_references);
+ }
+ var _vector_of_strong_referrables = default(VectorOffset);
+ if (_o.VectorOfStrongReferrables != null) {
+ var __vector_of_strong_referrables = new Offset<MyGame.Example.Referrable>[_o.VectorOfStrongReferrables.Count];
+ for (var _j = 0; _j < __vector_of_strong_referrables.Length; ++_j) { __vector_of_strong_referrables[_j] = MyGame.Example.Referrable.Pack(builder, _o.VectorOfStrongReferrables[_j]); }
+ _vector_of_strong_referrables = CreateVectorOfStrongReferrablesVector(builder, __vector_of_strong_referrables);
+ }
+ var _vector_of_co_owning_references = default(VectorOffset);
+ if (_o.VectorOfCoOwningReferences != null) {
+ var __vector_of_co_owning_references = _o.VectorOfCoOwningReferences.ToArray();
+ _vector_of_co_owning_references = CreateVectorOfCoOwningReferencesVector(builder, __vector_of_co_owning_references);
+ }
+ var _vector_of_non_owning_references = default(VectorOffset);
+ if (_o.VectorOfNonOwningReferences != null) {
+ var __vector_of_non_owning_references = _o.VectorOfNonOwningReferences.ToArray();
+ _vector_of_non_owning_references = CreateVectorOfNonOwningReferencesVector(builder, __vector_of_non_owning_references);
+ }
+ var _any_unique_type = _o.AnyUnique == null ? MyGame.Example.AnyUniqueAliases.NONE : _o.AnyUnique.Type;
+ var _any_unique = _o.AnyUnique == null ? 0 : MyGame.Example.AnyUniqueAliasesUnion.Pack(builder, _o.AnyUnique);
+ var _any_ambiguous_type = _o.AnyAmbiguous == null ? MyGame.Example.AnyAmbiguousAliases.NONE : _o.AnyAmbiguous.Type;
+ var _any_ambiguous = _o.AnyAmbiguous == null ? 0 : MyGame.Example.AnyAmbiguousAliasesUnion.Pack(builder, _o.AnyAmbiguous);
+ var _vector_of_enums = default(VectorOffset);
+ if (_o.VectorOfEnums != null) {
+ var __vector_of_enums = _o.VectorOfEnums.ToArray();
+ _vector_of_enums = CreateVectorOfEnumsVector(builder, __vector_of_enums);
+ }
+ var _testrequirednestedflatbuffer = default(VectorOffset);
+ if (_o.Testrequirednestedflatbuffer != null) {
+ var __testrequirednestedflatbuffer = _o.Testrequirednestedflatbuffer.ToArray();
+ _testrequirednestedflatbuffer = CreateTestrequirednestedflatbufferVector(builder, __testrequirednestedflatbuffer);
+ }
+ return CreateMonster(
+ builder,
+ _o.Pos,
+ _o.Mana,
+ _o.Hp,
+ _name,
+ _inventory,
+ _o.Color,
+ _test_type,
+ _test,
+ _test4,
+ _testarrayofstring,
+ _testarrayoftables,
+ _enemy,
+ _testnestedflatbuffer,
+ _testempty,
+ _o.Testbool,
+ _o.Testhashs32Fnv1,
+ _o.Testhashu32Fnv1,
+ _o.Testhashs64Fnv1,
+ _o.Testhashu64Fnv1,
+ _o.Testhashs32Fnv1a,
+ _o.Testhashu32Fnv1a,
+ _o.Testhashs64Fnv1a,
+ _o.Testhashu64Fnv1a,
+ _testarrayofbools,
+ _o.Testf,
+ _o.Testf2,
+ _o.Testf3,
+ _testarrayofstring2,
+ _testarrayofsortedstruct,
+ _flex,
+ _test5,
+ _vector_of_longs,
+ _vector_of_doubles,
+ _parent_namespace_test,
+ _vector_of_referrables,
+ _o.SingleWeakReference,
+ _vector_of_weak_references,
+ _vector_of_strong_referrables,
+ _o.CoOwningReference,
+ _vector_of_co_owning_references,
+ _o.NonOwningReference,
+ _vector_of_non_owning_references,
+ _any_unique_type,
+ _any_unique,
+ _any_ambiguous_type,
+ _any_ambiguous,
+ _vector_of_enums,
+ _o.SignedEnum,
+ _testrequirednestedflatbuffer);
+ }
};
+public class MonsterT
+{
+ [Newtonsoft.Json.JsonProperty("pos")]
+ public MyGame.Example.Vec3T Pos { get; set; }
+ [Newtonsoft.Json.JsonProperty("mana")]
+ public short Mana { get; set; }
+ [Newtonsoft.Json.JsonProperty("hp")]
+ public short Hp { get; set; }
+ [Newtonsoft.Json.JsonProperty("name")]
+ public string Name { get; set; }
+ [Newtonsoft.Json.JsonProperty("inventory")]
+ public List<byte> Inventory { get; set; }
+ [Newtonsoft.Json.JsonProperty("color")]
+ public MyGame.Example.Color Color { get; set; }
+ [Newtonsoft.Json.JsonProperty("test_type")]
+ private MyGame.Example.Any TestType {
+ get {
+ return this.Test != null ? this.Test.Type : MyGame.Example.Any.NONE;
+ }
+ set {
+ this.Test = new MyGame.Example.AnyUnion();
+ this.Test.Type = value;
+ }
+ }
+ [Newtonsoft.Json.JsonProperty("test")]
+ [Newtonsoft.Json.JsonConverter(typeof(MyGame.Example.AnyUnion_JsonConverter))]
+ public MyGame.Example.AnyUnion Test { get; set; }
+ [Newtonsoft.Json.JsonProperty("test4")]
+ public List<MyGame.Example.TestT> Test4 { get; set; }
+ [Newtonsoft.Json.JsonProperty("testarrayofstring")]
+ public List<string> Testarrayofstring { get; set; }
+ [Newtonsoft.Json.JsonProperty("testarrayoftables")]
+ public List<MyGame.Example.MonsterT> Testarrayoftables { get; set; }
+ [Newtonsoft.Json.JsonProperty("enemy")]
+ public MyGame.Example.MonsterT Enemy { get; set; }
+ [Newtonsoft.Json.JsonProperty("testnestedflatbuffer")]
+ public List<byte> Testnestedflatbuffer { get; set; }
+ [Newtonsoft.Json.JsonProperty("testempty")]
+ public MyGame.Example.StatT Testempty { get; set; }
+ [Newtonsoft.Json.JsonProperty("testbool")]
+ public bool Testbool { get; set; }
+ [Newtonsoft.Json.JsonProperty("testhashs32_fnv1")]
+ [Newtonsoft.Json.JsonIgnore()]
+ public int Testhashs32Fnv1 { get; set; }
+ [Newtonsoft.Json.JsonProperty("testhashu32_fnv1")]
+ [Newtonsoft.Json.JsonIgnore()]
+ public uint Testhashu32Fnv1 { get; set; }
+ [Newtonsoft.Json.JsonProperty("testhashs64_fnv1")]
+ [Newtonsoft.Json.JsonIgnore()]
+ public long Testhashs64Fnv1 { get; set; }
+ [Newtonsoft.Json.JsonProperty("testhashu64_fnv1")]
+ [Newtonsoft.Json.JsonIgnore()]
+ public ulong Testhashu64Fnv1 { get; set; }
+ [Newtonsoft.Json.JsonProperty("testhashs32_fnv1a")]
+ [Newtonsoft.Json.JsonIgnore()]
+ public int Testhashs32Fnv1a { get; set; }
+ [Newtonsoft.Json.JsonProperty("testhashu32_fnv1a")]
+ [Newtonsoft.Json.JsonIgnore()]
+ public uint Testhashu32Fnv1a { get; set; }
+ [Newtonsoft.Json.JsonProperty("testhashs64_fnv1a")]
+ [Newtonsoft.Json.JsonIgnore()]
+ public long Testhashs64Fnv1a { get; set; }
+ [Newtonsoft.Json.JsonProperty("testhashu64_fnv1a")]
+ [Newtonsoft.Json.JsonIgnore()]
+ public ulong Testhashu64Fnv1a { get; set; }
+ [Newtonsoft.Json.JsonProperty("testarrayofbools")]
+ public List<bool> Testarrayofbools { get; set; }
+ [Newtonsoft.Json.JsonProperty("testf")]
+ public float Testf { get; set; }
+ [Newtonsoft.Json.JsonProperty("testf2")]
+ public float Testf2 { get; set; }
+ [Newtonsoft.Json.JsonProperty("testf3")]
+ public float Testf3 { get; set; }
+ [Newtonsoft.Json.JsonProperty("testarrayofstring2")]
+ public List<string> Testarrayofstring2 { get; set; }
+ [Newtonsoft.Json.JsonProperty("testarrayofsortedstruct")]
+ public List<MyGame.Example.AbilityT> Testarrayofsortedstruct { get; set; }
+ [Newtonsoft.Json.JsonProperty("flex")]
+ public List<byte> Flex { get; set; }
+ [Newtonsoft.Json.JsonProperty("test5")]
+ public List<MyGame.Example.TestT> Test5 { get; set; }
+ [Newtonsoft.Json.JsonProperty("vector_of_longs")]
+ public List<long> VectorOfLongs { get; set; }
+ [Newtonsoft.Json.JsonProperty("vector_of_doubles")]
+ public List<double> VectorOfDoubles { get; set; }
+ [Newtonsoft.Json.JsonProperty("parent_namespace_test")]
+ public MyGame.InParentNamespaceT ParentNamespaceTest { get; set; }
+ [Newtonsoft.Json.JsonProperty("vector_of_referrables")]
+ public List<MyGame.Example.ReferrableT> VectorOfReferrables { get; set; }
+ [Newtonsoft.Json.JsonProperty("single_weak_reference")]
+ [Newtonsoft.Json.JsonIgnore()]
+ public ulong SingleWeakReference { get; set; }
+ [Newtonsoft.Json.JsonProperty("vector_of_weak_references")]
+ [Newtonsoft.Json.JsonIgnore()]
+ public List<ulong> VectorOfWeakReferences { get; set; }
+ [Newtonsoft.Json.JsonProperty("vector_of_strong_referrables")]
+ public List<MyGame.Example.ReferrableT> VectorOfStrongReferrables { get; set; }
+ [Newtonsoft.Json.JsonProperty("co_owning_reference")]
+ [Newtonsoft.Json.JsonIgnore()]
+ public ulong CoOwningReference { get; set; }
+ [Newtonsoft.Json.JsonProperty("vector_of_co_owning_references")]
+ [Newtonsoft.Json.JsonIgnore()]
+ public List<ulong> VectorOfCoOwningReferences { get; set; }
+ [Newtonsoft.Json.JsonProperty("non_owning_reference")]
+ [Newtonsoft.Json.JsonIgnore()]
+ public ulong NonOwningReference { get; set; }
+ [Newtonsoft.Json.JsonProperty("vector_of_non_owning_references")]
+ [Newtonsoft.Json.JsonIgnore()]
+ public List<ulong> VectorOfNonOwningReferences { get; set; }
+ [Newtonsoft.Json.JsonProperty("any_unique_type")]
+ private MyGame.Example.AnyUniqueAliases AnyUniqueType {
+ get {
+ return this.AnyUnique != null ? this.AnyUnique.Type : MyGame.Example.AnyUniqueAliases.NONE;
+ }
+ set {
+ this.AnyUnique = new MyGame.Example.AnyUniqueAliasesUnion();
+ this.AnyUnique.Type = value;
+ }
+ }
+ [Newtonsoft.Json.JsonProperty("any_unique")]
+ [Newtonsoft.Json.JsonConverter(typeof(MyGame.Example.AnyUniqueAliasesUnion_JsonConverter))]
+ public MyGame.Example.AnyUniqueAliasesUnion AnyUnique { get; set; }
+ [Newtonsoft.Json.JsonProperty("any_ambiguous_type")]
+ private MyGame.Example.AnyAmbiguousAliases AnyAmbiguousType {
+ get {
+ return this.AnyAmbiguous != null ? this.AnyAmbiguous.Type : MyGame.Example.AnyAmbiguousAliases.NONE;
+ }
+ set {
+ this.AnyAmbiguous = new MyGame.Example.AnyAmbiguousAliasesUnion();
+ this.AnyAmbiguous.Type = value;
+ }
+ }
+ [Newtonsoft.Json.JsonProperty("any_ambiguous")]
+ [Newtonsoft.Json.JsonConverter(typeof(MyGame.Example.AnyAmbiguousAliasesUnion_JsonConverter))]
+ public MyGame.Example.AnyAmbiguousAliasesUnion AnyAmbiguous { get; set; }
+ [Newtonsoft.Json.JsonProperty("vector_of_enums")]
+ public List<MyGame.Example.Color> VectorOfEnums { get; set; }
+ [Newtonsoft.Json.JsonProperty("signed_enum")]
+ public MyGame.Example.Race SignedEnum { get; set; }
+ [Newtonsoft.Json.JsonProperty("testrequirednestedflatbuffer")]
+ public List<byte> Testrequirednestedflatbuffer { get; set; }
+
+ public MonsterT() {
+ this.Pos = new MyGame.Example.Vec3T();
+ this.Mana = 150;
+ this.Hp = 100;
+ this.Name = null;
+ this.Inventory = null;
+ this.Color = MyGame.Example.Color.Blue;
+ this.Test = null;
+ this.Test4 = null;
+ this.Testarrayofstring = null;
+ this.Testarrayoftables = null;
+ this.Enemy = null;
+ this.Testnestedflatbuffer = null;
+ this.Testempty = null;
+ this.Testbool = false;
+ this.Testhashs32Fnv1 = 0;
+ this.Testhashu32Fnv1 = 0;
+ this.Testhashs64Fnv1 = 0;
+ this.Testhashu64Fnv1 = 0;
+ this.Testhashs32Fnv1a = 0;
+ this.Testhashu32Fnv1a = 0;
+ this.Testhashs64Fnv1a = 0;
+ this.Testhashu64Fnv1a = 0;
+ this.Testarrayofbools = null;
+ this.Testf = 3.14159f;
+ this.Testf2 = 3.0f;
+ this.Testf3 = 0.0f;
+ this.Testarrayofstring2 = null;
+ this.Testarrayofsortedstruct = null;
+ this.Flex = null;
+ this.Test5 = null;
+ this.VectorOfLongs = null;
+ this.VectorOfDoubles = null;
+ this.ParentNamespaceTest = null;
+ this.VectorOfReferrables = null;
+ this.SingleWeakReference = 0;
+ this.VectorOfWeakReferences = null;
+ this.VectorOfStrongReferrables = null;
+ this.CoOwningReference = 0;
+ this.VectorOfCoOwningReferences = null;
+ this.NonOwningReference = 0;
+ this.VectorOfNonOwningReferences = null;
+ this.AnyUnique = null;
+ this.AnyAmbiguous = null;
+ this.VectorOfEnums = null;
+ this.SignedEnum = MyGame.Example.Race.None;
+ this.Testrequirednestedflatbuffer = null;
+ }
+
+ public static MonsterT DeserializeFromJson(string jsonText) {
+ return Newtonsoft.Json.JsonConvert.DeserializeObject<MonsterT>(jsonText);
+ }
+ public string SerializeToJson() {
+ return Newtonsoft.Json.JsonConvert.SerializeObject(this, Newtonsoft.Json.Formatting.Indented);
+ }
+ public static MonsterT DeserializeFromBinary(byte[] fbBuffer) {
+ return Monster.GetRootAsMonster(new ByteBuffer(fbBuffer)).UnPack();
+ }
+ public byte[] SerializeToBinary() {
+ var fbb = new FlatBufferBuilder(0x10000);
+ Monster.FinishMonsterBuffer(fbb, Monster.Pack(fbb, this));
+ return fbb.DataBuffer.ToSizedArray();
+ }
+}
+
}
diff --git a/tests/MyGame/Example/Monster.go b/tests/MyGame/Example/Monster.go
index dabb596..2ffe926 100644
--- a/tests/MyGame/Example/Monster.go
+++ b/tests/MyGame/Example/Monster.go
@@ -8,7 +8,436 @@
MyGame "MyGame"
)
-/// an example documentation comment: monster object
+/// an example documentation comment: "monster object"
+type MonsterT struct {
+ Pos *Vec3T
+ Mana int16
+ Hp int16
+ Name string
+ Inventory []byte
+ Color Color
+ Test *AnyT
+ Test4 []*TestT
+ Testarrayofstring []string
+ Testarrayoftables []*MonsterT
+ Enemy *MonsterT
+ Testnestedflatbuffer []byte
+ Testempty *StatT
+ Testbool bool
+ Testhashs32Fnv1 int32
+ Testhashu32Fnv1 uint32
+ Testhashs64Fnv1 int64
+ Testhashu64Fnv1 uint64
+ Testhashs32Fnv1a int32
+ Testhashu32Fnv1a uint32
+ Testhashs64Fnv1a int64
+ Testhashu64Fnv1a uint64
+ Testarrayofbools []bool
+ Testf float32
+ Testf2 float32
+ Testf3 float32
+ Testarrayofstring2 []string
+ Testarrayofsortedstruct []*AbilityT
+ Flex []byte
+ Test5 []*TestT
+ VectorOfLongs []int64
+ VectorOfDoubles []float64
+ ParentNamespaceTest *MyGame.InParentNamespaceT
+ VectorOfReferrables []*ReferrableT
+ SingleWeakReference uint64
+ VectorOfWeakReferences []uint64
+ VectorOfStrongReferrables []*ReferrableT
+ CoOwningReference uint64
+ VectorOfCoOwningReferences []uint64
+ NonOwningReference uint64
+ VectorOfNonOwningReferences []uint64
+ AnyUnique *AnyUniqueAliasesT
+ AnyAmbiguous *AnyAmbiguousAliasesT
+ VectorOfEnums []Color
+ SignedEnum Race
+ Testrequirednestedflatbuffer []byte
+}
+
+func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil { return 0 }
+ nameOffset := builder.CreateString(t.Name)
+ inventoryOffset := flatbuffers.UOffsetT(0)
+ if t.Inventory != nil {
+ inventoryOffset = builder.CreateByteString(t.Inventory)
+ }
+ testOffset := t.Test.Pack(builder)
+
+ test4Offset := flatbuffers.UOffsetT(0)
+ if t.Test4 != nil {
+ test4Length := len(t.Test4)
+ MonsterStartTest4Vector(builder, test4Length)
+ for j := test4Length - 1; j >= 0; j-- {
+ t.Test4[j].Pack(builder)
+ }
+ test4Offset = builder.EndVector(test4Length)
+ }
+ testarrayofstringOffset := flatbuffers.UOffsetT(0)
+ if t.Testarrayofstring != nil {
+ testarrayofstringLength := len(t.Testarrayofstring)
+ testarrayofstringOffsets := make([]flatbuffers.UOffsetT, testarrayofstringLength)
+ for j := 0; j < testarrayofstringLength; j++ {
+ testarrayofstringOffsets[j] = builder.CreateString(t.Testarrayofstring[j])
+ }
+ MonsterStartTestarrayofstringVector(builder, testarrayofstringLength)
+ for j := testarrayofstringLength - 1; j >= 0; j-- {
+ builder.PrependUOffsetT(testarrayofstringOffsets[j])
+ }
+ testarrayofstringOffset = builder.EndVector(testarrayofstringLength)
+ }
+ testarrayoftablesOffset := flatbuffers.UOffsetT(0)
+ if t.Testarrayoftables != nil {
+ testarrayoftablesLength := len(t.Testarrayoftables)
+ testarrayoftablesOffsets := make([]flatbuffers.UOffsetT, testarrayoftablesLength)
+ for j := 0; j < testarrayoftablesLength; j++ {
+ testarrayoftablesOffsets[j] = t.Testarrayoftables[j].Pack(builder)
+ }
+ MonsterStartTestarrayoftablesVector(builder, testarrayoftablesLength)
+ for j := testarrayoftablesLength - 1; j >= 0; j-- {
+ builder.PrependUOffsetT(testarrayoftablesOffsets[j])
+ }
+ testarrayoftablesOffset = builder.EndVector(testarrayoftablesLength)
+ }
+ enemyOffset := t.Enemy.Pack(builder)
+ testnestedflatbufferOffset := flatbuffers.UOffsetT(0)
+ if t.Testnestedflatbuffer != nil {
+ testnestedflatbufferOffset = builder.CreateByteString(t.Testnestedflatbuffer)
+ }
+ testemptyOffset := t.Testempty.Pack(builder)
+ testarrayofboolsOffset := flatbuffers.UOffsetT(0)
+ if t.Testarrayofbools != nil {
+ testarrayofboolsLength := len(t.Testarrayofbools)
+ MonsterStartTestarrayofboolsVector(builder, testarrayofboolsLength)
+ for j := testarrayofboolsLength - 1; j >= 0; j-- {
+ builder.PrependBool(t.Testarrayofbools[j])
+ }
+ testarrayofboolsOffset = builder.EndVector(testarrayofboolsLength)
+ }
+ testarrayofstring2Offset := flatbuffers.UOffsetT(0)
+ if t.Testarrayofstring2 != nil {
+ testarrayofstring2Length := len(t.Testarrayofstring2)
+ testarrayofstring2Offsets := make([]flatbuffers.UOffsetT, testarrayofstring2Length)
+ for j := 0; j < testarrayofstring2Length; j++ {
+ testarrayofstring2Offsets[j] = builder.CreateString(t.Testarrayofstring2[j])
+ }
+ MonsterStartTestarrayofstring2Vector(builder, testarrayofstring2Length)
+ for j := testarrayofstring2Length - 1; j >= 0; j-- {
+ builder.PrependUOffsetT(testarrayofstring2Offsets[j])
+ }
+ testarrayofstring2Offset = builder.EndVector(testarrayofstring2Length)
+ }
+ testarrayofsortedstructOffset := flatbuffers.UOffsetT(0)
+ if t.Testarrayofsortedstruct != nil {
+ testarrayofsortedstructLength := len(t.Testarrayofsortedstruct)
+ MonsterStartTestarrayofsortedstructVector(builder, testarrayofsortedstructLength)
+ for j := testarrayofsortedstructLength - 1; j >= 0; j-- {
+ t.Testarrayofsortedstruct[j].Pack(builder)
+ }
+ testarrayofsortedstructOffset = builder.EndVector(testarrayofsortedstructLength)
+ }
+ flexOffset := flatbuffers.UOffsetT(0)
+ if t.Flex != nil {
+ flexOffset = builder.CreateByteString(t.Flex)
+ }
+ test5Offset := flatbuffers.UOffsetT(0)
+ if t.Test5 != nil {
+ test5Length := len(t.Test5)
+ MonsterStartTest5Vector(builder, test5Length)
+ for j := test5Length - 1; j >= 0; j-- {
+ t.Test5[j].Pack(builder)
+ }
+ test5Offset = builder.EndVector(test5Length)
+ }
+ vectorOfLongsOffset := flatbuffers.UOffsetT(0)
+ if t.VectorOfLongs != nil {
+ vectorOfLongsLength := len(t.VectorOfLongs)
+ MonsterStartVectorOfLongsVector(builder, vectorOfLongsLength)
+ for j := vectorOfLongsLength - 1; j >= 0; j-- {
+ builder.PrependInt64(t.VectorOfLongs[j])
+ }
+ vectorOfLongsOffset = builder.EndVector(vectorOfLongsLength)
+ }
+ vectorOfDoublesOffset := flatbuffers.UOffsetT(0)
+ if t.VectorOfDoubles != nil {
+ vectorOfDoublesLength := len(t.VectorOfDoubles)
+ MonsterStartVectorOfDoublesVector(builder, vectorOfDoublesLength)
+ for j := vectorOfDoublesLength - 1; j >= 0; j-- {
+ builder.PrependFloat64(t.VectorOfDoubles[j])
+ }
+ vectorOfDoublesOffset = builder.EndVector(vectorOfDoublesLength)
+ }
+ parentNamespaceTestOffset := t.ParentNamespaceTest.Pack(builder)
+ vectorOfReferrablesOffset := flatbuffers.UOffsetT(0)
+ if t.VectorOfReferrables != nil {
+ vectorOfReferrablesLength := len(t.VectorOfReferrables)
+ vectorOfReferrablesOffsets := make([]flatbuffers.UOffsetT, vectorOfReferrablesLength)
+ for j := 0; j < vectorOfReferrablesLength; j++ {
+ vectorOfReferrablesOffsets[j] = t.VectorOfReferrables[j].Pack(builder)
+ }
+ MonsterStartVectorOfReferrablesVector(builder, vectorOfReferrablesLength)
+ for j := vectorOfReferrablesLength - 1; j >= 0; j-- {
+ builder.PrependUOffsetT(vectorOfReferrablesOffsets[j])
+ }
+ vectorOfReferrablesOffset = builder.EndVector(vectorOfReferrablesLength)
+ }
+ vectorOfWeakReferencesOffset := flatbuffers.UOffsetT(0)
+ if t.VectorOfWeakReferences != nil {
+ vectorOfWeakReferencesLength := len(t.VectorOfWeakReferences)
+ MonsterStartVectorOfWeakReferencesVector(builder, vectorOfWeakReferencesLength)
+ for j := vectorOfWeakReferencesLength - 1; j >= 0; j-- {
+ builder.PrependUint64(t.VectorOfWeakReferences[j])
+ }
+ vectorOfWeakReferencesOffset = builder.EndVector(vectorOfWeakReferencesLength)
+ }
+ vectorOfStrongReferrablesOffset := flatbuffers.UOffsetT(0)
+ if t.VectorOfStrongReferrables != nil {
+ vectorOfStrongReferrablesLength := len(t.VectorOfStrongReferrables)
+ vectorOfStrongReferrablesOffsets := make([]flatbuffers.UOffsetT, vectorOfStrongReferrablesLength)
+ for j := 0; j < vectorOfStrongReferrablesLength; j++ {
+ vectorOfStrongReferrablesOffsets[j] = t.VectorOfStrongReferrables[j].Pack(builder)
+ }
+ MonsterStartVectorOfStrongReferrablesVector(builder, vectorOfStrongReferrablesLength)
+ for j := vectorOfStrongReferrablesLength - 1; j >= 0; j-- {
+ builder.PrependUOffsetT(vectorOfStrongReferrablesOffsets[j])
+ }
+ vectorOfStrongReferrablesOffset = builder.EndVector(vectorOfStrongReferrablesLength)
+ }
+ vectorOfCoOwningReferencesOffset := flatbuffers.UOffsetT(0)
+ if t.VectorOfCoOwningReferences != nil {
+ vectorOfCoOwningReferencesLength := len(t.VectorOfCoOwningReferences)
+ MonsterStartVectorOfCoOwningReferencesVector(builder, vectorOfCoOwningReferencesLength)
+ for j := vectorOfCoOwningReferencesLength - 1; j >= 0; j-- {
+ builder.PrependUint64(t.VectorOfCoOwningReferences[j])
+ }
+ vectorOfCoOwningReferencesOffset = builder.EndVector(vectorOfCoOwningReferencesLength)
+ }
+ vectorOfNonOwningReferencesOffset := flatbuffers.UOffsetT(0)
+ if t.VectorOfNonOwningReferences != nil {
+ vectorOfNonOwningReferencesLength := len(t.VectorOfNonOwningReferences)
+ MonsterStartVectorOfNonOwningReferencesVector(builder, vectorOfNonOwningReferencesLength)
+ for j := vectorOfNonOwningReferencesLength - 1; j >= 0; j-- {
+ builder.PrependUint64(t.VectorOfNonOwningReferences[j])
+ }
+ 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)
+ MonsterStartVectorOfEnumsVector(builder, vectorOfEnumsLength)
+ for j := vectorOfEnumsLength - 1; j >= 0; j-- {
+ builder.PrependByte(byte(t.VectorOfEnums[j]))
+ }
+ vectorOfEnumsOffset = builder.EndVector(vectorOfEnumsLength)
+ }
+ testrequirednestedflatbufferOffset := flatbuffers.UOffsetT(0)
+ if t.Testrequirednestedflatbuffer != nil {
+ testrequirednestedflatbufferOffset = builder.CreateByteString(t.Testrequirednestedflatbuffer)
+ }
+ MonsterStart(builder)
+ posOffset := t.Pos.Pack(builder)
+ MonsterAddPos(builder, posOffset)
+ MonsterAddMana(builder, t.Mana)
+ MonsterAddHp(builder, t.Hp)
+ MonsterAddName(builder, nameOffset)
+ MonsterAddInventory(builder, inventoryOffset)
+ MonsterAddColor(builder, t.Color)
+ if t.Test != nil {
+ MonsterAddTestType(builder, t.Test.Type)
+ }
+ MonsterAddTest(builder, testOffset)
+ MonsterAddTest4(builder, test4Offset)
+ MonsterAddTestarrayofstring(builder, testarrayofstringOffset)
+ MonsterAddTestarrayoftables(builder, testarrayoftablesOffset)
+ MonsterAddEnemy(builder, enemyOffset)
+ MonsterAddTestnestedflatbuffer(builder, testnestedflatbufferOffset)
+ MonsterAddTestempty(builder, testemptyOffset)
+ MonsterAddTestbool(builder, t.Testbool)
+ MonsterAddTesthashs32Fnv1(builder, t.Testhashs32Fnv1)
+ MonsterAddTesthashu32Fnv1(builder, t.Testhashu32Fnv1)
+ MonsterAddTesthashs64Fnv1(builder, t.Testhashs64Fnv1)
+ MonsterAddTesthashu64Fnv1(builder, t.Testhashu64Fnv1)
+ MonsterAddTesthashs32Fnv1a(builder, t.Testhashs32Fnv1a)
+ MonsterAddTesthashu32Fnv1a(builder, t.Testhashu32Fnv1a)
+ MonsterAddTesthashs64Fnv1a(builder, t.Testhashs64Fnv1a)
+ MonsterAddTesthashu64Fnv1a(builder, t.Testhashu64Fnv1a)
+ MonsterAddTestarrayofbools(builder, testarrayofboolsOffset)
+ MonsterAddTestf(builder, t.Testf)
+ MonsterAddTestf2(builder, t.Testf2)
+ MonsterAddTestf3(builder, t.Testf3)
+ MonsterAddTestarrayofstring2(builder, testarrayofstring2Offset)
+ MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstructOffset)
+ MonsterAddFlex(builder, flexOffset)
+ MonsterAddTest5(builder, test5Offset)
+ MonsterAddVectorOfLongs(builder, vectorOfLongsOffset)
+ MonsterAddVectorOfDoubles(builder, vectorOfDoublesOffset)
+ MonsterAddParentNamespaceTest(builder, parentNamespaceTestOffset)
+ MonsterAddVectorOfReferrables(builder, vectorOfReferrablesOffset)
+ MonsterAddSingleWeakReference(builder, t.SingleWeakReference)
+ MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferencesOffset)
+ MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrablesOffset)
+ MonsterAddCoOwningReference(builder, t.CoOwningReference)
+ MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferencesOffset)
+ MonsterAddNonOwningReference(builder, t.NonOwningReference)
+ MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferencesOffset)
+ if t.AnyUnique != nil {
+ MonsterAddAnyUniqueType(builder, t.AnyUnique.Type)
+ }
+ MonsterAddAnyUnique(builder, anyUniqueOffset)
+ if t.AnyAmbiguous != nil {
+ MonsterAddAnyAmbiguousType(builder, t.AnyAmbiguous.Type)
+ }
+ MonsterAddAnyAmbiguous(builder, anyAmbiguousOffset)
+ MonsterAddVectorOfEnums(builder, vectorOfEnumsOffset)
+ MonsterAddSignedEnum(builder, t.SignedEnum)
+ MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbufferOffset)
+ return MonsterEnd(builder)
+}
+
+func (rcv *Monster) UnPackTo(t *MonsterT) {
+ t.Pos = rcv.Pos(nil).UnPack()
+ t.Mana = rcv.Mana()
+ t.Hp = rcv.Hp()
+ t.Name = string(rcv.Name())
+ t.Inventory = rcv.InventoryBytes()
+ t.Color = rcv.Color()
+ testTable := flatbuffers.Table{}
+ if rcv.Test(&testTable) {
+ t.Test = rcv.TestType().UnPack(testTable)
+ }
+ test4Length := rcv.Test4Length()
+ t.Test4 = make([]*TestT, test4Length)
+ for j := 0; j < test4Length; j++ {
+ x := Test{}
+ rcv.Test4(&x, j)
+ t.Test4[j] = x.UnPack()
+ }
+ testarrayofstringLength := rcv.TestarrayofstringLength()
+ t.Testarrayofstring = make([]string, testarrayofstringLength)
+ for j := 0; j < testarrayofstringLength; j++ {
+ t.Testarrayofstring[j] = string(rcv.Testarrayofstring(j))
+ }
+ testarrayoftablesLength := rcv.TestarrayoftablesLength()
+ t.Testarrayoftables = make([]*MonsterT, testarrayoftablesLength)
+ for j := 0; j < testarrayoftablesLength; j++ {
+ x := Monster{}
+ rcv.Testarrayoftables(&x, j)
+ t.Testarrayoftables[j] = x.UnPack()
+ }
+ t.Enemy = rcv.Enemy(nil).UnPack()
+ t.Testnestedflatbuffer = rcv.TestnestedflatbufferBytes()
+ t.Testempty = rcv.Testempty(nil).UnPack()
+ t.Testbool = rcv.Testbool()
+ t.Testhashs32Fnv1 = rcv.Testhashs32Fnv1()
+ t.Testhashu32Fnv1 = rcv.Testhashu32Fnv1()
+ t.Testhashs64Fnv1 = rcv.Testhashs64Fnv1()
+ t.Testhashu64Fnv1 = rcv.Testhashu64Fnv1()
+ t.Testhashs32Fnv1a = rcv.Testhashs32Fnv1a()
+ t.Testhashu32Fnv1a = rcv.Testhashu32Fnv1a()
+ t.Testhashs64Fnv1a = rcv.Testhashs64Fnv1a()
+ t.Testhashu64Fnv1a = rcv.Testhashu64Fnv1a()
+ testarrayofboolsLength := rcv.TestarrayofboolsLength()
+ t.Testarrayofbools = make([]bool, testarrayofboolsLength)
+ for j := 0; j < testarrayofboolsLength; j++ {
+ t.Testarrayofbools[j] = rcv.Testarrayofbools(j)
+ }
+ t.Testf = rcv.Testf()
+ t.Testf2 = rcv.Testf2()
+ t.Testf3 = rcv.Testf3()
+ testarrayofstring2Length := rcv.Testarrayofstring2Length()
+ t.Testarrayofstring2 = make([]string, testarrayofstring2Length)
+ for j := 0; j < testarrayofstring2Length; j++ {
+ t.Testarrayofstring2[j] = string(rcv.Testarrayofstring2(j))
+ }
+ testarrayofsortedstructLength := rcv.TestarrayofsortedstructLength()
+ t.Testarrayofsortedstruct = make([]*AbilityT, testarrayofsortedstructLength)
+ for j := 0; j < testarrayofsortedstructLength; j++ {
+ x := Ability{}
+ rcv.Testarrayofsortedstruct(&x, j)
+ t.Testarrayofsortedstruct[j] = x.UnPack()
+ }
+ t.Flex = rcv.FlexBytes()
+ test5Length := rcv.Test5Length()
+ t.Test5 = make([]*TestT, test5Length)
+ for j := 0; j < test5Length; j++ {
+ x := Test{}
+ rcv.Test5(&x, j)
+ t.Test5[j] = x.UnPack()
+ }
+ vectorOfLongsLength := rcv.VectorOfLongsLength()
+ t.VectorOfLongs = make([]int64, vectorOfLongsLength)
+ for j := 0; j < vectorOfLongsLength; j++ {
+ t.VectorOfLongs[j] = rcv.VectorOfLongs(j)
+ }
+ vectorOfDoublesLength := rcv.VectorOfDoublesLength()
+ t.VectorOfDoubles = make([]float64, vectorOfDoublesLength)
+ for j := 0; j < vectorOfDoublesLength; j++ {
+ t.VectorOfDoubles[j] = rcv.VectorOfDoubles(j)
+ }
+ t.ParentNamespaceTest = rcv.ParentNamespaceTest(nil).UnPack()
+ vectorOfReferrablesLength := rcv.VectorOfReferrablesLength()
+ t.VectorOfReferrables = make([]*ReferrableT, vectorOfReferrablesLength)
+ for j := 0; j < vectorOfReferrablesLength; j++ {
+ x := Referrable{}
+ rcv.VectorOfReferrables(&x, j)
+ t.VectorOfReferrables[j] = x.UnPack()
+ }
+ t.SingleWeakReference = rcv.SingleWeakReference()
+ vectorOfWeakReferencesLength := rcv.VectorOfWeakReferencesLength()
+ t.VectorOfWeakReferences = make([]uint64, vectorOfWeakReferencesLength)
+ for j := 0; j < vectorOfWeakReferencesLength; j++ {
+ t.VectorOfWeakReferences[j] = rcv.VectorOfWeakReferences(j)
+ }
+ vectorOfStrongReferrablesLength := rcv.VectorOfStrongReferrablesLength()
+ t.VectorOfStrongReferrables = make([]*ReferrableT, vectorOfStrongReferrablesLength)
+ for j := 0; j < vectorOfStrongReferrablesLength; j++ {
+ x := Referrable{}
+ rcv.VectorOfStrongReferrables(&x, j)
+ t.VectorOfStrongReferrables[j] = x.UnPack()
+ }
+ t.CoOwningReference = rcv.CoOwningReference()
+ vectorOfCoOwningReferencesLength := rcv.VectorOfCoOwningReferencesLength()
+ t.VectorOfCoOwningReferences = make([]uint64, vectorOfCoOwningReferencesLength)
+ for j := 0; j < vectorOfCoOwningReferencesLength; j++ {
+ t.VectorOfCoOwningReferences[j] = rcv.VectorOfCoOwningReferences(j)
+ }
+ t.NonOwningReference = rcv.NonOwningReference()
+ vectorOfNonOwningReferencesLength := rcv.VectorOfNonOwningReferencesLength()
+ t.VectorOfNonOwningReferences = make([]uint64, vectorOfNonOwningReferencesLength)
+ for j := 0; j < vectorOfNonOwningReferencesLength; j++ {
+ t.VectorOfNonOwningReferences[j] = rcv.VectorOfNonOwningReferences(j)
+ }
+ anyUniqueTable := flatbuffers.Table{}
+ if rcv.AnyUnique(&anyUniqueTable) {
+ t.AnyUnique = rcv.AnyUniqueType().UnPack(anyUniqueTable)
+ }
+ anyAmbiguousTable := flatbuffers.Table{}
+ if rcv.AnyAmbiguous(&anyAmbiguousTable) {
+ t.AnyAmbiguous = rcv.AnyAmbiguousType().UnPack(anyAmbiguousTable)
+ }
+ vectorOfEnumsLength := rcv.VectorOfEnumsLength()
+ t.VectorOfEnums = make([]Color, vectorOfEnumsLength)
+ for j := 0; j < vectorOfEnumsLength; j++ {
+ t.VectorOfEnums[j] = rcv.VectorOfEnums(j)
+ }
+ t.SignedEnum = rcv.SignedEnum()
+ t.Testrequirednestedflatbuffer = rcv.TestrequirednestedflatbufferBytes()
+}
+
+func (rcv *Monster) UnPack() *MonsterT {
+ if rcv == nil { return nil }
+ t := &MonsterT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
type Monster struct {
_tab flatbuffers.Table
}
@@ -20,6 +449,13 @@
return x
}
+func GetSizePrefixedRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Monster {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Monster{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
func (rcv *Monster) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
@@ -815,8 +1251,54 @@
return false
}
+func (rcv *Monster) SignedEnum() Race {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(100))
+ if o != 0 {
+ return Race(rcv._tab.GetInt8(o + rcv._tab.Pos))
+ }
+ return -1
+}
+
+func (rcv *Monster) MutateSignedEnum(n Race) bool {
+ return rcv._tab.MutateInt8Slot(100, int8(n))
+}
+
+func (rcv *Monster) Testrequirednestedflatbuffer(j int) byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(102))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
+ }
+ return 0
+}
+
+func (rcv *Monster) TestrequirednestedflatbufferLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(102))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func (rcv *Monster) TestrequirednestedflatbufferBytes() []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(102))
+ if o != 0 {
+ return rcv._tab.ByteVector(o + rcv._tab.Pos)
+ }
+ return nil
+}
+
+func (rcv *Monster) MutateTestrequirednestedflatbuffer(j int, n byte) bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(102))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n)
+ }
+ return false
+}
+
func MonsterStart(builder *flatbuffers.Builder) {
- builder.StartObject(48)
+ builder.StartObject(50)
}
func MonsterAddPos(builder *flatbuffers.Builder, pos flatbuffers.UOffsetT) {
builder.PrependStructSlot(0, flatbuffers.UOffsetT(pos), 0)
@@ -1013,6 +1495,15 @@
func MonsterStartVectorOfEnumsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
return builder.StartVector(1, numElems, 1)
}
+func MonsterAddSignedEnum(builder *flatbuffers.Builder, signedEnum Race) {
+ builder.PrependInt8Slot(48, int8(signedEnum), -1)
+}
+func MonsterAddTestrequirednestedflatbuffer(builder *flatbuffers.Builder, testrequirednestedflatbuffer flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(49, flatbuffers.UOffsetT(testrequirednestedflatbuffer), 0)
+}
+func MonsterStartTestrequirednestedflatbufferVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(1, numElems, 1)
+}
func MonsterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
diff --git a/tests/MyGame/Example/Monster.java b/tests/MyGame/Example/Monster.java
index 34d7983..c3cd1ca 100644
--- a/tests/MyGame/Example/Monster.java
+++ b/tests/MyGame/Example/Monster.java
@@ -7,12 +7,12 @@
import java.util.*;
import com.google.flatbuffers.*;
-@SuppressWarnings("unused")
/**
- * an example documentation comment: monster object
+ * an example documentation comment: "monster object"
*/
+@SuppressWarnings("unused")
public final class Monster extends Table {
- public static void ValidateVersion() { Constants.FLATBUFFERS_1_11_1(); }
+ public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
public static Monster getRootAsMonster(ByteBuffer _bb) { return getRootAsMonster(_bb, new Monster()); }
public static Monster getRootAsMonster(ByteBuffer _bb, Monster obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
public static boolean MonsterBufferHasIdentifier(ByteBuffer _bb) { return __has_identifier(_bb, "MONS"); }
@@ -30,19 +30,24 @@
public ByteBuffer nameInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 10, 1); }
public int inventory(int j) { int o = __offset(14); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; }
public int inventoryLength() { int o = __offset(14); return o != 0 ? __vector_len(o) : 0; }
+ public ByteVector inventoryVector() { return inventoryVector(new ByteVector()); }
+ public ByteVector inventoryVector(ByteVector obj) { int o = __offset(14); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
public ByteBuffer inventoryAsByteBuffer() { return __vector_as_bytebuffer(14, 1); }
public ByteBuffer inventoryInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 14, 1); }
public boolean mutateInventory(int j, int inventory) { int o = __offset(14); if (o != 0) { bb.put(__vector(o) + j * 1, (byte)inventory); return true; } else { return false; } }
public int color() { int o = __offset(16); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 8; }
public boolean mutateColor(int color) { int o = __offset(16); if (o != 0) { bb.put(o + bb_pos, (byte)color); return true; } else { return false; } }
public byte testType() { int o = __offset(18); return o != 0 ? bb.get(o + bb_pos) : 0; }
- public boolean mutateTestType(byte test_type) { int o = __offset(18); if (o != 0) { bb.put(o + bb_pos, test_type); return true; } else { return false; } }
- public Table test(Table obj) { int o = __offset(20); return o != 0 ? __union(obj, o) : null; }
+ public Table test(Table obj) { int o = __offset(20); return o != 0 ? __union(obj, o + bb_pos) : null; }
public MyGame.Example.Test test4(int j) { return test4(new MyGame.Example.Test(), j); }
public MyGame.Example.Test test4(MyGame.Example.Test obj, int j) { int o = __offset(22); return o != 0 ? obj.__assign(__vector(o) + j * 4, bb) : null; }
public int test4Length() { int o = __offset(22); return o != 0 ? __vector_len(o) : 0; }
+ public MyGame.Example.Test.Vector test4Vector() { return test4Vector(new MyGame.Example.Test.Vector()); }
+ public MyGame.Example.Test.Vector test4Vector(MyGame.Example.Test.Vector obj) { int o = __offset(22); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }
public String testarrayofstring(int j) { int o = __offset(24); return o != 0 ? __string(__vector(o) + j * 4) : null; }
public int testarrayofstringLength() { int o = __offset(24); return o != 0 ? __vector_len(o) : 0; }
+ public StringVector testarrayofstringVector() { return testarrayofstringVector(new StringVector()); }
+ public StringVector testarrayofstringVector(StringVector obj) { int o = __offset(24); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }
/**
* an example documentation comment: this will end up in the generated code
* multiline too
@@ -52,10 +57,14 @@
public int testarrayoftablesLength() { int o = __offset(26); return o != 0 ? __vector_len(o) : 0; }
public MyGame.Example.Monster testarrayoftablesByKey(String key) { int o = __offset(26); return o != 0 ? MyGame.Example.Monster.__lookup_by_key(null, __vector(o), key, bb) : null; }
public MyGame.Example.Monster testarrayoftablesByKey(MyGame.Example.Monster obj, String key) { int o = __offset(26); return o != 0 ? MyGame.Example.Monster.__lookup_by_key(obj, __vector(o), key, bb) : null; }
+ public MyGame.Example.Monster.Vector testarrayoftablesVector() { return testarrayoftablesVector(new MyGame.Example.Monster.Vector()); }
+ public MyGame.Example.Monster.Vector testarrayoftablesVector(MyGame.Example.Monster.Vector obj) { int o = __offset(26); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }
public MyGame.Example.Monster enemy() { return enemy(new MyGame.Example.Monster()); }
public MyGame.Example.Monster enemy(MyGame.Example.Monster obj) { int o = __offset(28); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; }
public int testnestedflatbuffer(int j) { int o = __offset(30); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; }
public int testnestedflatbufferLength() { int o = __offset(30); return o != 0 ? __vector_len(o) : 0; }
+ public ByteVector testnestedflatbufferVector() { return testnestedflatbufferVector(new ByteVector()); }
+ public ByteVector testnestedflatbufferVector(ByteVector obj) { int o = __offset(30); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
public ByteBuffer testnestedflatbufferAsByteBuffer() { return __vector_as_bytebuffer(30, 1); }
public ByteBuffer testnestedflatbufferInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 30, 1); }
public MyGame.Example.Monster testnestedflatbufferAsMonster() { return testnestedflatbufferAsMonster(new MyGame.Example.Monster()); }
@@ -83,6 +92,8 @@
public boolean mutateTesthashu64Fnv1a(long testhashu64_fnv1a) { int o = __offset(50); if (o != 0) { bb.putLong(o + bb_pos, testhashu64_fnv1a); return true; } else { return false; } }
public boolean testarrayofbools(int j) { int o = __offset(52); return o != 0 ? 0!=bb.get(__vector(o) + j * 1) : false; }
public int testarrayofboolsLength() { int o = __offset(52); return o != 0 ? __vector_len(o) : 0; }
+ public BooleanVector testarrayofboolsVector() { return testarrayofboolsVector(new BooleanVector()); }
+ public BooleanVector testarrayofboolsVector(BooleanVector obj) { int o = __offset(52); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
public ByteBuffer testarrayofboolsAsByteBuffer() { return __vector_as_bytebuffer(52, 1); }
public ByteBuffer testarrayofboolsInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 52, 1); }
public boolean mutateTestarrayofbools(int j, boolean testarrayofbools) { int o = __offset(52); if (o != 0) { bb.put(__vector(o) + j * 1, (byte)(testarrayofbools ? 1 : 0)); return true; } else { return false; } }
@@ -94,24 +105,36 @@
public boolean mutateTestf3(float testf3) { int o = __offset(58); if (o != 0) { bb.putFloat(o + bb_pos, testf3); return true; } else { return false; } }
public String testarrayofstring2(int j) { int o = __offset(60); return o != 0 ? __string(__vector(o) + j * 4) : null; }
public int testarrayofstring2Length() { int o = __offset(60); return o != 0 ? __vector_len(o) : 0; }
+ public StringVector testarrayofstring2Vector() { return testarrayofstring2Vector(new StringVector()); }
+ public StringVector testarrayofstring2Vector(StringVector obj) { int o = __offset(60); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }
public MyGame.Example.Ability testarrayofsortedstruct(int j) { return testarrayofsortedstruct(new MyGame.Example.Ability(), j); }
public MyGame.Example.Ability testarrayofsortedstruct(MyGame.Example.Ability obj, int j) { int o = __offset(62); return o != 0 ? obj.__assign(__vector(o) + j * 8, bb) : null; }
public int testarrayofsortedstructLength() { int o = __offset(62); return o != 0 ? __vector_len(o) : 0; }
+ public MyGame.Example.Ability.Vector testarrayofsortedstructVector() { return testarrayofsortedstructVector(new MyGame.Example.Ability.Vector()); }
+ public MyGame.Example.Ability.Vector testarrayofsortedstructVector(MyGame.Example.Ability.Vector obj) { int o = __offset(62); return o != 0 ? obj.__assign(__vector(o), 8, bb) : null; }
public int flex(int j) { int o = __offset(64); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; }
public int flexLength() { int o = __offset(64); return o != 0 ? __vector_len(o) : 0; }
+ public ByteVector flexVector() { return flexVector(new ByteVector()); }
+ public ByteVector flexVector(ByteVector obj) { int o = __offset(64); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
public ByteBuffer flexAsByteBuffer() { return __vector_as_bytebuffer(64, 1); }
public ByteBuffer flexInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 64, 1); }
public boolean mutateFlex(int j, int flex) { int o = __offset(64); if (o != 0) { bb.put(__vector(o) + j * 1, (byte)flex); return true; } else { return false; } }
public MyGame.Example.Test test5(int j) { return test5(new MyGame.Example.Test(), j); }
public MyGame.Example.Test test5(MyGame.Example.Test obj, int j) { int o = __offset(66); return o != 0 ? obj.__assign(__vector(o) + j * 4, bb) : null; }
public int test5Length() { int o = __offset(66); return o != 0 ? __vector_len(o) : 0; }
+ public MyGame.Example.Test.Vector test5Vector() { return test5Vector(new MyGame.Example.Test.Vector()); }
+ public MyGame.Example.Test.Vector test5Vector(MyGame.Example.Test.Vector obj) { int o = __offset(66); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }
public long vectorOfLongs(int j) { int o = __offset(68); return o != 0 ? bb.getLong(__vector(o) + j * 8) : 0; }
public int vectorOfLongsLength() { int o = __offset(68); return o != 0 ? __vector_len(o) : 0; }
+ public LongVector vectorOfLongsVector() { return vectorOfLongsVector(new LongVector()); }
+ public LongVector vectorOfLongsVector(LongVector obj) { int o = __offset(68); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
public ByteBuffer vectorOfLongsAsByteBuffer() { return __vector_as_bytebuffer(68, 8); }
public ByteBuffer vectorOfLongsInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 68, 8); }
public boolean mutateVectorOfLongs(int j, long vector_of_longs) { int o = __offset(68); if (o != 0) { bb.putLong(__vector(o) + j * 8, vector_of_longs); return true; } else { return false; } }
public double vectorOfDoubles(int j) { int o = __offset(70); return o != 0 ? bb.getDouble(__vector(o) + j * 8) : 0; }
public int vectorOfDoublesLength() { int o = __offset(70); return o != 0 ? __vector_len(o) : 0; }
+ public DoubleVector vectorOfDoublesVector() { return vectorOfDoublesVector(new DoubleVector()); }
+ public DoubleVector vectorOfDoublesVector(DoubleVector obj) { int o = __offset(70); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
public ByteBuffer vectorOfDoublesAsByteBuffer() { return __vector_as_bytebuffer(70, 8); }
public ByteBuffer vectorOfDoublesInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 70, 8); }
public boolean mutateVectorOfDoubles(int j, double vector_of_doubles) { int o = __offset(70); if (o != 0) { bb.putDouble(__vector(o) + j * 8, vector_of_doubles); return true; } else { return false; } }
@@ -122,10 +145,14 @@
public int vectorOfReferrablesLength() { int o = __offset(74); return o != 0 ? __vector_len(o) : 0; }
public MyGame.Example.Referrable vectorOfReferrablesByKey(long key) { int o = __offset(74); return o != 0 ? MyGame.Example.Referrable.__lookup_by_key(null, __vector(o), key, bb) : null; }
public MyGame.Example.Referrable vectorOfReferrablesByKey(MyGame.Example.Referrable obj, long key) { int o = __offset(74); return o != 0 ? MyGame.Example.Referrable.__lookup_by_key(obj, __vector(o), key, bb) : null; }
+ public MyGame.Example.Referrable.Vector vectorOfReferrablesVector() { return vectorOfReferrablesVector(new MyGame.Example.Referrable.Vector()); }
+ public MyGame.Example.Referrable.Vector vectorOfReferrablesVector(MyGame.Example.Referrable.Vector obj) { int o = __offset(74); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }
public long singleWeakReference() { int o = __offset(76); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
public boolean mutateSingleWeakReference(long single_weak_reference) { int o = __offset(76); if (o != 0) { bb.putLong(o + bb_pos, single_weak_reference); return true; } else { return false; } }
public long vectorOfWeakReferences(int j) { int o = __offset(78); return o != 0 ? bb.getLong(__vector(o) + j * 8) : 0; }
public int vectorOfWeakReferencesLength() { int o = __offset(78); return o != 0 ? __vector_len(o) : 0; }
+ public LongVector vectorOfWeakReferencesVector() { return vectorOfWeakReferencesVector(new LongVector()); }
+ public LongVector vectorOfWeakReferencesVector(LongVector obj) { int o = __offset(78); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
public ByteBuffer vectorOfWeakReferencesAsByteBuffer() { return __vector_as_bytebuffer(78, 8); }
public ByteBuffer vectorOfWeakReferencesInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 78, 8); }
public boolean mutateVectorOfWeakReferences(int j, long vector_of_weak_references) { int o = __offset(78); if (o != 0) { bb.putLong(__vector(o) + j * 8, vector_of_weak_references); return true; } else { return false; } }
@@ -134,10 +161,14 @@
public int vectorOfStrongReferrablesLength() { int o = __offset(80); return o != 0 ? __vector_len(o) : 0; }
public MyGame.Example.Referrable vectorOfStrongReferrablesByKey(long key) { int o = __offset(80); return o != 0 ? MyGame.Example.Referrable.__lookup_by_key(null, __vector(o), key, bb) : null; }
public MyGame.Example.Referrable vectorOfStrongReferrablesByKey(MyGame.Example.Referrable obj, long key) { int o = __offset(80); return o != 0 ? MyGame.Example.Referrable.__lookup_by_key(obj, __vector(o), key, bb) : null; }
+ public MyGame.Example.Referrable.Vector vectorOfStrongReferrablesVector() { return vectorOfStrongReferrablesVector(new MyGame.Example.Referrable.Vector()); }
+ public MyGame.Example.Referrable.Vector vectorOfStrongReferrablesVector(MyGame.Example.Referrable.Vector obj) { int o = __offset(80); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }
public long coOwningReference() { int o = __offset(82); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
public boolean mutateCoOwningReference(long co_owning_reference) { int o = __offset(82); if (o != 0) { bb.putLong(o + bb_pos, co_owning_reference); return true; } else { return false; } }
public long vectorOfCoOwningReferences(int j) { int o = __offset(84); return o != 0 ? bb.getLong(__vector(o) + j * 8) : 0; }
public int vectorOfCoOwningReferencesLength() { int o = __offset(84); return o != 0 ? __vector_len(o) : 0; }
+ public LongVector vectorOfCoOwningReferencesVector() { return vectorOfCoOwningReferencesVector(new LongVector()); }
+ public LongVector vectorOfCoOwningReferencesVector(LongVector obj) { int o = __offset(84); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
public ByteBuffer vectorOfCoOwningReferencesAsByteBuffer() { return __vector_as_bytebuffer(84, 8); }
public ByteBuffer vectorOfCoOwningReferencesInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 84, 8); }
public boolean mutateVectorOfCoOwningReferences(int j, long vector_of_co_owning_references) { int o = __offset(84); if (o != 0) { bb.putLong(__vector(o) + j * 8, vector_of_co_owning_references); return true; } else { return false; } }
@@ -145,28 +176,42 @@
public boolean mutateNonOwningReference(long non_owning_reference) { int o = __offset(86); if (o != 0) { bb.putLong(o + bb_pos, non_owning_reference); return true; } else { return false; } }
public long vectorOfNonOwningReferences(int j) { int o = __offset(88); return o != 0 ? bb.getLong(__vector(o) + j * 8) : 0; }
public int vectorOfNonOwningReferencesLength() { int o = __offset(88); return o != 0 ? __vector_len(o) : 0; }
+ public LongVector vectorOfNonOwningReferencesVector() { return vectorOfNonOwningReferencesVector(new LongVector()); }
+ public LongVector vectorOfNonOwningReferencesVector(LongVector obj) { int o = __offset(88); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
public ByteBuffer vectorOfNonOwningReferencesAsByteBuffer() { return __vector_as_bytebuffer(88, 8); }
public ByteBuffer vectorOfNonOwningReferencesInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 88, 8); }
public boolean mutateVectorOfNonOwningReferences(int j, long vector_of_non_owning_references) { int o = __offset(88); if (o != 0) { bb.putLong(__vector(o) + j * 8, vector_of_non_owning_references); return true; } else { return false; } }
public byte anyUniqueType() { int o = __offset(90); return o != 0 ? bb.get(o + bb_pos) : 0; }
- public boolean mutateAnyUniqueType(byte any_unique_type) { int o = __offset(90); if (o != 0) { bb.put(o + bb_pos, any_unique_type); return true; } else { return false; } }
- public Table anyUnique(Table obj) { int o = __offset(92); return o != 0 ? __union(obj, o) : null; }
+ public Table anyUnique(Table obj) { int o = __offset(92); return o != 0 ? __union(obj, o + bb_pos) : null; }
public byte anyAmbiguousType() { int o = __offset(94); return o != 0 ? bb.get(o + bb_pos) : 0; }
- public boolean mutateAnyAmbiguousType(byte any_ambiguous_type) { int o = __offset(94); if (o != 0) { bb.put(o + bb_pos, any_ambiguous_type); return true; } else { return false; } }
- public Table anyAmbiguous(Table obj) { int o = __offset(96); return o != 0 ? __union(obj, o) : null; }
+ public Table anyAmbiguous(Table obj) { int o = __offset(96); return o != 0 ? __union(obj, o + bb_pos) : null; }
public int vectorOfEnums(int j) { int o = __offset(98); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; }
public int vectorOfEnumsLength() { int o = __offset(98); return o != 0 ? __vector_len(o) : 0; }
+ public ByteVector vectorOfEnumsVector() { return vectorOfEnumsVector(new ByteVector()); }
+ public ByteVector vectorOfEnumsVector(ByteVector obj) { int o = __offset(98); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
public ByteBuffer vectorOfEnumsAsByteBuffer() { return __vector_as_bytebuffer(98, 1); }
public ByteBuffer vectorOfEnumsInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 98, 1); }
public boolean mutateVectorOfEnums(int j, int vector_of_enums) { int o = __offset(98); if (o != 0) { bb.put(__vector(o) + j * 1, (byte)vector_of_enums); return true; } else { return false; } }
+ public byte signedEnum() { int o = __offset(100); return o != 0 ? bb.get(o + bb_pos) : -1; }
+ public boolean mutateSignedEnum(byte signed_enum) { int o = __offset(100); if (o != 0) { bb.put(o + bb_pos, signed_enum); return true; } else { return false; } }
+ public int testrequirednestedflatbuffer(int j) { int o = __offset(102); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; }
+ public int testrequirednestedflatbufferLength() { int o = __offset(102); return o != 0 ? __vector_len(o) : 0; }
+ public ByteVector testrequirednestedflatbufferVector() { return testrequirednestedflatbufferVector(new ByteVector()); }
+ public ByteVector testrequirednestedflatbufferVector(ByteVector obj) { int o = __offset(102); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
+ public ByteBuffer testrequirednestedflatbufferAsByteBuffer() { return __vector_as_bytebuffer(102, 1); }
+ public ByteBuffer testrequirednestedflatbufferInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 102, 1); }
+ public MyGame.Example.Monster testrequirednestedflatbufferAsMonster() { return testrequirednestedflatbufferAsMonster(new MyGame.Example.Monster()); }
+ public MyGame.Example.Monster testrequirednestedflatbufferAsMonster(MyGame.Example.Monster obj) { int o = __offset(102); return o != 0 ? obj.__assign(__indirect(__vector(o)), bb) : null; }
+ public boolean mutateTestrequirednestedflatbuffer(int j, int testrequirednestedflatbuffer) { int o = __offset(102); if (o != 0) { bb.put(__vector(o) + j * 1, (byte)testrequirednestedflatbuffer); return true; } else { return false; } }
- public static void startMonster(FlatBufferBuilder builder) { builder.startTable(48); }
+ public static void startMonster(FlatBufferBuilder builder) { builder.startTable(50); }
public static void addPos(FlatBufferBuilder builder, int posOffset) { builder.addStruct(0, posOffset, 0); }
public static void addMana(FlatBufferBuilder builder, short mana) { builder.addShort(1, mana, 150); }
public static void addHp(FlatBufferBuilder builder, short hp) { builder.addShort(2, hp, 100); }
public static void addName(FlatBufferBuilder builder, int nameOffset) { builder.addOffset(3, nameOffset, 0); }
public static void addInventory(FlatBufferBuilder builder, int inventoryOffset) { builder.addOffset(5, inventoryOffset, 0); }
- public static int createInventoryVector(FlatBufferBuilder builder, byte[] data) { builder.startVector(1, data.length, 1); for (int i = data.length - 1; i >= 0; i--) builder.addByte(data[i]); return builder.endVector(); }
+ public static int createInventoryVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); }
+ public static int createInventoryVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); }
public static void startInventoryVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
public static void addColor(FlatBufferBuilder builder, int color) { builder.addByte(6, (byte)color, (byte)8); }
public static void addTestType(FlatBufferBuilder builder, byte testType) { builder.addByte(7, testType, 0); }
@@ -181,7 +226,8 @@
public static void startTestarrayoftablesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
public static void addEnemy(FlatBufferBuilder builder, int enemyOffset) { builder.addOffset(12, enemyOffset, 0); }
public static void addTestnestedflatbuffer(FlatBufferBuilder builder, int testnestedflatbufferOffset) { builder.addOffset(13, testnestedflatbufferOffset, 0); }
- public static int createTestnestedflatbufferVector(FlatBufferBuilder builder, byte[] data) { builder.startVector(1, data.length, 1); for (int i = data.length - 1; i >= 0; i--) builder.addByte(data[i]); return builder.endVector(); }
+ public static int createTestnestedflatbufferVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); }
+ public static int createTestnestedflatbufferVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); }
public static void startTestnestedflatbufferVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
public static void addTestempty(FlatBufferBuilder builder, int testemptyOffset) { builder.addOffset(14, testemptyOffset, 0); }
public static void addTestbool(FlatBufferBuilder builder, boolean testbool) { builder.addBoolean(15, testbool, false); }
@@ -205,7 +251,8 @@
public static void addTestarrayofsortedstruct(FlatBufferBuilder builder, int testarrayofsortedstructOffset) { builder.addOffset(29, testarrayofsortedstructOffset, 0); }
public static void startTestarrayofsortedstructVector(FlatBufferBuilder builder, int numElems) { builder.startVector(8, numElems, 4); }
public static void addFlex(FlatBufferBuilder builder, int flexOffset) { builder.addOffset(30, flexOffset, 0); }
- public static int createFlexVector(FlatBufferBuilder builder, byte[] data) { builder.startVector(1, data.length, 1); for (int i = data.length - 1; i >= 0; i--) builder.addByte(data[i]); return builder.endVector(); }
+ public static int createFlexVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); }
+ public static int createFlexVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); }
public static void startFlexVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
public static void addTest5(FlatBufferBuilder builder, int test5Offset) { builder.addOffset(31, test5Offset, 0); }
public static void startTest5Vector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 2); }
@@ -239,8 +286,14 @@
public static void addAnyAmbiguousType(FlatBufferBuilder builder, byte anyAmbiguousType) { builder.addByte(45, anyAmbiguousType, 0); }
public static void addAnyAmbiguous(FlatBufferBuilder builder, int anyAmbiguousOffset) { builder.addOffset(46, anyAmbiguousOffset, 0); }
public static void addVectorOfEnums(FlatBufferBuilder builder, int vectorOfEnumsOffset) { builder.addOffset(47, vectorOfEnumsOffset, 0); }
- public static int createVectorOfEnumsVector(FlatBufferBuilder builder, byte[] data) { builder.startVector(1, data.length, 1); for (int i = data.length - 1; i >= 0; i--) builder.addByte(data[i]); return builder.endVector(); }
+ public static int createVectorOfEnumsVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); }
+ public static int createVectorOfEnumsVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); }
public static void startVectorOfEnumsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
+ public static void addSignedEnum(FlatBufferBuilder builder, byte signedEnum) { builder.addByte(48, signedEnum, -1); }
+ public static void addTestrequirednestedflatbuffer(FlatBufferBuilder builder, int testrequirednestedflatbufferOffset) { builder.addOffset(49, testrequirednestedflatbufferOffset, 0); }
+ public static int createTestrequirednestedflatbufferVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); }
+ public static int createTestrequirednestedflatbufferVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); }
+ public static void startTestrequirednestedflatbufferVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
public static int endMonster(FlatBufferBuilder builder) {
int o = builder.endTable();
builder.required(o, 10); // name
@@ -253,7 +306,7 @@
protected int keysCompare(Integer o1, Integer o2, ByteBuffer _bb) { return compareStrings(__offset(10, o1, _bb), __offset(10, o2, _bb), _bb); }
public static Monster __lookup_by_key(Monster obj, int vectorLocation, String key, ByteBuffer bb) {
- byte[] byteKey = key.getBytes(Table.UTF8_CHARSET.get());
+ byte[] byteKey = key.getBytes(java.nio.charset.StandardCharsets.UTF_8);
int span = bb.getInt(vectorLocation - 4);
int start = 0;
while (span != 0) {
@@ -272,5 +325,14 @@
}
return null;
}
+
+ public static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+ public Monster get(int j) { return get(new Monster(), j); }
+ public Monster get(Monster obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); }
+ public Monster getByKey(String key) { return __lookup_by_key(null, __vector(), key, bb); }
+ public Monster getByKey(Monster obj, String key) { return __lookup_by_key(obj, __vector(), key, bb); }
+ }
}
diff --git a/tests/MyGame/Example/Monster.kt b/tests/MyGame/Example/Monster.kt
index 71d72b8..7b15138 100644
--- a/tests/MyGame/Example/Monster.kt
+++ b/tests/MyGame/Example/Monster.kt
@@ -7,7 +7,7 @@
import com.google.flatbuffers.*
/**
- * an example documentation comment: monster object
+ * an example documentation comment: "monster object"
*/
@Suppress("unused")
@ExperimentalUnsignedTypes
@@ -116,7 +116,7 @@
}
}
fun test(obj: Table) : Table? {
- val o = __offset(20); return if (o != 0) __union(obj, o) else null
+ val o = __offset(20); return if (o != 0) __union(obj, o + bb_pos) else null
}
fun test4(j: Int) : MyGame.Example.Test? = test4(MyGame.Example.Test(), j)
fun test4(obj: MyGame.Example.Test, j: Int) : MyGame.Example.Test? {
@@ -717,7 +717,7 @@
}
}
fun anyUnique(obj: Table) : Table? {
- val o = __offset(92); return if (o != 0) __union(obj, o) else null
+ val o = __offset(92); return if (o != 0) __union(obj, o + bb_pos) else null
}
val anyAmbiguousType : UByte
get() {
@@ -734,7 +734,7 @@
}
}
fun anyAmbiguous(obj: Table) : Table? {
- val o = __offset(96); return if (o != 0) __union(obj, o) else null
+ val o = __offset(96); return if (o != 0) __union(obj, o + bb_pos) else null
}
fun vectorOfEnums(j: Int) : UByte {
val o = __offset(98)
@@ -759,18 +759,64 @@
false
}
}
+ val signedEnum : Byte
+ get() {
+ val o = __offset(100)
+ return if(o != 0) bb.get(o + bb_pos) else -1
+ }
+ fun mutateSignedEnum(signedEnum: Byte) : Boolean {
+ val o = __offset(100)
+ return if (o != 0) {
+ bb.put(o + bb_pos, signedEnum)
+ true
+ } else {
+ false
+ }
+ }
+ fun testrequirednestedflatbuffer(j: Int) : UByte {
+ val o = __offset(102)
+ return if (o != 0) {
+ bb.get(__vector(o) + j * 1).toUByte()
+ } else {
+ 0u
+ }
+ }
+ val testrequirednestedflatbufferLength : Int
+ get() {
+ val o = __offset(102); return if (o != 0) __vector_len(o) else 0
+ }
+ val testrequirednestedflatbufferAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(102, 1)
+ fun testrequirednestedflatbufferInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 102, 1)
+ val testrequirednestedflatbufferAsMonster : MyGame.Example.Monster? get() = testrequirednestedflatbufferAsMonster(MyGame.Example.Monster())
+ fun testrequirednestedflatbufferAsMonster(obj: MyGame.Example.Monster) : MyGame.Example.Monster? {
+ val o = __offset(102)
+ return if (o != 0) {
+ obj.__assign(__indirect(__vector(o)), bb)
+ } else {
+ null
+ }
+ }
+ fun mutateTestrequirednestedflatbuffer(j: Int, testrequirednestedflatbuffer: UByte) : Boolean {
+ val o = __offset(102)
+ return if (o != 0) {
+ bb.put(__vector(o) + j * 1, testrequirednestedflatbuffer.toByte())
+ true
+ } else {
+ false
+ }
+ }
override fun keysCompare(o1: Int, o2: Int, _bb: ByteBuffer) : Int {
return compareStrings(__offset(10, o1, _bb), __offset(10, o2, _bb), _bb)
}
companion object {
- fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
+ fun validateVersion() = Constants.FLATBUFFERS_1_12_0()
fun getRootAsMonster(_bb: ByteBuffer): Monster = getRootAsMonster(_bb, Monster())
fun getRootAsMonster(_bb: ByteBuffer, obj: Monster): Monster {
_bb.order(ByteOrder.LITTLE_ENDIAN)
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
}
fun MonsterBufferHasIdentifier(_bb: ByteBuffer) : Boolean = __has_identifier(_bb, "MONS")
- fun startMonster(builder: FlatBufferBuilder) = builder.startTable(48)
+ fun startMonster(builder: FlatBufferBuilder) = builder.startTable(50)
fun addPos(builder: FlatBufferBuilder, pos: Int) = builder.addStruct(0, pos, 0)
fun addMana(builder: FlatBufferBuilder, mana: Short) = builder.addShort(1, mana, 150)
fun addHp(builder: FlatBufferBuilder, hp: Short) = builder.addShort(2, hp, 100)
@@ -941,6 +987,16 @@
return builder.endVector()
}
fun startVectorOfEnumsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1)
+ fun addSignedEnum(builder: FlatBufferBuilder, signedEnum: Byte) = builder.addByte(48, signedEnum, -1)
+ fun addTestrequirednestedflatbuffer(builder: FlatBufferBuilder, testrequirednestedflatbuffer: Int) = builder.addOffset(49, testrequirednestedflatbuffer, 0)
+ fun createTestrequirednestedflatbufferVector(builder: FlatBufferBuilder, data: UByteArray) : Int {
+ builder.startVector(1, data.size, 1)
+ for (i in data.size - 1 downTo 0) {
+ builder.addByte(data[i].toByte())
+ }
+ return builder.endVector()
+ }
+ fun startTestrequirednestedflatbufferVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1)
fun endMonster(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
builder.required(o, 10)
@@ -949,7 +1005,7 @@
fun finishMonsterBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finish(offset, "MONS")
fun finishSizePrefixedMonsterBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finishSizePrefixed(offset, "MONS")
fun __lookup_by_key(obj: Monster?, vectorLocation: Int, key: String, bb: ByteBuffer) : Monster? {
- val byteKey = key.toByteArray(Table.UTF8_CHARSET.get()!!)
+ val byteKey = key.toByteArray(java.nio.charset.StandardCharsets.UTF_8)
var span = bb.getInt(vectorLocation - 4)
var start = 0
while (span != 0) {
diff --git a/tests/MyGame/Example/Monster.lua b/tests/MyGame/Example/Monster.lua
index 130c903..78ae4a5 100644
--- a/tests/MyGame/Example/Monster.lua
+++ b/tests/MyGame/Example/Monster.lua
@@ -4,7 +4,7 @@
local flatbuffers = require('flatbuffers')
--- an example documentation comment: monster object
+-- an example documentation comment: "monster object"
local Monster = {} -- the module
local Monster_mt = {} -- the class metatable
@@ -522,7 +522,29 @@
end
return 0
end
-function Monster.Start(builder) builder:StartObject(48) end
+function Monster_mt:SignedEnum()
+ local o = self.view:Offset(100)
+ if o ~= 0 then
+ return self.view:Get(flatbuffers.N.Int8, o + self.view.pos)
+ end
+ return -1
+end
+function Monster_mt:Testrequirednestedflatbuffer(j)
+ local o = self.view:Offset(102)
+ if o ~= 0 then
+ local a = self.view:Vector(o)
+ return self.view:Get(flatbuffers.N.Uint8, a + ((j-1) * 1))
+ end
+ return 0
+end
+function Monster_mt:TestrequirednestedflatbufferLength()
+ local o = self.view:Offset(102)
+ if o ~= 0 then
+ return self.view:VectorLen(o)
+ end
+ return 0
+end
+function Monster.Start(builder) builder:StartObject(50) end
function Monster.AddPos(builder, pos) builder:PrependStructSlot(0, pos, 0) end
function Monster.AddMana(builder, mana) builder:PrependInt16Slot(1, mana, 150) end
function Monster.AddHp(builder, hp) builder:PrependInt16Slot(2, hp, 100) end
@@ -588,6 +610,9 @@
function Monster.AddAnyAmbiguous(builder, anyAmbiguous) builder:PrependUOffsetTRelativeSlot(46, anyAmbiguous, 0) end
function Monster.AddVectorOfEnums(builder, vectorOfEnums) builder:PrependUOffsetTRelativeSlot(47, vectorOfEnums, 0) end
function Monster.StartVectorOfEnumsVector(builder, numElems) return builder:StartVector(1, numElems, 1) end
+function Monster.AddSignedEnum(builder, signedEnum) builder:PrependInt8Slot(48, signedEnum, -1) end
+function Monster.AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer) builder:PrependUOffsetTRelativeSlot(49, testrequirednestedflatbuffer, 0) end
+function Monster.StartTestrequirednestedflatbufferVector(builder, numElems) return builder:StartVector(1, numElems, 1) end
function Monster.End(builder) return builder:EndObject() end
return Monster -- return the module
\ No newline at end of file
diff --git a/tests/MyGame/Example/Monster.php b/tests/MyGame/Example/Monster.php
index 7d6de87b..21e27dc 100644
--- a/tests/MyGame/Example/Monster.php
+++ b/tests/MyGame/Example/Monster.php
@@ -8,7 +8,7 @@
use \Google\FlatBuffers\ByteBuffer;
use \Google\FlatBuffers\FlatBufferBuilder;
-/// an example documentation comment: monster object
+/// an example documentation comment: "monster object"
class Monster extends Table
{
/**
@@ -675,21 +675,57 @@
}
/**
+ * @return sbyte
+ */
+ public function getSignedEnum()
+ {
+ $o = $this->__offset(100);
+ return $o != 0 ? $this->bb->getSbyte($o + $this->bb_pos) : \MyGame\Example\Race::None;
+ }
+
+ /**
+ * @param int offset
+ * @return byte
+ */
+ public function getTestrequirednestedflatbuffer($j)
+ {
+ $o = $this->__offset(102);
+ return $o != 0 ? $this->bb->getByte($this->__vector($o) + $j * 1) : 0;
+ }
+
+ /**
+ * @return int
+ */
+ public function getTestrequirednestedflatbufferLength()
+ {
+ $o = $this->__offset(102);
+ return $o != 0 ? $this->__vector_len($o) : 0;
+ }
+
+ /**
+ * @return string
+ */
+ public function getTestrequirednestedflatbufferBytes()
+ {
+ return $this->__vector_as_bytes(102);
+ }
+
+ /**
* @param FlatBufferBuilder $builder
* @return void
*/
public static function startMonster(FlatBufferBuilder $builder)
{
- $builder->StartObject(48);
+ $builder->StartObject(50);
}
/**
* @param FlatBufferBuilder $builder
* @return Monster
*/
- public static function createMonster(FlatBufferBuilder $builder, $pos, $mana, $hp, $name, $inventory, $color, $test_type, $test, $test4, $testarrayofstring, $testarrayoftables, $enemy, $testnestedflatbuffer, $testempty, $testbool, $testhashs32_fnv1, $testhashu32_fnv1, $testhashs64_fnv1, $testhashu64_fnv1, $testhashs32_fnv1a, $testhashu32_fnv1a, $testhashs64_fnv1a, $testhashu64_fnv1a, $testarrayofbools, $testf, $testf2, $testf3, $testarrayofstring2, $testarrayofsortedstruct, $flex, $test5, $vector_of_longs, $vector_of_doubles, $parent_namespace_test, $vector_of_referrables, $single_weak_reference, $vector_of_weak_references, $vector_of_strong_referrables, $co_owning_reference, $vector_of_co_owning_references, $non_owning_reference, $vector_of_non_owning_references, $any_unique_type, $any_unique, $any_ambiguous_type, $any_ambiguous, $vector_of_enums)
+ public static function createMonster(FlatBufferBuilder $builder, $pos, $mana, $hp, $name, $inventory, $color, $test_type, $test, $test4, $testarrayofstring, $testarrayoftables, $enemy, $testnestedflatbuffer, $testempty, $testbool, $testhashs32_fnv1, $testhashu32_fnv1, $testhashs64_fnv1, $testhashu64_fnv1, $testhashs32_fnv1a, $testhashu32_fnv1a, $testhashs64_fnv1a, $testhashu64_fnv1a, $testarrayofbools, $testf, $testf2, $testf3, $testarrayofstring2, $testarrayofsortedstruct, $flex, $test5, $vector_of_longs, $vector_of_doubles, $parent_namespace_test, $vector_of_referrables, $single_weak_reference, $vector_of_weak_references, $vector_of_strong_referrables, $co_owning_reference, $vector_of_co_owning_references, $non_owning_reference, $vector_of_non_owning_references, $any_unique_type, $any_unique, $any_ambiguous_type, $any_ambiguous, $vector_of_enums, $signed_enum, $testrequirednestedflatbuffer)
{
- $builder->startObject(48);
+ $builder->startObject(50);
self::addPos($builder, $pos);
self::addMana($builder, $mana);
self::addHp($builder, $hp);
@@ -737,6 +773,8 @@
self::addAnyAmbiguousType($builder, $any_ambiguous_type);
self::addAnyAmbiguous($builder, $any_ambiguous);
self::addVectorOfEnums($builder, $vector_of_enums);
+ self::addSignedEnum($builder, $signed_enum);
+ self::addTestrequirednestedflatbuffer($builder, $testrequirednestedflatbuffer);
$o = $builder->endObject();
$builder->required($o, 10); // name
return $o;
@@ -1631,6 +1669,50 @@
/**
* @param FlatBufferBuilder $builder
+ * @param sbyte
+ * @return void
+ */
+ public static function addSignedEnum(FlatBufferBuilder $builder, $signedEnum)
+ {
+ $builder->addSbyteX(48, $signedEnum, -1);
+ }
+
+ /**
+ * @param FlatBufferBuilder $builder
+ * @param VectorOffset
+ * @return void
+ */
+ public static function addTestrequirednestedflatbuffer(FlatBufferBuilder $builder, $testrequirednestedflatbuffer)
+ {
+ $builder->addOffsetX(49, $testrequirednestedflatbuffer, 0);
+ }
+
+ /**
+ * @param FlatBufferBuilder $builder
+ * @param array offset array
+ * @return int vector offset
+ */
+ public static function createTestrequirednestedflatbufferVector(FlatBufferBuilder $builder, array $data)
+ {
+ $builder->startVector(1, count($data), 1);
+ for ($i = count($data) - 1; $i >= 0; $i--) {
+ $builder->putByte($data[$i]);
+ }
+ return $builder->endVector();
+ }
+
+ /**
+ * @param FlatBufferBuilder $builder
+ * @param int $numElems
+ * @return void
+ */
+ public static function startTestrequirednestedflatbufferVector(FlatBufferBuilder $builder, $numElems)
+ {
+ $builder->startVector(1, $numElems, 1);
+ }
+
+ /**
+ * @param FlatBufferBuilder $builder
* @return int table offset
*/
public static function endMonster(FlatBufferBuilder $builder)
diff --git a/tests/MyGame/Example/Monster.py b/tests/MyGame/Example/Monster.py
index 5baf64d..67f6e1b 100644
--- a/tests/MyGame/Example/Monster.py
+++ b/tests/MyGame/Example/Monster.py
@@ -3,8 +3,10 @@
# namespace: Example
import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
-# an example documentation comment: monster object
+# an example documentation comment: "monster object"
class Monster(object):
__slots__ = ['_tab']
@@ -28,7 +30,7 @@
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
x = o + self._tab.Pos
- from .Vec3 import Vec3
+ from MyGame.Example.Vec3 import Vec3
obj = Vec3()
obj.Init(self._tab.Bytes, x)
return obj
@@ -78,6 +80,11 @@
return 0
# Monster
+ def InventoryIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+ return o == 0
+
+ # Monster
def Color(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
if o != 0:
@@ -107,7 +114,7 @@
if o != 0:
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
- from .Test import Test
+ from MyGame.Example.Test import Test
obj = Test()
obj.Init(self._tab.Bytes, x)
return obj
@@ -121,6 +128,11 @@
return 0
# Monster
+ def Test4IsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+ return o == 0
+
+ # Monster
def Testarrayofstring(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
if o != 0:
@@ -135,6 +147,11 @@
return self._tab.VectorLen(o)
return 0
+ # Monster
+ def TestarrayofstringIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+ return o == 0
+
# an example documentation comment: this will end up in the generated code
# multiline too
# Monster
@@ -144,7 +161,7 @@
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
x = self._tab.Indirect(x)
- from .Monster import Monster
+ from MyGame.Example.Monster import Monster
obj = Monster()
obj.Init(self._tab.Bytes, x)
return obj
@@ -158,11 +175,16 @@
return 0
# Monster
+ def TestarrayoftablesIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+ return o == 0
+
+ # Monster
def Enemy(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
- from .Monster import Monster
+ from MyGame.Example.Monster import Monster
obj = Monster()
obj.Init(self._tab.Bytes, x)
return obj
@@ -191,11 +213,16 @@
return 0
# Monster
+ def TestnestedflatbufferIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+ return o == 0
+
+ # Monster
def Testempty(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
- from .Stat import Stat
+ from MyGame.Example.Stat import Stat
obj = Stat()
obj.Init(self._tab.Bytes, x)
return obj
@@ -287,6 +314,11 @@
return 0
# Monster
+ def TestarrayofboolsIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
+ return o == 0
+
+ # Monster
def Testf(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
if o != 0:
@@ -323,12 +355,17 @@
return 0
# Monster
+ def Testarrayofstring2IsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
+ return o == 0
+
+ # Monster
def Testarrayofsortedstruct(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
if o != 0:
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
- from .Ability import Ability
+ from MyGame.Example.Ability import Ability
obj = Ability()
obj.Init(self._tab.Bytes, x)
return obj
@@ -342,6 +379,11 @@
return 0
# Monster
+ def TestarrayofsortedstructIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
+ return o == 0
+
+ # Monster
def Flex(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
if o != 0:
@@ -364,12 +406,17 @@
return 0
# Monster
+ def FlexIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
+ return o == 0
+
+ # Monster
def Test5(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
if o != 0:
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
- from .Test import Test
+ from MyGame.Example.Test import Test
obj = Test()
obj.Init(self._tab.Bytes, x)
return obj
@@ -383,6 +430,11 @@
return 0
# Monster
+ def Test5IsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
+ return o == 0
+
+ # Monster
def VectorOfLongs(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
if o != 0:
@@ -405,6 +457,11 @@
return 0
# Monster
+ def VectorOfLongsIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
+ return o == 0
+
+ # Monster
def VectorOfDoubles(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
if o != 0:
@@ -427,11 +484,16 @@
return 0
# Monster
+ def VectorOfDoublesIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
+ return o == 0
+
+ # Monster
def ParentNamespaceTest(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
- from .InParentNamespace import InParentNamespace
+ from MyGame.InParentNamespace import InParentNamespace
obj = InParentNamespace()
obj.Init(self._tab.Bytes, x)
return obj
@@ -444,7 +506,7 @@
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
x = self._tab.Indirect(x)
- from .Referrable import Referrable
+ from MyGame.Example.Referrable import Referrable
obj = Referrable()
obj.Init(self._tab.Bytes, x)
return obj
@@ -458,6 +520,11 @@
return 0
# Monster
+ def VectorOfReferrablesIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
+ return o == 0
+
+ # Monster
def SingleWeakReference(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(76))
if o != 0:
@@ -487,13 +554,18 @@
return 0
# Monster
+ def VectorOfWeakReferencesIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
+ return o == 0
+
+ # Monster
def VectorOfStrongReferrables(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
if o != 0:
x = self._tab.Vector(o)
x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
x = self._tab.Indirect(x)
- from .Referrable import Referrable
+ from MyGame.Example.Referrable import Referrable
obj = Referrable()
obj.Init(self._tab.Bytes, x)
return obj
@@ -507,6 +579,11 @@
return 0
# Monster
+ def VectorOfStrongReferrablesIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
+ return o == 0
+
+ # Monster
def CoOwningReference(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(82))
if o != 0:
@@ -536,6 +613,11 @@
return 0
# Monster
+ def VectorOfCoOwningReferencesIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
+ return o == 0
+
+ # Monster
def NonOwningReference(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(86))
if o != 0:
@@ -565,6 +647,11 @@
return 0
# Monster
+ def VectorOfNonOwningReferencesIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
+ return o == 0
+
+ # Monster
def AnyUniqueType(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
if o != 0:
@@ -620,7 +707,46 @@
return self._tab.VectorLen(o)
return 0
-def MonsterStart(builder): builder.StartObject(48)
+ # Monster
+ def VectorOfEnumsIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
+ return o == 0
+
+ # Monster
+ def SignedEnum(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return -1
+
+ # Monster
+ def Testrequirednestedflatbuffer(self, j):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
+ if o != 0:
+ a = self._tab.Vector(o)
+ return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+ return 0
+
+ # Monster
+ def TestrequirednestedflatbufferAsNumpy(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
+ if o != 0:
+ return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+ return 0
+
+ # Monster
+ def TestrequirednestedflatbufferLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # Monster
+ def TestrequirednestedflatbufferIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
+ return o == 0
+
+def MonsterStart(builder): builder.StartObject(50)
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)
@@ -686,4 +812,501 @@
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 MonsterEnd(builder): return builder.EndObject()
+
+import MyGame.Example.Ability
+import MyGame.Example.Any
+import MyGame.Example.AnyAmbiguousAliases
+import MyGame.Example.AnyUniqueAliases
+import MyGame.Example.Referrable
+import MyGame.Example.Stat
+import MyGame.Example.Test
+import MyGame.Example.TestSimpleTableWithEnum
+import MyGame.Example.Vec3
+import MyGame.Example2.Monster
+import MyGame.InParentNamespace
+try:
+ from typing import List, Optional, Union
+except:
+ pass
+
+class MonsterT(object):
+
+ # MonsterT
+ def __init__(self):
+ self.pos = None # type: Optional[MyGame.Example.Vec3.Vec3T]
+ self.mana = 150 # type: int
+ self.hp = 100 # type: int
+ self.name = None # type: str
+ self.inventory = None # type: List[int]
+ self.color = 8 # type: int
+ self.testType = 0 # type: int
+ self.test = None # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.TestSimpleTableWithEnum.TestSimpleTableWithEnumT, MyGame.Example2.Monster.MonsterT]
+ self.test4 = None # type: List[MyGame.Example.Test.TestT]
+ self.testarrayofstring = None # type: List[str]
+ self.testarrayoftables = None # type: List[MyGame.Example.Monster.MonsterT]
+ self.enemy = None # type: Optional[MyGame.Example.Monster.MonsterT]
+ self.testnestedflatbuffer = None # type: List[int]
+ self.testempty = None # type: Optional[MyGame.Example.Stat.StatT]
+ self.testbool = False # type: bool
+ self.testhashs32Fnv1 = 0 # type: int
+ self.testhashu32Fnv1 = 0 # type: int
+ self.testhashs64Fnv1 = 0 # type: int
+ self.testhashu64Fnv1 = 0 # type: int
+ self.testhashs32Fnv1a = 0 # type: int
+ self.testhashu32Fnv1a = 0 # type: int
+ self.testhashs64Fnv1a = 0 # type: int
+ self.testhashu64Fnv1a = 0 # type: int
+ self.testarrayofbools = None # type: List[bool]
+ self.testf = 3.14159 # type: float
+ self.testf2 = 3.0 # type: float
+ self.testf3 = 0.0 # type: float
+ self.testarrayofstring2 = None # type: List[str]
+ self.testarrayofsortedstruct = None # type: List[MyGame.Example.Ability.AbilityT]
+ self.flex = None # type: List[int]
+ self.test5 = None # type: List[MyGame.Example.Test.TestT]
+ self.vectorOfLongs = None # type: List[int]
+ self.vectorOfDoubles = None # type: List[float]
+ self.parentNamespaceTest = None # type: Optional[MyGame.InParentNamespace.InParentNamespaceT]
+ self.vectorOfReferrables = None # type: List[MyGame.Example.Referrable.ReferrableT]
+ self.singleWeakReference = 0 # type: int
+ self.vectorOfWeakReferences = None # type: List[int]
+ self.vectorOfStrongReferrables = None # type: List[MyGame.Example.Referrable.ReferrableT]
+ self.coOwningReference = 0 # type: int
+ self.vectorOfCoOwningReferences = None # type: List[int]
+ self.nonOwningReference = 0 # type: int
+ self.vectorOfNonOwningReferences = None # type: List[int]
+ self.anyUniqueType = 0 # type: int
+ self.anyUnique = None # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.TestSimpleTableWithEnum.TestSimpleTableWithEnumT, MyGame.Example2.Monster.MonsterT]
+ self.anyAmbiguousType = 0 # type: int
+ self.anyAmbiguous = None # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.Monster.MonsterT, MyGame.Example.Monster.MonsterT]
+ self.vectorOfEnums = None # type: List[int]
+ self.signedEnum = -1 # type: int
+ self.testrequirednestedflatbuffer = None # type: List[int]
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ monster = Monster()
+ monster.Init(buf, pos)
+ return cls.InitFromObj(monster)
+
+ @classmethod
+ def InitFromObj(cls, monster):
+ x = MonsterT()
+ x._UnPack(monster)
+ return x
+
+ # MonsterT
+ def _UnPack(self, monster):
+ if monster is None:
+ return
+ if monster.Pos() is not None:
+ self.pos = MyGame.Example.Vec3.Vec3T.InitFromObj(monster.Pos())
+ self.mana = monster.Mana()
+ self.hp = monster.Hp()
+ self.name = monster.Name()
+ if not monster.InventoryIsNone():
+ if np is None:
+ self.inventory = []
+ for i in range(monster.InventoryLength()):
+ self.inventory.append(monster.Inventory(i))
+ else:
+ self.inventory = monster.InventoryAsNumpy()
+ self.color = monster.Color()
+ self.testType = monster.TestType()
+ self.test = MyGame.Example.Any.AnyCreator(self.testType, monster.Test())
+ if not monster.Test4IsNone():
+ self.test4 = []
+ for i in range(monster.Test4Length()):
+ if monster.Test4(i) is None:
+ self.test4.append(None)
+ else:
+ test_ = MyGame.Example.Test.TestT.InitFromObj(monster.Test4(i))
+ self.test4.append(test_)
+ if not monster.TestarrayofstringIsNone():
+ self.testarrayofstring = []
+ for i in range(monster.TestarrayofstringLength()):
+ self.testarrayofstring.append(monster.Testarrayofstring(i))
+ if not monster.TestarrayoftablesIsNone():
+ self.testarrayoftables = []
+ for i in range(monster.TestarrayoftablesLength()):
+ if monster.Testarrayoftables(i) is None:
+ self.testarrayoftables.append(None)
+ else:
+ monster_ = MyGame.Example.Monster.MonsterT.InitFromObj(monster.Testarrayoftables(i))
+ self.testarrayoftables.append(monster_)
+ if monster.Enemy() is not None:
+ self.enemy = MyGame.Example.Monster.MonsterT.InitFromObj(monster.Enemy())
+ if not monster.TestnestedflatbufferIsNone():
+ if np is None:
+ self.testnestedflatbuffer = []
+ for i in range(monster.TestnestedflatbufferLength()):
+ self.testnestedflatbuffer.append(monster.Testnestedflatbuffer(i))
+ else:
+ self.testnestedflatbuffer = monster.TestnestedflatbufferAsNumpy()
+ if monster.Testempty() is not None:
+ self.testempty = MyGame.Example.Stat.StatT.InitFromObj(monster.Testempty())
+ self.testbool = monster.Testbool()
+ self.testhashs32Fnv1 = monster.Testhashs32Fnv1()
+ self.testhashu32Fnv1 = monster.Testhashu32Fnv1()
+ self.testhashs64Fnv1 = monster.Testhashs64Fnv1()
+ self.testhashu64Fnv1 = monster.Testhashu64Fnv1()
+ self.testhashs32Fnv1a = monster.Testhashs32Fnv1a()
+ self.testhashu32Fnv1a = monster.Testhashu32Fnv1a()
+ self.testhashs64Fnv1a = monster.Testhashs64Fnv1a()
+ self.testhashu64Fnv1a = monster.Testhashu64Fnv1a()
+ if not monster.TestarrayofboolsIsNone():
+ if np is None:
+ self.testarrayofbools = []
+ for i in range(monster.TestarrayofboolsLength()):
+ self.testarrayofbools.append(monster.Testarrayofbools(i))
+ else:
+ self.testarrayofbools = monster.TestarrayofboolsAsNumpy()
+ self.testf = monster.Testf()
+ self.testf2 = monster.Testf2()
+ self.testf3 = monster.Testf3()
+ if not monster.Testarrayofstring2IsNone():
+ self.testarrayofstring2 = []
+ for i in range(monster.Testarrayofstring2Length()):
+ self.testarrayofstring2.append(monster.Testarrayofstring2(i))
+ if not monster.TestarrayofsortedstructIsNone():
+ self.testarrayofsortedstruct = []
+ for i in range(monster.TestarrayofsortedstructLength()):
+ if monster.Testarrayofsortedstruct(i) is None:
+ self.testarrayofsortedstruct.append(None)
+ else:
+ ability_ = MyGame.Example.Ability.AbilityT.InitFromObj(monster.Testarrayofsortedstruct(i))
+ self.testarrayofsortedstruct.append(ability_)
+ if not monster.FlexIsNone():
+ if np is None:
+ self.flex = []
+ for i in range(monster.FlexLength()):
+ self.flex.append(monster.Flex(i))
+ else:
+ self.flex = monster.FlexAsNumpy()
+ if not monster.Test5IsNone():
+ self.test5 = []
+ for i in range(monster.Test5Length()):
+ if monster.Test5(i) is None:
+ self.test5.append(None)
+ else:
+ test_ = MyGame.Example.Test.TestT.InitFromObj(monster.Test5(i))
+ self.test5.append(test_)
+ if not monster.VectorOfLongsIsNone():
+ if np is None:
+ self.vectorOfLongs = []
+ for i in range(monster.VectorOfLongsLength()):
+ self.vectorOfLongs.append(monster.VectorOfLongs(i))
+ else:
+ self.vectorOfLongs = monster.VectorOfLongsAsNumpy()
+ if not monster.VectorOfDoublesIsNone():
+ if np is None:
+ self.vectorOfDoubles = []
+ for i in range(monster.VectorOfDoublesLength()):
+ self.vectorOfDoubles.append(monster.VectorOfDoubles(i))
+ else:
+ self.vectorOfDoubles = monster.VectorOfDoublesAsNumpy()
+ if monster.ParentNamespaceTest() is not None:
+ self.parentNamespaceTest = MyGame.InParentNamespace.InParentNamespaceT.InitFromObj(monster.ParentNamespaceTest())
+ if not monster.VectorOfReferrablesIsNone():
+ self.vectorOfReferrables = []
+ for i in range(monster.VectorOfReferrablesLength()):
+ if monster.VectorOfReferrables(i) is None:
+ self.vectorOfReferrables.append(None)
+ else:
+ referrable_ = MyGame.Example.Referrable.ReferrableT.InitFromObj(monster.VectorOfReferrables(i))
+ self.vectorOfReferrables.append(referrable_)
+ self.singleWeakReference = monster.SingleWeakReference()
+ if not monster.VectorOfWeakReferencesIsNone():
+ if np is None:
+ self.vectorOfWeakReferences = []
+ for i in range(monster.VectorOfWeakReferencesLength()):
+ self.vectorOfWeakReferences.append(monster.VectorOfWeakReferences(i))
+ else:
+ self.vectorOfWeakReferences = monster.VectorOfWeakReferencesAsNumpy()
+ if not monster.VectorOfStrongReferrablesIsNone():
+ self.vectorOfStrongReferrables = []
+ for i in range(monster.VectorOfStrongReferrablesLength()):
+ if monster.VectorOfStrongReferrables(i) is None:
+ self.vectorOfStrongReferrables.append(None)
+ else:
+ referrable_ = MyGame.Example.Referrable.ReferrableT.InitFromObj(monster.VectorOfStrongReferrables(i))
+ self.vectorOfStrongReferrables.append(referrable_)
+ self.coOwningReference = monster.CoOwningReference()
+ if not monster.VectorOfCoOwningReferencesIsNone():
+ if np is None:
+ self.vectorOfCoOwningReferences = []
+ for i in range(monster.VectorOfCoOwningReferencesLength()):
+ self.vectorOfCoOwningReferences.append(monster.VectorOfCoOwningReferences(i))
+ else:
+ self.vectorOfCoOwningReferences = monster.VectorOfCoOwningReferencesAsNumpy()
+ self.nonOwningReference = monster.NonOwningReference()
+ if not monster.VectorOfNonOwningReferencesIsNone():
+ if np is None:
+ self.vectorOfNonOwningReferences = []
+ for i in range(monster.VectorOfNonOwningReferencesLength()):
+ self.vectorOfNonOwningReferences.append(monster.VectorOfNonOwningReferences(i))
+ else:
+ self.vectorOfNonOwningReferences = monster.VectorOfNonOwningReferencesAsNumpy()
+ self.anyUniqueType = monster.AnyUniqueType()
+ self.anyUnique = MyGame.Example.AnyUniqueAliases.AnyUniqueAliasesCreator(self.anyUniqueType, monster.AnyUnique())
+ self.anyAmbiguousType = monster.AnyAmbiguousType()
+ self.anyAmbiguous = MyGame.Example.AnyAmbiguousAliases.AnyAmbiguousAliasesCreator(self.anyAmbiguousType, monster.AnyAmbiguous())
+ if not monster.VectorOfEnumsIsNone():
+ if np is None:
+ self.vectorOfEnums = []
+ for i in range(monster.VectorOfEnumsLength()):
+ self.vectorOfEnums.append(monster.VectorOfEnums(i))
+ else:
+ self.vectorOfEnums = monster.VectorOfEnumsAsNumpy()
+ self.signedEnum = monster.SignedEnum()
+ if not monster.TestrequirednestedflatbufferIsNone():
+ if np is None:
+ self.testrequirednestedflatbuffer = []
+ for i in range(monster.TestrequirednestedflatbufferLength()):
+ self.testrequirednestedflatbuffer.append(monster.Testrequirednestedflatbuffer(i))
+ else:
+ self.testrequirednestedflatbuffer = monster.TestrequirednestedflatbufferAsNumpy()
+
+ # MonsterT
+ def Pack(self, builder):
+ if self.name is not None:
+ name = builder.CreateString(self.name)
+ if self.inventory is not None:
+ if np is not None and type(self.inventory) is np.ndarray:
+ inventory = builder.CreateNumpyVector(self.inventory)
+ else:
+ MonsterStartInventoryVector(builder, len(self.inventory))
+ for i in reversed(range(len(self.inventory))):
+ builder.PrependUint8(self.inventory[i])
+ inventory = builder.EndVector(len(self.inventory))
+ if self.test is not None:
+ test = self.test.Pack(builder)
+ if self.test4 is not None:
+ MonsterStartTest4Vector(builder, len(self.test4))
+ for i in reversed(range(len(self.test4))):
+ self.test4[i].Pack(builder)
+ test4 = builder.EndVector(len(self.test4))
+ if self.testarrayofstring is not None:
+ testarrayofstringlist = []
+ for i in range(len(self.testarrayofstring)):
+ testarrayofstringlist.append(builder.CreateString(self.testarrayofstring[i]))
+ MonsterStartTestarrayofstringVector(builder, len(self.testarrayofstring))
+ for i in reversed(range(len(self.testarrayofstring))):
+ builder.PrependUOffsetTRelative(testarrayofstringlist[i])
+ testarrayofstring = builder.EndVector(len(self.testarrayofstring))
+ if self.testarrayoftables is not None:
+ testarrayoftableslist = []
+ for i in range(len(self.testarrayoftables)):
+ testarrayoftableslist.append(self.testarrayoftables[i].Pack(builder))
+ MonsterStartTestarrayoftablesVector(builder, len(self.testarrayoftables))
+ for i in reversed(range(len(self.testarrayoftables))):
+ builder.PrependUOffsetTRelative(testarrayoftableslist[i])
+ testarrayoftables = builder.EndVector(len(self.testarrayoftables))
+ if self.enemy is not None:
+ enemy = self.enemy.Pack(builder)
+ if self.testnestedflatbuffer is not None:
+ if np is not None and type(self.testnestedflatbuffer) is np.ndarray:
+ testnestedflatbuffer = builder.CreateNumpyVector(self.testnestedflatbuffer)
+ else:
+ MonsterStartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer))
+ for i in reversed(range(len(self.testnestedflatbuffer))):
+ builder.PrependUint8(self.testnestedflatbuffer[i])
+ testnestedflatbuffer = builder.EndVector(len(self.testnestedflatbuffer))
+ if self.testempty is not None:
+ testempty = self.testempty.Pack(builder)
+ if self.testarrayofbools is not None:
+ if np is not None and type(self.testarrayofbools) is np.ndarray:
+ testarrayofbools = builder.CreateNumpyVector(self.testarrayofbools)
+ else:
+ MonsterStartTestarrayofboolsVector(builder, len(self.testarrayofbools))
+ for i in reversed(range(len(self.testarrayofbools))):
+ builder.PrependBool(self.testarrayofbools[i])
+ testarrayofbools = builder.EndVector(len(self.testarrayofbools))
+ if self.testarrayofstring2 is not None:
+ testarrayofstring2list = []
+ for i in range(len(self.testarrayofstring2)):
+ testarrayofstring2list.append(builder.CreateString(self.testarrayofstring2[i]))
+ MonsterStartTestarrayofstring2Vector(builder, len(self.testarrayofstring2))
+ for i in reversed(range(len(self.testarrayofstring2))):
+ builder.PrependUOffsetTRelative(testarrayofstring2list[i])
+ testarrayofstring2 = builder.EndVector(len(self.testarrayofstring2))
+ if self.testarrayofsortedstruct is not None:
+ MonsterStartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct))
+ for i in reversed(range(len(self.testarrayofsortedstruct))):
+ self.testarrayofsortedstruct[i].Pack(builder)
+ testarrayofsortedstruct = builder.EndVector(len(self.testarrayofsortedstruct))
+ if self.flex is not None:
+ if np is not None and type(self.flex) is np.ndarray:
+ flex = builder.CreateNumpyVector(self.flex)
+ else:
+ MonsterStartFlexVector(builder, len(self.flex))
+ for i in reversed(range(len(self.flex))):
+ builder.PrependUint8(self.flex[i])
+ flex = builder.EndVector(len(self.flex))
+ if self.test5 is not None:
+ MonsterStartTest5Vector(builder, len(self.test5))
+ for i in reversed(range(len(self.test5))):
+ self.test5[i].Pack(builder)
+ test5 = builder.EndVector(len(self.test5))
+ if self.vectorOfLongs is not None:
+ if np is not None and type(self.vectorOfLongs) is np.ndarray:
+ vectorOfLongs = builder.CreateNumpyVector(self.vectorOfLongs)
+ else:
+ MonsterStartVectorOfLongsVector(builder, len(self.vectorOfLongs))
+ for i in reversed(range(len(self.vectorOfLongs))):
+ builder.PrependInt64(self.vectorOfLongs[i])
+ vectorOfLongs = builder.EndVector(len(self.vectorOfLongs))
+ if self.vectorOfDoubles is not None:
+ if np is not None and type(self.vectorOfDoubles) is np.ndarray:
+ vectorOfDoubles = builder.CreateNumpyVector(self.vectorOfDoubles)
+ else:
+ MonsterStartVectorOfDoublesVector(builder, len(self.vectorOfDoubles))
+ for i in reversed(range(len(self.vectorOfDoubles))):
+ builder.PrependFloat64(self.vectorOfDoubles[i])
+ vectorOfDoubles = builder.EndVector(len(self.vectorOfDoubles))
+ if self.parentNamespaceTest is not None:
+ parentNamespaceTest = self.parentNamespaceTest.Pack(builder)
+ if self.vectorOfReferrables is not None:
+ vectorOfReferrableslist = []
+ for i in range(len(self.vectorOfReferrables)):
+ vectorOfReferrableslist.append(self.vectorOfReferrables[i].Pack(builder))
+ MonsterStartVectorOfReferrablesVector(builder, len(self.vectorOfReferrables))
+ for i in reversed(range(len(self.vectorOfReferrables))):
+ builder.PrependUOffsetTRelative(vectorOfReferrableslist[i])
+ vectorOfReferrables = builder.EndVector(len(self.vectorOfReferrables))
+ if self.vectorOfWeakReferences is not None:
+ if np is not None and type(self.vectorOfWeakReferences) is np.ndarray:
+ vectorOfWeakReferences = builder.CreateNumpyVector(self.vectorOfWeakReferences)
+ else:
+ MonsterStartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences))
+ for i in reversed(range(len(self.vectorOfWeakReferences))):
+ builder.PrependUint64(self.vectorOfWeakReferences[i])
+ vectorOfWeakReferences = builder.EndVector(len(self.vectorOfWeakReferences))
+ if self.vectorOfStrongReferrables is not None:
+ vectorOfStrongReferrableslist = []
+ for i in range(len(self.vectorOfStrongReferrables)):
+ vectorOfStrongReferrableslist.append(self.vectorOfStrongReferrables[i].Pack(builder))
+ MonsterStartVectorOfStrongReferrablesVector(builder, len(self.vectorOfStrongReferrables))
+ for i in reversed(range(len(self.vectorOfStrongReferrables))):
+ builder.PrependUOffsetTRelative(vectorOfStrongReferrableslist[i])
+ vectorOfStrongReferrables = builder.EndVector(len(self.vectorOfStrongReferrables))
+ if self.vectorOfCoOwningReferences is not None:
+ if np is not None and type(self.vectorOfCoOwningReferences) is np.ndarray:
+ vectorOfCoOwningReferences = builder.CreateNumpyVector(self.vectorOfCoOwningReferences)
+ else:
+ MonsterStartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences))
+ for i in reversed(range(len(self.vectorOfCoOwningReferences))):
+ builder.PrependUint64(self.vectorOfCoOwningReferences[i])
+ vectorOfCoOwningReferences = builder.EndVector(len(self.vectorOfCoOwningReferences))
+ if self.vectorOfNonOwningReferences is not None:
+ if np is not None and type(self.vectorOfNonOwningReferences) is np.ndarray:
+ vectorOfNonOwningReferences = builder.CreateNumpyVector(self.vectorOfNonOwningReferences)
+ else:
+ MonsterStartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences))
+ for i in reversed(range(len(self.vectorOfNonOwningReferences))):
+ builder.PrependUint64(self.vectorOfNonOwningReferences[i])
+ vectorOfNonOwningReferences = builder.EndVector(len(self.vectorOfNonOwningReferences))
+ if self.anyUnique is not None:
+ anyUnique = self.anyUnique.Pack(builder)
+ if self.anyAmbiguous is not None:
+ anyAmbiguous = self.anyAmbiguous.Pack(builder)
+ if self.vectorOfEnums is not None:
+ if np is not None and type(self.vectorOfEnums) is np.ndarray:
+ vectorOfEnums = builder.CreateNumpyVector(self.vectorOfEnums)
+ else:
+ MonsterStartVectorOfEnumsVector(builder, len(self.vectorOfEnums))
+ for i in reversed(range(len(self.vectorOfEnums))):
+ builder.PrependUint8(self.vectorOfEnums[i])
+ vectorOfEnums = builder.EndVector(len(self.vectorOfEnums))
+ if self.testrequirednestedflatbuffer is not None:
+ if np is not None and type(self.testrequirednestedflatbuffer) is np.ndarray:
+ testrequirednestedflatbuffer = builder.CreateNumpyVector(self.testrequirednestedflatbuffer)
+ else:
+ MonsterStartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer))
+ for i in reversed(range(len(self.testrequirednestedflatbuffer))):
+ builder.PrependUint8(self.testrequirednestedflatbuffer[i])
+ testrequirednestedflatbuffer = builder.EndVector(len(self.testrequirednestedflatbuffer))
+ MonsterStart(builder)
+ if self.pos is not None:
+ pos = self.pos.Pack(builder)
+ MonsterAddPos(builder, pos)
+ MonsterAddMana(builder, self.mana)
+ MonsterAddHp(builder, self.hp)
+ if self.name is not None:
+ MonsterAddName(builder, name)
+ if self.inventory is not None:
+ MonsterAddInventory(builder, inventory)
+ MonsterAddColor(builder, self.color)
+ MonsterAddTestType(builder, self.testType)
+ if self.test is not None:
+ MonsterAddTest(builder, test)
+ if self.test4 is not None:
+ MonsterAddTest4(builder, test4)
+ if self.testarrayofstring is not None:
+ MonsterAddTestarrayofstring(builder, testarrayofstring)
+ if self.testarrayoftables is not None:
+ MonsterAddTestarrayoftables(builder, testarrayoftables)
+ if self.enemy is not None:
+ MonsterAddEnemy(builder, enemy)
+ if self.testnestedflatbuffer is not None:
+ MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
+ if self.testempty is not None:
+ MonsterAddTestempty(builder, testempty)
+ MonsterAddTestbool(builder, self.testbool)
+ MonsterAddTesthashs32Fnv1(builder, self.testhashs32Fnv1)
+ MonsterAddTesthashu32Fnv1(builder, self.testhashu32Fnv1)
+ MonsterAddTesthashs64Fnv1(builder, self.testhashs64Fnv1)
+ MonsterAddTesthashu64Fnv1(builder, self.testhashu64Fnv1)
+ MonsterAddTesthashs32Fnv1a(builder, self.testhashs32Fnv1a)
+ MonsterAddTesthashu32Fnv1a(builder, self.testhashu32Fnv1a)
+ MonsterAddTesthashs64Fnv1a(builder, self.testhashs64Fnv1a)
+ MonsterAddTesthashu64Fnv1a(builder, self.testhashu64Fnv1a)
+ if self.testarrayofbools is not None:
+ MonsterAddTestarrayofbools(builder, testarrayofbools)
+ MonsterAddTestf(builder, self.testf)
+ MonsterAddTestf2(builder, self.testf2)
+ MonsterAddTestf3(builder, self.testf3)
+ if self.testarrayofstring2 is not None:
+ MonsterAddTestarrayofstring2(builder, testarrayofstring2)
+ if self.testarrayofsortedstruct is not None:
+ MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
+ if self.flex is not None:
+ MonsterAddFlex(builder, flex)
+ if self.test5 is not None:
+ MonsterAddTest5(builder, test5)
+ if self.vectorOfLongs is not None:
+ MonsterAddVectorOfLongs(builder, vectorOfLongs)
+ if self.vectorOfDoubles is not None:
+ MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
+ if self.parentNamespaceTest is not None:
+ MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
+ if self.vectorOfReferrables is not None:
+ MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
+ MonsterAddSingleWeakReference(builder, self.singleWeakReference)
+ if self.vectorOfWeakReferences is not None:
+ MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
+ if self.vectorOfStrongReferrables is not None:
+ MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
+ MonsterAddCoOwningReference(builder, self.coOwningReference)
+ if self.vectorOfCoOwningReferences is not None:
+ MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
+ MonsterAddNonOwningReference(builder, self.nonOwningReference)
+ if self.vectorOfNonOwningReferences is not None:
+ MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
+ MonsterAddAnyUniqueType(builder, self.anyUniqueType)
+ if self.anyUnique is not None:
+ MonsterAddAnyUnique(builder, anyUnique)
+ MonsterAddAnyAmbiguousType(builder, self.anyAmbiguousType)
+ if self.anyAmbiguous is not None:
+ MonsterAddAnyAmbiguous(builder, anyAmbiguous)
+ if self.vectorOfEnums is not None:
+ MonsterAddVectorOfEnums(builder, vectorOfEnums)
+ MonsterAddSignedEnum(builder, self.signedEnum)
+ if self.testrequirednestedflatbuffer is not None:
+ MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
+ monster = MonsterEnd(builder)
+ return monster
diff --git a/tests/MyGame/Example/MonsterStorageGrpc.java b/tests/MyGame/Example/MonsterStorageGrpc.java
index b9f070f..8e468d4 100644
--- a/tests/MyGame/Example/MonsterStorageGrpc.java
+++ b/tests/MyGame/Example/MonsterStorageGrpc.java
@@ -1,4 +1,4 @@
-//Generated by flatc compiler (version 1.11.0)
+//Generated by flatc compiler (version 1.12.0)
//If you make any local changes, they will be lost
//source: monster_test.fbs
diff --git a/tests/MyGame/Example/NestedStruct.cs b/tests/MyGame/Example/NestedStruct.cs
index 3f1f2f0..13e3498 100644
--- a/tests/MyGame/Example/NestedStruct.cs
+++ b/tests/MyGame/Example/NestedStruct.cs
@@ -6,6 +6,7 @@
{
using global::System;
+using global::System.Collections.Generic;
using global::FlatBuffers;
public struct NestedStruct : IFlatbufferObject
@@ -21,10 +22,15 @@
public void MutateB(MyGame.Example.TestEnum b) { __p.bb.PutSbyte(__p.bb_pos + 8, (sbyte)b); }
public MyGame.Example.TestEnum C(int j) { return (MyGame.Example.TestEnum)__p.bb.GetSbyte(__p.bb_pos + 9 + j * 1); }
public void MutateC(int j, MyGame.Example.TestEnum c) { __p.bb.PutSbyte(__p.bb_pos + 9 + j * 1, (sbyte)c); }
+ public long D(int j) { return __p.bb.GetLong(__p.bb_pos + 16 + j * 8); }
+ public void MutateD(int j, long d) { __p.bb.PutLong(__p.bb_pos + 16 + j * 8, d); }
- public static Offset<MyGame.Example.NestedStruct> CreateNestedStruct(FlatBufferBuilder builder, int[] A, MyGame.Example.TestEnum B, MyGame.Example.TestEnum[] C) {
- builder.Prep(4, 12);
- builder.Pad(1);
+ public static Offset<MyGame.Example.NestedStruct> CreateNestedStruct(FlatBufferBuilder builder, int[] A, MyGame.Example.TestEnum B, MyGame.Example.TestEnum[] C, long[] D) {
+ builder.Prep(8, 32);
+ for (int _idx0 = 2; _idx0 > 0; _idx0--) {
+ builder.PutLong(D[_idx0-1]);
+ }
+ builder.Pad(5);
for (int _idx0 = 2; _idx0 > 0; _idx0--) {
builder.PutSbyte((sbyte)C[_idx0-1]);
}
@@ -34,7 +40,52 @@
}
return new Offset<MyGame.Example.NestedStruct>(builder.Offset);
}
+ public NestedStructT UnPack() {
+ var _o = new NestedStructT();
+ this.UnPackTo(_o);
+ return _o;
+ }
+ public void UnPackTo(NestedStructT _o) {
+ _o.A = new int[2];
+ for (var _j = 0; _j < 2; ++_j) { _o.A[_j] = this.A(_j); }
+ _o.B = this.B;
+ _o.C = new MyGame.Example.TestEnum[2];
+ for (var _j = 0; _j < 2; ++_j) { _o.C[_j] = this.C(_j); }
+ _o.D = new long[2];
+ for (var _j = 0; _j < 2; ++_j) { _o.D[_j] = this.D(_j); }
+ }
+ public static Offset<MyGame.Example.NestedStruct> Pack(FlatBufferBuilder builder, NestedStructT _o) {
+ if (_o == null) return default(Offset<MyGame.Example.NestedStruct>);
+ var _a = _o.A;
+ var _c = _o.C;
+ var _d = _o.D;
+ return CreateNestedStruct(
+ builder,
+ _a,
+ _o.B,
+ _c,
+ _d);
+ }
};
+public class NestedStructT
+{
+ [Newtonsoft.Json.JsonProperty("a")]
+ public int[] A { get; set; }
+ [Newtonsoft.Json.JsonProperty("b")]
+ public MyGame.Example.TestEnum B { get; set; }
+ [Newtonsoft.Json.JsonProperty("c")]
+ public MyGame.Example.TestEnum[] C { get; set; }
+ [Newtonsoft.Json.JsonProperty("d")]
+ public long[] D { get; set; }
+
+ public NestedStructT() {
+ this.A = new int[2];
+ this.B = MyGame.Example.TestEnum.A;
+ this.C = new MyGame.Example.TestEnum[2];
+ this.D = new long[2];
+ }
+}
+
}
diff --git a/tests/MyGame/Example/NestedStruct.java b/tests/MyGame/Example/NestedStruct.java
index 3c8a8f6..fbfedd8 100644
--- a/tests/MyGame/Example/NestedStruct.java
+++ b/tests/MyGame/Example/NestedStruct.java
@@ -18,10 +18,15 @@
public void mutateB(byte b) { bb.put(bb_pos + 8, b); }
public byte c(int j) { return bb.get(bb_pos + 9 + j * 1); }
public void mutateC(int j, byte c) { bb.put(bb_pos + 9 + j * 1, c); }
+ public long d(int j) { return bb.getLong(bb_pos + 16 + j * 8); }
+ public void mutateD(int j, long d) { bb.putLong(bb_pos + 16 + j * 8, d); }
- public static int createNestedStruct(FlatBufferBuilder builder, int[] a, byte b, byte[] c) {
- builder.prep(4, 12);
- builder.pad(1);
+ public static int createNestedStruct(FlatBufferBuilder builder, int[] a, byte b, byte[] c, long[] d) {
+ builder.prep(8, 32);
+ for (int _idx0 = 2; _idx0 > 0; _idx0--) {
+ builder.putLong(d[_idx0-1]);
+ }
+ builder.pad(5);
for (int _idx0 = 2; _idx0 > 0; _idx0--) {
builder.putByte(c[_idx0-1]);
}
@@ -31,5 +36,12 @@
}
return builder.offset();
}
+
+ public static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+ public NestedStruct get(int j) { return get(new NestedStruct(), j); }
+ public NestedStruct get(NestedStruct obj, int j) { return obj.__assign(__element(j), bb); }
+ }
}
diff --git a/tests/MyGame/Example/NestedStruct.py b/tests/MyGame/Example/NestedStruct.py
index aa742f4..a9db014 100644
--- a/tests/MyGame/Example/NestedStruct.py
+++ b/tests/MyGame/Example/NestedStruct.py
@@ -3,10 +3,16 @@
# namespace: Example
import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
class NestedStruct(object):
__slots__ = ['_tab']
+ @classmethod
+ def SizeOf(cls):
+ return 32
+
# NestedStruct
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
@@ -14,16 +20,113 @@
# NestedStruct
def A(self): return [self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0 + i * 4)) for i in range(2)]
# NestedStruct
+ def ALength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(0))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # NestedStruct
+ def AIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(0))
+ return o == 0
+
+ # NestedStruct
def B(self): return self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(8))
# NestedStruct
def C(self): return [self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(9 + i * 1)) for i in range(2)]
+ # NestedStruct
+ def CLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(9))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
-def CreateNestedStruct(builder, a, b, c):
- builder.Prep(4, 12)
- builder.Pad(1)
+ # NestedStruct
+ def CIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(9))
+ return o == 0
+
+ # NestedStruct
+ def D(self): return [self._tab.Get(flatbuffers.number_types.Int64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(16 + i * 8)) for i in range(2)]
+ # NestedStruct
+ def DLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # NestedStruct
+ def DIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+ return o == 0
+
+
+def CreateNestedStruct(builder, a, b, c, d):
+ builder.Prep(8, 32)
+ for _idx0 in range(2 , 0, -1):
+ builder.PrependInt64(d[_idx0-1])
+ builder.Pad(5)
for _idx0 in range(2 , 0, -1):
builder.PrependInt8(c[_idx0-1])
builder.PrependInt8(b)
for _idx0 in range(2 , 0, -1):
builder.PrependInt32(a[_idx0-1])
return builder.Offset()
+
+try:
+ from typing import List
+except:
+ pass
+
+class NestedStructT(object):
+
+ # NestedStructT
+ def __init__(self):
+ self.a = None # type: List[int]
+ self.b = 0 # type: int
+ self.c = None # type: List[int]
+ self.d = None # type: List[int]
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ nestedStruct = NestedStruct()
+ nestedStruct.Init(buf, pos)
+ return cls.InitFromObj(nestedStruct)
+
+ @classmethod
+ def InitFromObj(cls, nestedStruct):
+ x = NestedStructT()
+ x._UnPack(nestedStruct)
+ return x
+
+ # NestedStructT
+ def _UnPack(self, nestedStruct):
+ if nestedStruct is None:
+ return
+ if not nestedStruct.AIsNone():
+ if np is None:
+ self.a = []
+ for i in range(nestedStruct.ALength()):
+ self.a.append(nestedStruct.A(i))
+ else:
+ self.a = nestedStruct.AAsNumpy()
+ self.b = nestedStruct.B()
+ if not nestedStruct.CIsNone():
+ if np is None:
+ self.c = []
+ for i in range(nestedStruct.CLength()):
+ self.c.append(nestedStruct.C(i))
+ else:
+ self.c = nestedStruct.CAsNumpy()
+ if not nestedStruct.DIsNone():
+ if np is None:
+ self.d = []
+ for i in range(nestedStruct.DLength()):
+ self.d.append(nestedStruct.D(i))
+ else:
+ self.d = nestedStruct.DAsNumpy()
+
+ # NestedStructT
+ def Pack(self, builder):
+ return CreateNestedStruct(builder, self.a, self.b, self.c, self.d)
diff --git a/tests/MyGame/Example/Race.cs b/tests/MyGame/Example/Race.cs
new file mode 100644
index 0000000..8a1959a
--- /dev/null
+++ b/tests/MyGame/Example/Race.cs
@@ -0,0 +1,18 @@
+// <auto-generated>
+// automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace MyGame.Example
+{
+
+[Newtonsoft.Json.JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
+public enum Race : sbyte
+{
+ None = -1,
+ Human = 0,
+ Dwarf = 1,
+ Elf = 2,
+};
+
+
+}
diff --git a/tests/MyGame/Example/Race.go b/tests/MyGame/Example/Race.go
new file mode 100644
index 0000000..0762bca
--- /dev/null
+++ b/tests/MyGame/Example/Race.go
@@ -0,0 +1,35 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package Example
+
+import "strconv"
+
+type Race int8
+
+const (
+ RaceNone Race = -1
+ RaceHuman Race = 0
+ RaceDwarf Race = 1
+ RaceElf Race = 2
+)
+
+var EnumNamesRace = map[Race]string{
+ RaceNone: "None",
+ RaceHuman: "Human",
+ RaceDwarf: "Dwarf",
+ RaceElf: "Elf",
+}
+
+var EnumValuesRace = map[string]Race{
+ "None": RaceNone,
+ "Human": RaceHuman,
+ "Dwarf": RaceDwarf,
+ "Elf": RaceElf,
+}
+
+func (v Race) String() string {
+ if s, ok := EnumNamesRace[v]; ok {
+ return s
+ }
+ return "Race(" + strconv.FormatInt(int64(v), 10) + ")"
+}
diff --git a/tests/MyGame/Example/Race.java b/tests/MyGame/Example/Race.java
new file mode 100644
index 0000000..0dfd80b
--- /dev/null
+++ b/tests/MyGame/Example/Race.java
@@ -0,0 +1,16 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package MyGame.Example;
+
+public final class Race {
+ private Race() { }
+ public static final byte None = -1;
+ public static final byte Human = 0;
+ public static final byte Dwarf = 1;
+ public static final byte Elf = 2;
+
+ public static final String[] names = { "None", "Human", "Dwarf", "Elf", };
+
+ public static String name(int e) { return names[e - None]; }
+}
+
diff --git a/tests/MyGame/Example/Race.kt b/tests/MyGame/Example/Race.kt
new file mode 100644
index 0000000..6eb9534
--- /dev/null
+++ b/tests/MyGame/Example/Race.kt
@@ -0,0 +1,16 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package MyGame.Example
+
+@Suppress("unused")
+@ExperimentalUnsignedTypes
+class Race private constructor() {
+ companion object {
+ const val None: Byte = -1
+ const val Human: Byte = 0
+ const val Dwarf: Byte = 1
+ const val Elf: Byte = 2
+ val names : Array<String> = arrayOf("None", "Human", "Dwarf", "Elf")
+ fun name(e: Int) : String = names[e - None.toInt()]
+ }
+}
diff --git a/tests/MyGame/Example/Race.lua b/tests/MyGame/Example/Race.lua
new file mode 100644
index 0000000..646f374
--- /dev/null
+++ b/tests/MyGame/Example/Race.lua
@@ -0,0 +1,12 @@
+-- automatically generated by the FlatBuffers compiler, do not modify
+
+-- namespace: Example
+
+local Race = {
+ None = -1,
+ Human = 0,
+ Dwarf = 1,
+ Elf = 2,
+}
+
+return Race -- return the module
\ No newline at end of file
diff --git a/tests/MyGame/Example/Race.php b/tests/MyGame/Example/Race.php
new file mode 100644
index 0000000..3f05c43
--- /dev/null
+++ b/tests/MyGame/Example/Race.php
@@ -0,0 +1,27 @@
+<?php
+// automatically generated by the FlatBuffers compiler, do not modify
+
+namespace MyGame\Example;
+
+class Race
+{
+ const None = -1;
+ const Human = 0;
+ const Dwarf = 1;
+ const Elf = 2;
+
+ private static $names = array(
+ Race::None=>"None",
+ Race::Human=>"Human",
+ Race::Dwarf=>"Dwarf",
+ Race::Elf=>"Elf",
+ );
+
+ public static function Name($e)
+ {
+ if (!isset(self::$names[$e])) {
+ throw new \Exception();
+ }
+ return self::$names[$e];
+ }
+}
diff --git a/tests/MyGame/Example/Race.py b/tests/MyGame/Example/Race.py
new file mode 100644
index 0000000..a39c6ea
--- /dev/null
+++ b/tests/MyGame/Example/Race.py
@@ -0,0 +1,10 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: Example
+
+class Race(object):
+ None_ = -1
+ Human = 0
+ Dwarf = 1
+ Elf = 2
+
diff --git a/tests/MyGame/Example/Referrable.cs b/tests/MyGame/Example/Referrable.cs
index 5a79f91..81394ad 100644
--- a/tests/MyGame/Example/Referrable.cs
+++ b/tests/MyGame/Example/Referrable.cs
@@ -6,13 +6,14 @@
{
using global::System;
+using global::System.Collections.Generic;
using global::FlatBuffers;
public struct Referrable : IFlatbufferObject
{
private Table __p;
public ByteBuffer ByteBuffer { get { return __p.bb; } }
- public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_11_1(); }
+ public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_12_0(); }
public static Referrable GetRootAsReferrable(ByteBuffer _bb) { return GetRootAsReferrable(_bb, new Referrable()); }
public static Referrable GetRootAsReferrable(ByteBuffer _bb, Referrable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
@@ -59,7 +60,32 @@
}
return null;
}
+ public ReferrableT UnPack() {
+ var _o = new ReferrableT();
+ this.UnPackTo(_o);
+ return _o;
+ }
+ public void UnPackTo(ReferrableT _o) {
+ _o.Id = this.Id;
+ }
+ public static Offset<MyGame.Example.Referrable> Pack(FlatBufferBuilder builder, ReferrableT _o) {
+ if (_o == null) return default(Offset<MyGame.Example.Referrable>);
+ return CreateReferrable(
+ builder,
+ _o.Id);
+ }
};
+public class ReferrableT
+{
+ [Newtonsoft.Json.JsonProperty("id")]
+ [Newtonsoft.Json.JsonIgnore()]
+ public ulong Id { get; set; }
+
+ public ReferrableT() {
+ this.Id = 0;
+ }
+}
+
}
diff --git a/tests/MyGame/Example/Referrable.go b/tests/MyGame/Example/Referrable.go
index 0fb06fb..66c5972 100644
--- a/tests/MyGame/Example/Referrable.go
+++ b/tests/MyGame/Example/Referrable.go
@@ -6,6 +6,28 @@
flatbuffers "github.com/google/flatbuffers/go"
)
+type ReferrableT struct {
+ Id uint64
+}
+
+func (t *ReferrableT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil { return 0 }
+ ReferrableStart(builder)
+ ReferrableAddId(builder, t.Id)
+ return ReferrableEnd(builder)
+}
+
+func (rcv *Referrable) UnPackTo(t *ReferrableT) {
+ t.Id = rcv.Id()
+}
+
+func (rcv *Referrable) UnPack() *ReferrableT {
+ if rcv == nil { return nil }
+ t := &ReferrableT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
type Referrable struct {
_tab flatbuffers.Table
}
@@ -17,6 +39,13 @@
return x
}
+func GetSizePrefixedRootAsReferrable(buf []byte, offset flatbuffers.UOffsetT) *Referrable {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Referrable{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
func (rcv *Referrable) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/tests/MyGame/Example/Referrable.java b/tests/MyGame/Example/Referrable.java
index f154857..1f92958 100644
--- a/tests/MyGame/Example/Referrable.java
+++ b/tests/MyGame/Example/Referrable.java
@@ -9,7 +9,7 @@
@SuppressWarnings("unused")
public final class Referrable extends Table {
- public static void ValidateVersion() { Constants.FLATBUFFERS_1_11_1(); }
+ public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
public static Referrable getRootAsReferrable(ByteBuffer _bb) { return getRootAsReferrable(_bb, new Referrable()); }
public static Referrable getRootAsReferrable(ByteBuffer _bb, Referrable obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
@@ -59,5 +59,14 @@
}
return null;
}
+
+ public static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+ public Referrable get(int j) { return get(new Referrable(), j); }
+ public Referrable get(Referrable obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); }
+ public Referrable getByKey(long key) { return __lookup_by_key(null, __vector(), key, bb); }
+ public Referrable getByKey(Referrable obj, long key) { return __lookup_by_key(obj, __vector(), key, bb); }
+ }
}
diff --git a/tests/MyGame/Example/Referrable.kt b/tests/MyGame/Example/Referrable.kt
index 55ff1d8..2e78c93 100644
--- a/tests/MyGame/Example/Referrable.kt
+++ b/tests/MyGame/Example/Referrable.kt
@@ -37,7 +37,7 @@
return (val_1 - val_2).sign
}
companion object {
- fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
+ fun validateVersion() = Constants.FLATBUFFERS_1_12_0()
fun getRootAsReferrable(_bb: ByteBuffer): Referrable = getRootAsReferrable(_bb, Referrable())
fun getRootAsReferrable(_bb: ByteBuffer, obj: Referrable): Referrable {
_bb.order(ByteOrder.LITTLE_ENDIAN)
diff --git a/tests/MyGame/Example/Referrable.py b/tests/MyGame/Example/Referrable.py
index eaec09b..44bf50f 100644
--- a/tests/MyGame/Example/Referrable.py
+++ b/tests/MyGame/Example/Referrable.py
@@ -3,6 +3,8 @@
# namespace: Example
import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
class Referrable(object):
__slots__ = ['_tab']
@@ -32,3 +34,35 @@
def ReferrableStart(builder): builder.StartObject(1)
def ReferrableAddId(builder, id): builder.PrependUint64Slot(0, id, 0)
def ReferrableEnd(builder): return builder.EndObject()
+
+
+class ReferrableT(object):
+
+ # ReferrableT
+ def __init__(self):
+ self.id = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ referrable = Referrable()
+ referrable.Init(buf, pos)
+ return cls.InitFromObj(referrable)
+
+ @classmethod
+ def InitFromObj(cls, referrable):
+ x = ReferrableT()
+ x._UnPack(referrable)
+ return x
+
+ # ReferrableT
+ def _UnPack(self, referrable):
+ if referrable is None:
+ return
+ self.id = referrable.Id()
+
+ # ReferrableT
+ def Pack(self, builder):
+ ReferrableStart(builder)
+ ReferrableAddId(builder, self.id)
+ referrable = ReferrableEnd(builder)
+ return referrable
diff --git a/tests/MyGame/Example/Stat.cs b/tests/MyGame/Example/Stat.cs
index bcd1004..6f19ed4 100644
--- a/tests/MyGame/Example/Stat.cs
+++ b/tests/MyGame/Example/Stat.cs
@@ -6,13 +6,14 @@
{
using global::System;
+using global::System.Collections.Generic;
using global::FlatBuffers;
public struct Stat : IFlatbufferObject
{
private Table __p;
public ByteBuffer ByteBuffer { get { return __p.bb; } }
- public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_11_1(); }
+ public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_12_0(); }
public static Stat GetRootAsStat(ByteBuffer _bb) { return GetRootAsStat(_bb, new Stat()); }
public static Stat GetRootAsStat(ByteBuffer _bb, Stat obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
@@ -20,7 +21,7 @@
public string Id { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
#if ENABLE_SPAN_T
- public Span<byte> GetIdBytes() { return __p.__vector_as_span(4); }
+ public Span<byte> GetIdBytes() { return __p.__vector_as_span<byte>(4, 1); }
#else
public ArraySegment<byte>? GetIdBytes() { return __p.__vector_as_arraysegment(4); }
#endif
@@ -49,7 +50,42 @@
int o = builder.EndTable();
return new Offset<MyGame.Example.Stat>(o);
}
+ public StatT UnPack() {
+ var _o = new StatT();
+ this.UnPackTo(_o);
+ return _o;
+ }
+ public void UnPackTo(StatT _o) {
+ _o.Id = this.Id;
+ _o.Val = this.Val;
+ _o.Count = this.Count;
+ }
+ public static Offset<MyGame.Example.Stat> Pack(FlatBufferBuilder builder, StatT _o) {
+ if (_o == null) return default(Offset<MyGame.Example.Stat>);
+ var _id = _o.Id == null ? default(StringOffset) : builder.CreateString(_o.Id);
+ return CreateStat(
+ builder,
+ _id,
+ _o.Val,
+ _o.Count);
+ }
};
+public class StatT
+{
+ [Newtonsoft.Json.JsonProperty("id")]
+ public string Id { get; set; }
+ [Newtonsoft.Json.JsonProperty("val")]
+ public long Val { get; set; }
+ [Newtonsoft.Json.JsonProperty("count")]
+ public ushort Count { get; set; }
+
+ public StatT() {
+ this.Id = null;
+ this.Val = 0;
+ this.Count = 0;
+ }
+}
+
}
diff --git a/tests/MyGame/Example/Stat.go b/tests/MyGame/Example/Stat.go
index 401712f..5c060d1 100644
--- a/tests/MyGame/Example/Stat.go
+++ b/tests/MyGame/Example/Stat.go
@@ -6,6 +6,35 @@
flatbuffers "github.com/google/flatbuffers/go"
)
+type StatT struct {
+ Id string
+ Val int64
+ Count uint16
+}
+
+func (t *StatT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil { return 0 }
+ idOffset := builder.CreateString(t.Id)
+ StatStart(builder)
+ StatAddId(builder, idOffset)
+ StatAddVal(builder, t.Val)
+ StatAddCount(builder, t.Count)
+ return StatEnd(builder)
+}
+
+func (rcv *Stat) UnPackTo(t *StatT) {
+ t.Id = string(rcv.Id())
+ t.Val = rcv.Val()
+ t.Count = rcv.Count()
+}
+
+func (rcv *Stat) UnPack() *StatT {
+ if rcv == nil { return nil }
+ t := &StatT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
type Stat struct {
_tab flatbuffers.Table
}
@@ -17,6 +46,13 @@
return x
}
+func GetSizePrefixedRootAsStat(buf []byte, offset flatbuffers.UOffsetT) *Stat {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Stat{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
func (rcv *Stat) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/tests/MyGame/Example/Stat.java b/tests/MyGame/Example/Stat.java
index 58d34f3..116c211 100644
--- a/tests/MyGame/Example/Stat.java
+++ b/tests/MyGame/Example/Stat.java
@@ -9,7 +9,7 @@
@SuppressWarnings("unused")
public final class Stat extends Table {
- public static void ValidateVersion() { Constants.FLATBUFFERS_1_11_1(); }
+ public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
public static Stat getRootAsStat(ByteBuffer _bb) { return getRootAsStat(_bb, new Stat()); }
public static Stat getRootAsStat(ByteBuffer _bb, Stat obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
@@ -42,5 +42,12 @@
int o = builder.endTable();
return o;
}
+
+ public static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+ public Stat get(int j) { return get(new Stat(), j); }
+ public Stat get(Stat obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); }
+ }
}
diff --git a/tests/MyGame/Example/Stat.kt b/tests/MyGame/Example/Stat.kt
index 26b293c..e72f553 100644
--- a/tests/MyGame/Example/Stat.kt
+++ b/tests/MyGame/Example/Stat.kt
@@ -53,7 +53,7 @@
}
}
companion object {
- fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
+ fun validateVersion() = Constants.FLATBUFFERS_1_12_0()
fun getRootAsStat(_bb: ByteBuffer): Stat = getRootAsStat(_bb, Stat())
fun getRootAsStat(_bb: ByteBuffer, obj: Stat): Stat {
_bb.order(ByteOrder.LITTLE_ENDIAN)
diff --git a/tests/MyGame/Example/Stat.py b/tests/MyGame/Example/Stat.py
index 0fbd2a7..7d3362f 100644
--- a/tests/MyGame/Example/Stat.py
+++ b/tests/MyGame/Example/Stat.py
@@ -3,6 +3,8 @@
# namespace: Example
import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
class Stat(object):
__slots__ = ['_tab']
@@ -48,3 +50,44 @@
def StatAddVal(builder, val): builder.PrependInt64Slot(1, val, 0)
def StatAddCount(builder, count): builder.PrependUint16Slot(2, count, 0)
def StatEnd(builder): return builder.EndObject()
+
+
+class StatT(object):
+
+ # StatT
+ def __init__(self):
+ self.id = None # type: str
+ self.val = 0 # type: int
+ self.count = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ stat = Stat()
+ stat.Init(buf, pos)
+ return cls.InitFromObj(stat)
+
+ @classmethod
+ def InitFromObj(cls, stat):
+ x = StatT()
+ x._UnPack(stat)
+ return x
+
+ # StatT
+ def _UnPack(self, stat):
+ if stat is None:
+ return
+ self.id = stat.Id()
+ self.val = stat.Val()
+ self.count = stat.Count()
+
+ # StatT
+ def Pack(self, builder):
+ if self.id is not None:
+ id = builder.CreateString(self.id)
+ StatStart(builder)
+ if self.id is not None:
+ StatAddId(builder, id)
+ StatAddVal(builder, self.val)
+ StatAddCount(builder, self.count)
+ stat = StatEnd(builder)
+ return stat
diff --git a/tests/MyGame/Example/Test.cs b/tests/MyGame/Example/Test.cs
index cd91454..a6419ed 100644
--- a/tests/MyGame/Example/Test.cs
+++ b/tests/MyGame/Example/Test.cs
@@ -6,6 +6,7 @@
{
using global::System;
+using global::System.Collections.Generic;
using global::FlatBuffers;
public struct Test : IFlatbufferObject
@@ -27,7 +28,36 @@
builder.PutShort(A);
return new Offset<MyGame.Example.Test>(builder.Offset);
}
+ public TestT UnPack() {
+ var _o = new TestT();
+ this.UnPackTo(_o);
+ return _o;
+ }
+ public void UnPackTo(TestT _o) {
+ _o.A = this.A;
+ _o.B = this.B;
+ }
+ public static Offset<MyGame.Example.Test> Pack(FlatBufferBuilder builder, TestT _o) {
+ if (_o == null) return default(Offset<MyGame.Example.Test>);
+ return CreateTest(
+ builder,
+ _o.A,
+ _o.B);
+ }
};
+public class TestT
+{
+ [Newtonsoft.Json.JsonProperty("a")]
+ public short A { get; set; }
+ [Newtonsoft.Json.JsonProperty("b")]
+ public sbyte B { get; set; }
+
+ public TestT() {
+ this.A = 0;
+ this.B = 0;
+ }
+}
+
}
diff --git a/tests/MyGame/Example/Test.go b/tests/MyGame/Example/Test.go
index 53f53fd..cbf7e29 100644
--- a/tests/MyGame/Example/Test.go
+++ b/tests/MyGame/Example/Test.go
@@ -6,6 +6,27 @@
flatbuffers "github.com/google/flatbuffers/go"
)
+type TestT struct {
+ A int16
+ B int8
+}
+
+func (t *TestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil { return 0 }
+ return CreateTest(builder, t.A, t.B)
+}
+func (rcv *Test) UnPackTo(t *TestT) {
+ t.A = rcv.A()
+ t.B = rcv.B()
+}
+
+func (rcv *Test) UnPack() *TestT {
+ if rcv == nil { return nil }
+ t := &TestT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
type Test struct {
_tab flatbuffers.Struct
}
diff --git a/tests/MyGame/Example/Test.java b/tests/MyGame/Example/Test.java
index 83fdeb0..c4ffc41 100644
--- a/tests/MyGame/Example/Test.java
+++ b/tests/MyGame/Example/Test.java
@@ -24,5 +24,12 @@
builder.putShort(a);
return builder.offset();
}
+
+ public static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+ public Test get(int j) { return get(new Test(), j); }
+ public Test get(Test obj, int j) { return obj.__assign(__element(j), bb); }
+ }
}
diff --git a/tests/MyGame/Example/Test.py b/tests/MyGame/Example/Test.py
index 3b2fd45..8357ec2 100644
--- a/tests/MyGame/Example/Test.py
+++ b/tests/MyGame/Example/Test.py
@@ -3,10 +3,16 @@
# namespace: Example
import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
class Test(object):
__slots__ = ['_tab']
+ @classmethod
+ def SizeOf(cls):
+ return 4
+
# Test
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
@@ -22,3 +28,34 @@
builder.PrependInt8(b)
builder.PrependInt16(a)
return builder.Offset()
+
+
+class TestT(object):
+
+ # TestT
+ def __init__(self):
+ self.a = 0 # type: int
+ self.b = 0 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ test = Test()
+ test.Init(buf, pos)
+ return cls.InitFromObj(test)
+
+ @classmethod
+ def InitFromObj(cls, test):
+ x = TestT()
+ x._UnPack(test)
+ return x
+
+ # TestT
+ def _UnPack(self, test):
+ if test is None:
+ return
+ self.a = test.A()
+ self.b = test.B()
+
+ # TestT
+ def Pack(self, builder):
+ return CreateTest(builder, self.a, self.b)
diff --git a/tests/MyGame/Example/TestEnum.cs b/tests/MyGame/Example/TestEnum.cs
index 22e83b3..6dfd6b5 100644
--- a/tests/MyGame/Example/TestEnum.cs
+++ b/tests/MyGame/Example/TestEnum.cs
@@ -5,6 +5,7 @@
namespace MyGame.Example
{
+[Newtonsoft.Json.JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
public enum TestEnum : sbyte
{
A = 0,
diff --git a/tests/MyGame/Example/TestSimpleTableWithEnum.cs b/tests/MyGame/Example/TestSimpleTableWithEnum.cs
index f9ac42e..c8ef08e 100644
--- a/tests/MyGame/Example/TestSimpleTableWithEnum.cs
+++ b/tests/MyGame/Example/TestSimpleTableWithEnum.cs
@@ -6,13 +6,14 @@
{
using global::System;
+using global::System.Collections.Generic;
using global::FlatBuffers;
internal partial struct TestSimpleTableWithEnum : IFlatbufferObject
{
private Table __p;
public ByteBuffer ByteBuffer { get { return __p.bb; } }
- public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_11_1(); }
+ public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_12_0(); }
public static TestSimpleTableWithEnum GetRootAsTestSimpleTableWithEnum(ByteBuffer _bb) { return GetRootAsTestSimpleTableWithEnum(_bb, new TestSimpleTableWithEnum()); }
public static TestSimpleTableWithEnum GetRootAsTestSimpleTableWithEnum(ByteBuffer _bb, TestSimpleTableWithEnum obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
@@ -34,7 +35,31 @@
int o = builder.EndTable();
return new Offset<MyGame.Example.TestSimpleTableWithEnum>(o);
}
+ public TestSimpleTableWithEnumT UnPack() {
+ var _o = new TestSimpleTableWithEnumT();
+ this.UnPackTo(_o);
+ return _o;
+ }
+ public void UnPackTo(TestSimpleTableWithEnumT _o) {
+ _o.Color = this.Color;
+ }
+ public static Offset<MyGame.Example.TestSimpleTableWithEnum> Pack(FlatBufferBuilder builder, TestSimpleTableWithEnumT _o) {
+ if (_o == null) return default(Offset<MyGame.Example.TestSimpleTableWithEnum>);
+ return CreateTestSimpleTableWithEnum(
+ builder,
+ _o.Color);
+ }
};
+internal partial class TestSimpleTableWithEnumT
+{
+ [Newtonsoft.Json.JsonProperty("color")]
+ public MyGame.Example.Color Color { get; set; }
+
+ public TestSimpleTableWithEnumT() {
+ this.Color = MyGame.Example.Color.Green;
+ }
+}
+
}
diff --git a/tests/MyGame/Example/TestSimpleTableWithEnum.go b/tests/MyGame/Example/TestSimpleTableWithEnum.go
index 35a6c7c..b8cde12 100644
--- a/tests/MyGame/Example/TestSimpleTableWithEnum.go
+++ b/tests/MyGame/Example/TestSimpleTableWithEnum.go
@@ -6,6 +6,28 @@
flatbuffers "github.com/google/flatbuffers/go"
)
+type TestSimpleTableWithEnumT struct {
+ Color Color
+}
+
+func (t *TestSimpleTableWithEnumT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil { return 0 }
+ TestSimpleTableWithEnumStart(builder)
+ TestSimpleTableWithEnumAddColor(builder, t.Color)
+ return TestSimpleTableWithEnumEnd(builder)
+}
+
+func (rcv *TestSimpleTableWithEnum) UnPackTo(t *TestSimpleTableWithEnumT) {
+ t.Color = rcv.Color()
+}
+
+func (rcv *TestSimpleTableWithEnum) UnPack() *TestSimpleTableWithEnumT {
+ if rcv == nil { return nil }
+ t := &TestSimpleTableWithEnumT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
type TestSimpleTableWithEnum struct {
_tab flatbuffers.Table
}
@@ -17,6 +39,13 @@
return x
}
+func GetSizePrefixedRootAsTestSimpleTableWithEnum(buf []byte, offset flatbuffers.UOffsetT) *TestSimpleTableWithEnum {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &TestSimpleTableWithEnum{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
func (rcv *TestSimpleTableWithEnum) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/tests/MyGame/Example/TestSimpleTableWithEnum.java b/tests/MyGame/Example/TestSimpleTableWithEnum.java
index c9f1c63..7e72c22 100644
--- a/tests/MyGame/Example/TestSimpleTableWithEnum.java
+++ b/tests/MyGame/Example/TestSimpleTableWithEnum.java
@@ -9,7 +9,7 @@
@SuppressWarnings("unused")
final class TestSimpleTableWithEnum extends Table {
- public static void ValidateVersion() { Constants.FLATBUFFERS_1_11_1(); }
+ public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
public static TestSimpleTableWithEnum getRootAsTestSimpleTableWithEnum(ByteBuffer _bb) { return getRootAsTestSimpleTableWithEnum(_bb, new TestSimpleTableWithEnum()); }
public static TestSimpleTableWithEnum getRootAsTestSimpleTableWithEnum(ByteBuffer _bb, TestSimpleTableWithEnum obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
@@ -31,5 +31,12 @@
int o = builder.endTable();
return o;
}
+
+ static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+ public TestSimpleTableWithEnum get(int j) { return get(new TestSimpleTableWithEnum(), j); }
+ public TestSimpleTableWithEnum get(TestSimpleTableWithEnum obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); }
+ }
}
diff --git a/tests/MyGame/Example/TestSimpleTableWithEnum.kt b/tests/MyGame/Example/TestSimpleTableWithEnum.kt
index 68c6abf..125f889 100644
--- a/tests/MyGame/Example/TestSimpleTableWithEnum.kt
+++ b/tests/MyGame/Example/TestSimpleTableWithEnum.kt
@@ -32,7 +32,7 @@
}
}
companion object {
- fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
+ fun validateVersion() = Constants.FLATBUFFERS_1_12_0()
fun getRootAsTestSimpleTableWithEnum(_bb: ByteBuffer): TestSimpleTableWithEnum = getRootAsTestSimpleTableWithEnum(_bb, TestSimpleTableWithEnum())
fun getRootAsTestSimpleTableWithEnum(_bb: ByteBuffer, obj: TestSimpleTableWithEnum): TestSimpleTableWithEnum {
_bb.order(ByteOrder.LITTLE_ENDIAN)
diff --git a/tests/MyGame/Example/TestSimpleTableWithEnum.py b/tests/MyGame/Example/TestSimpleTableWithEnum.py
index cb9c631..d91947a 100644
--- a/tests/MyGame/Example/TestSimpleTableWithEnum.py
+++ b/tests/MyGame/Example/TestSimpleTableWithEnum.py
@@ -3,6 +3,8 @@
# namespace: Example
import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
class TestSimpleTableWithEnum(object):
__slots__ = ['_tab']
@@ -32,3 +34,35 @@
def TestSimpleTableWithEnumStart(builder): builder.StartObject(1)
def TestSimpleTableWithEnumAddColor(builder, color): builder.PrependUint8Slot(0, color, 2)
def TestSimpleTableWithEnumEnd(builder): return builder.EndObject()
+
+
+class TestSimpleTableWithEnumT(object):
+
+ # TestSimpleTableWithEnumT
+ def __init__(self):
+ self.color = 2 # type: int
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ testSimpleTableWithEnum = TestSimpleTableWithEnum()
+ testSimpleTableWithEnum.Init(buf, pos)
+ return cls.InitFromObj(testSimpleTableWithEnum)
+
+ @classmethod
+ def InitFromObj(cls, testSimpleTableWithEnum):
+ x = TestSimpleTableWithEnumT()
+ x._UnPack(testSimpleTableWithEnum)
+ return x
+
+ # TestSimpleTableWithEnumT
+ def _UnPack(self, testSimpleTableWithEnum):
+ if testSimpleTableWithEnum is None:
+ return
+ self.color = testSimpleTableWithEnum.Color()
+
+ # TestSimpleTableWithEnumT
+ def Pack(self, builder):
+ TestSimpleTableWithEnumStart(builder)
+ TestSimpleTableWithEnumAddColor(builder, self.color)
+ testSimpleTableWithEnum = TestSimpleTableWithEnumEnd(builder)
+ return testSimpleTableWithEnum
diff --git a/tests/MyGame/Example/TypeAliases.cs b/tests/MyGame/Example/TypeAliases.cs
index a7b54d5..79ffb07 100644
--- a/tests/MyGame/Example/TypeAliases.cs
+++ b/tests/MyGame/Example/TypeAliases.cs
@@ -6,13 +6,14 @@
{
using global::System;
+using global::System.Collections.Generic;
using global::FlatBuffers;
public struct TypeAliases : IFlatbufferObject
{
private Table __p;
public ByteBuffer ByteBuffer { get { return __p.bb; } }
- public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_11_1(); }
+ public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_12_0(); }
public static TypeAliases GetRootAsTypeAliases(ByteBuffer _bb) { return GetRootAsTypeAliases(_bb, new TypeAliases()); }
public static TypeAliases GetRootAsTypeAliases(ByteBuffer _bb, TypeAliases obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
@@ -41,7 +42,7 @@
public sbyte V8(int j) { int o = __p.__offset(24); return o != 0 ? __p.bb.GetSbyte(__p.__vector(o) + j * 1) : (sbyte)0; }
public int V8Length { get { int o = __p.__offset(24); return o != 0 ? __p.__vector_len(o) : 0; } }
#if ENABLE_SPAN_T
- public Span<byte> GetV8Bytes() { return __p.__vector_as_span(24); }
+ public Span<sbyte> GetV8Bytes() { return __p.__vector_as_span<sbyte>(24, 1); }
#else
public ArraySegment<byte>? GetV8Bytes() { return __p.__vector_as_arraysegment(24); }
#endif
@@ -50,7 +51,7 @@
public double Vf64(int j) { int o = __p.__offset(26); return o != 0 ? __p.bb.GetDouble(__p.__vector(o) + j * 8) : (double)0; }
public int Vf64Length { get { int o = __p.__offset(26); return o != 0 ? __p.__vector_len(o) : 0; } }
#if ENABLE_SPAN_T
- public Span<byte> GetVf64Bytes() { return __p.__vector_as_span(26); }
+ public Span<double> GetVf64Bytes() { return __p.__vector_as_span<double>(26, 8); }
#else
public ArraySegment<byte>? GetVf64Bytes() { return __p.__vector_as_arraysegment(26); }
#endif
@@ -109,7 +110,98 @@
int o = builder.EndTable();
return new Offset<MyGame.Example.TypeAliases>(o);
}
+ public TypeAliasesT UnPack() {
+ var _o = new TypeAliasesT();
+ this.UnPackTo(_o);
+ return _o;
+ }
+ public void UnPackTo(TypeAliasesT _o) {
+ _o.I8 = this.I8;
+ _o.U8 = this.U8;
+ _o.I16 = this.I16;
+ _o.U16 = this.U16;
+ _o.I32 = this.I32;
+ _o.U32 = this.U32;
+ _o.I64 = this.I64;
+ _o.U64 = this.U64;
+ _o.F32 = this.F32;
+ _o.F64 = this.F64;
+ _o.V8 = new List<sbyte>();
+ for (var _j = 0; _j < this.V8Length; ++_j) {_o.V8.Add(this.V8(_j));}
+ _o.Vf64 = new List<double>();
+ for (var _j = 0; _j < this.Vf64Length; ++_j) {_o.Vf64.Add(this.Vf64(_j));}
+ }
+ public static Offset<MyGame.Example.TypeAliases> Pack(FlatBufferBuilder builder, TypeAliasesT _o) {
+ if (_o == null) return default(Offset<MyGame.Example.TypeAliases>);
+ var _v8 = default(VectorOffset);
+ if (_o.V8 != null) {
+ var __v8 = _o.V8.ToArray();
+ _v8 = CreateV8Vector(builder, __v8);
+ }
+ var _vf64 = default(VectorOffset);
+ if (_o.Vf64 != null) {
+ var __vf64 = _o.Vf64.ToArray();
+ _vf64 = CreateVf64Vector(builder, __vf64);
+ }
+ return CreateTypeAliases(
+ builder,
+ _o.I8,
+ _o.U8,
+ _o.I16,
+ _o.U16,
+ _o.I32,
+ _o.U32,
+ _o.I64,
+ _o.U64,
+ _o.F32,
+ _o.F64,
+ _v8,
+ _vf64);
+ }
};
+public class TypeAliasesT
+{
+ [Newtonsoft.Json.JsonProperty("i8")]
+ public sbyte I8 { get; set; }
+ [Newtonsoft.Json.JsonProperty("u8")]
+ public byte U8 { get; set; }
+ [Newtonsoft.Json.JsonProperty("i16")]
+ public short I16 { get; set; }
+ [Newtonsoft.Json.JsonProperty("u16")]
+ public ushort U16 { get; set; }
+ [Newtonsoft.Json.JsonProperty("i32")]
+ public int I32 { get; set; }
+ [Newtonsoft.Json.JsonProperty("u32")]
+ public uint U32 { get; set; }
+ [Newtonsoft.Json.JsonProperty("i64")]
+ public long I64 { get; set; }
+ [Newtonsoft.Json.JsonProperty("u64")]
+ public ulong U64 { get; set; }
+ [Newtonsoft.Json.JsonProperty("f32")]
+ public float F32 { get; set; }
+ [Newtonsoft.Json.JsonProperty("f64")]
+ public double F64 { get; set; }
+ [Newtonsoft.Json.JsonProperty("v8")]
+ public List<sbyte> V8 { get; set; }
+ [Newtonsoft.Json.JsonProperty("vf64")]
+ public List<double> Vf64 { get; set; }
+
+ public TypeAliasesT() {
+ this.I8 = 0;
+ this.U8 = 0;
+ this.I16 = 0;
+ this.U16 = 0;
+ this.I32 = 0;
+ this.U32 = 0;
+ this.I64 = 0;
+ this.U64 = 0;
+ this.F32 = 0.0f;
+ this.F64 = 0.0;
+ this.V8 = null;
+ this.Vf64 = null;
+ }
+}
+
}
diff --git a/tests/MyGame/Example/TypeAliases.go b/tests/MyGame/Example/TypeAliases.go
index d017b5b..d018fa1 100644
--- a/tests/MyGame/Example/TypeAliases.go
+++ b/tests/MyGame/Example/TypeAliases.go
@@ -6,6 +6,87 @@
flatbuffers "github.com/google/flatbuffers/go"
)
+type TypeAliasesT struct {
+ I8 int8
+ U8 byte
+ I16 int16
+ U16 uint16
+ I32 int32
+ U32 uint32
+ I64 int64
+ U64 uint64
+ F32 float32
+ F64 float64
+ V8 []int8
+ Vf64 []float64
+}
+
+func (t *TypeAliasesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil { return 0 }
+ v8Offset := flatbuffers.UOffsetT(0)
+ if t.V8 != nil {
+ v8Length := len(t.V8)
+ TypeAliasesStartV8Vector(builder, v8Length)
+ for j := v8Length - 1; j >= 0; j-- {
+ builder.PrependInt8(t.V8[j])
+ }
+ v8Offset = builder.EndVector(v8Length)
+ }
+ vf64Offset := flatbuffers.UOffsetT(0)
+ if t.Vf64 != nil {
+ vf64Length := len(t.Vf64)
+ TypeAliasesStartVf64Vector(builder, vf64Length)
+ for j := vf64Length - 1; j >= 0; j-- {
+ builder.PrependFloat64(t.Vf64[j])
+ }
+ vf64Offset = builder.EndVector(vf64Length)
+ }
+ TypeAliasesStart(builder)
+ TypeAliasesAddI8(builder, t.I8)
+ TypeAliasesAddU8(builder, t.U8)
+ TypeAliasesAddI16(builder, t.I16)
+ TypeAliasesAddU16(builder, t.U16)
+ TypeAliasesAddI32(builder, t.I32)
+ TypeAliasesAddU32(builder, t.U32)
+ TypeAliasesAddI64(builder, t.I64)
+ TypeAliasesAddU64(builder, t.U64)
+ TypeAliasesAddF32(builder, t.F32)
+ TypeAliasesAddF64(builder, t.F64)
+ TypeAliasesAddV8(builder, v8Offset)
+ TypeAliasesAddVf64(builder, vf64Offset)
+ return TypeAliasesEnd(builder)
+}
+
+func (rcv *TypeAliases) UnPackTo(t *TypeAliasesT) {
+ t.I8 = rcv.I8()
+ t.U8 = rcv.U8()
+ t.I16 = rcv.I16()
+ t.U16 = rcv.U16()
+ t.I32 = rcv.I32()
+ t.U32 = rcv.U32()
+ t.I64 = rcv.I64()
+ t.U64 = rcv.U64()
+ t.F32 = rcv.F32()
+ t.F64 = rcv.F64()
+ v8Length := rcv.V8Length()
+ t.V8 = make([]int8, v8Length)
+ for j := 0; j < v8Length; j++ {
+ t.V8[j] = rcv.V8(j)
+ }
+ vf64Length := rcv.Vf64Length()
+ t.Vf64 = make([]float64, vf64Length)
+ for j := 0; j < vf64Length; j++ {
+ t.Vf64[j] = rcv.Vf64(j)
+ }
+}
+
+func (rcv *TypeAliases) UnPack() *TypeAliasesT {
+ if rcv == nil { return nil }
+ t := &TypeAliasesT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
type TypeAliases struct {
_tab flatbuffers.Table
}
@@ -17,6 +98,13 @@
return x
}
+func GetSizePrefixedRootAsTypeAliases(buf []byte, offset flatbuffers.UOffsetT) *TypeAliases {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &TypeAliases{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
func (rcv *TypeAliases) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/tests/MyGame/Example/TypeAliases.java b/tests/MyGame/Example/TypeAliases.java
index dde6acb..1112658 100644
--- a/tests/MyGame/Example/TypeAliases.java
+++ b/tests/MyGame/Example/TypeAliases.java
@@ -9,7 +9,7 @@
@SuppressWarnings("unused")
public final class TypeAliases extends Table {
- public static void ValidateVersion() { Constants.FLATBUFFERS_1_11_1(); }
+ public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
public static TypeAliases getRootAsTypeAliases(ByteBuffer _bb) { return getRootAsTypeAliases(_bb, new TypeAliases()); }
public static TypeAliases getRootAsTypeAliases(ByteBuffer _bb, TypeAliases obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
@@ -37,11 +37,15 @@
public boolean mutateF64(double f64) { int o = __offset(22); if (o != 0) { bb.putDouble(o + bb_pos, f64); return true; } else { return false; } }
public byte v8(int j) { int o = __offset(24); return o != 0 ? bb.get(__vector(o) + j * 1) : 0; }
public int v8Length() { int o = __offset(24); return o != 0 ? __vector_len(o) : 0; }
+ public ByteVector v8Vector() { return v8Vector(new ByteVector()); }
+ public ByteVector v8Vector(ByteVector obj) { int o = __offset(24); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
public ByteBuffer v8AsByteBuffer() { return __vector_as_bytebuffer(24, 1); }
public ByteBuffer v8InByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 24, 1); }
public boolean mutateV8(int j, byte v8) { int o = __offset(24); if (o != 0) { bb.put(__vector(o) + j * 1, v8); return true; } else { return false; } }
public double vf64(int j) { int o = __offset(26); return o != 0 ? bb.getDouble(__vector(o) + j * 8) : 0; }
public int vf64Length() { int o = __offset(26); return o != 0 ? __vector_len(o) : 0; }
+ public DoubleVector vf64Vector() { return vf64Vector(new DoubleVector()); }
+ public DoubleVector vf64Vector(DoubleVector obj) { int o = __offset(26); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
public ByteBuffer vf64AsByteBuffer() { return __vector_as_bytebuffer(26, 8); }
public ByteBuffer vf64InByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 26, 8); }
public boolean mutateVf64(int j, double vf64) { int o = __offset(26); if (o != 0) { bb.putDouble(__vector(o) + j * 8, vf64); return true; } else { return false; } }
@@ -87,7 +91,8 @@
public static void addF32(FlatBufferBuilder builder, float f32) { builder.addFloat(8, f32, 0.0f); }
public static void addF64(FlatBufferBuilder builder, double f64) { builder.addDouble(9, f64, 0.0); }
public static void addV8(FlatBufferBuilder builder, int v8Offset) { builder.addOffset(10, v8Offset, 0); }
- public static int createV8Vector(FlatBufferBuilder builder, byte[] data) { builder.startVector(1, data.length, 1); for (int i = data.length - 1; i >= 0; i--) builder.addByte(data[i]); return builder.endVector(); }
+ public static int createV8Vector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); }
+ public static int createV8Vector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); }
public static void startV8Vector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
public static void addVf64(FlatBufferBuilder builder, int vf64Offset) { builder.addOffset(11, vf64Offset, 0); }
public static int createVf64Vector(FlatBufferBuilder builder, double[] data) { builder.startVector(8, data.length, 8); for (int i = data.length - 1; i >= 0; i--) builder.addDouble(data[i]); return builder.endVector(); }
@@ -96,5 +101,12 @@
int o = builder.endTable();
return o;
}
+
+ public static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+ public TypeAliases get(int j) { return get(new TypeAliases(), j); }
+ public TypeAliases get(TypeAliases obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); }
+ }
}
diff --git a/tests/MyGame/Example/TypeAliases.kt b/tests/MyGame/Example/TypeAliases.kt
index d1e8816..d279d14 100644
--- a/tests/MyGame/Example/TypeAliases.kt
+++ b/tests/MyGame/Example/TypeAliases.kt
@@ -204,7 +204,7 @@
}
}
companion object {
- fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
+ fun validateVersion() = Constants.FLATBUFFERS_1_12_0()
fun getRootAsTypeAliases(_bb: ByteBuffer): TypeAliases = getRootAsTypeAliases(_bb, TypeAliases())
fun getRootAsTypeAliases(_bb: ByteBuffer, obj: TypeAliases): TypeAliases {
_bb.order(ByteOrder.LITTLE_ENDIAN)
diff --git a/tests/MyGame/Example/TypeAliases.py b/tests/MyGame/Example/TypeAliases.py
index 81e9b06..0567212 100644
--- a/tests/MyGame/Example/TypeAliases.py
+++ b/tests/MyGame/Example/TypeAliases.py
@@ -3,6 +3,8 @@
# namespace: Example
import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
class TypeAliases(object):
__slots__ = ['_tab']
@@ -115,6 +117,11 @@
return 0
# TypeAliases
+ def V8IsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+ return o == 0
+
+ # TypeAliases
def Vf64(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
if o != 0:
@@ -136,6 +143,11 @@
return self._tab.VectorLen(o)
return 0
+ # TypeAliases
+ def Vf64IsNone(self):
+ 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)
@@ -152,3 +164,102 @@
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()
+
+try:
+ from typing import List
+except:
+ pass
+
+class TypeAliasesT(object):
+
+ # TypeAliasesT
+ def __init__(self):
+ self.i8 = 0 # type: int
+ self.u8 = 0 # type: int
+ self.i16 = 0 # type: int
+ self.u16 = 0 # type: int
+ self.i32 = 0 # type: int
+ self.u32 = 0 # type: int
+ self.i64 = 0 # type: int
+ self.u64 = 0 # type: int
+ self.f32 = 0.0 # type: float
+ self.f64 = 0.0 # type: float
+ self.v8 = None # type: List[int]
+ self.vf64 = None # type: List[float]
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ typeAliases = TypeAliases()
+ typeAliases.Init(buf, pos)
+ return cls.InitFromObj(typeAliases)
+
+ @classmethod
+ def InitFromObj(cls, typeAliases):
+ x = TypeAliasesT()
+ x._UnPack(typeAliases)
+ return x
+
+ # TypeAliasesT
+ def _UnPack(self, typeAliases):
+ if typeAliases is None:
+ return
+ self.i8 = typeAliases.I8()
+ self.u8 = typeAliases.U8()
+ self.i16 = typeAliases.I16()
+ self.u16 = typeAliases.U16()
+ self.i32 = typeAliases.I32()
+ self.u32 = typeAliases.U32()
+ self.i64 = typeAliases.I64()
+ self.u64 = typeAliases.U64()
+ self.f32 = typeAliases.F32()
+ self.f64 = typeAliases.F64()
+ if not typeAliases.V8IsNone():
+ if np is None:
+ self.v8 = []
+ for i in range(typeAliases.V8Length()):
+ self.v8.append(typeAliases.V8(i))
+ else:
+ self.v8 = typeAliases.V8AsNumpy()
+ if not typeAliases.Vf64IsNone():
+ if np is None:
+ self.vf64 = []
+ for i in range(typeAliases.Vf64Length()):
+ self.vf64.append(typeAliases.Vf64(i))
+ else:
+ self.vf64 = typeAliases.Vf64AsNumpy()
+
+ # TypeAliasesT
+ def Pack(self, builder):
+ if self.v8 is not None:
+ if np is not None and type(self.v8) is np.ndarray:
+ v8 = builder.CreateNumpyVector(self.v8)
+ else:
+ TypeAliasesStartV8Vector(builder, len(self.v8))
+ for i in reversed(range(len(self.v8))):
+ builder.PrependByte(self.v8[i])
+ v8 = builder.EndVector(len(self.v8))
+ if self.vf64 is not None:
+ if np is not None and type(self.vf64) is np.ndarray:
+ vf64 = builder.CreateNumpyVector(self.vf64)
+ else:
+ TypeAliasesStartVf64Vector(builder, len(self.vf64))
+ for i in reversed(range(len(self.vf64))):
+ builder.PrependFloat64(self.vf64[i])
+ vf64 = builder.EndVector(len(self.vf64))
+ TypeAliasesStart(builder)
+ TypeAliasesAddI8(builder, self.i8)
+ TypeAliasesAddU8(builder, self.u8)
+ TypeAliasesAddI16(builder, self.i16)
+ TypeAliasesAddU16(builder, self.u16)
+ TypeAliasesAddI32(builder, self.i32)
+ TypeAliasesAddU32(builder, self.u32)
+ TypeAliasesAddI64(builder, self.i64)
+ TypeAliasesAddU64(builder, self.u64)
+ TypeAliasesAddF32(builder, self.f32)
+ TypeAliasesAddF64(builder, self.f64)
+ if self.v8 is not None:
+ TypeAliasesAddV8(builder, v8)
+ if self.vf64 is not None:
+ TypeAliasesAddVf64(builder, vf64)
+ typeAliases = TypeAliasesEnd(builder)
+ return typeAliases
diff --git a/tests/MyGame/Example/Vec3.cs b/tests/MyGame/Example/Vec3.cs
index 1dbb315..54fc8f9 100644
--- a/tests/MyGame/Example/Vec3.cs
+++ b/tests/MyGame/Example/Vec3.cs
@@ -6,6 +6,7 @@
{
using global::System;
+using global::System.Collections.Generic;
using global::FlatBuffers;
public struct Vec3 : IFlatbufferObject
@@ -43,7 +44,59 @@
builder.PutFloat(X);
return new Offset<MyGame.Example.Vec3>(builder.Offset);
}
+ public Vec3T UnPack() {
+ var _o = new Vec3T();
+ this.UnPackTo(_o);
+ return _o;
+ }
+ public void UnPackTo(Vec3T _o) {
+ _o.X = this.X;
+ _o.Y = this.Y;
+ _o.Z = this.Z;
+ _o.Test1 = this.Test1;
+ _o.Test2 = this.Test2;
+ _o.Test3 = this.Test3.UnPack();
+ }
+ public static Offset<MyGame.Example.Vec3> Pack(FlatBufferBuilder builder, Vec3T _o) {
+ if (_o == null) return default(Offset<MyGame.Example.Vec3>);
+ var _test3_a = _o.Test3.A;
+ var _test3_b = _o.Test3.B;
+ return CreateVec3(
+ builder,
+ _o.X,
+ _o.Y,
+ _o.Z,
+ _o.Test1,
+ _o.Test2,
+ _test3_a,
+ _test3_b);
+ }
};
+public class Vec3T
+{
+ [Newtonsoft.Json.JsonProperty("x")]
+ public float X { get; set; }
+ [Newtonsoft.Json.JsonProperty("y")]
+ public float Y { get; set; }
+ [Newtonsoft.Json.JsonProperty("z")]
+ public float Z { get; set; }
+ [Newtonsoft.Json.JsonProperty("test1")]
+ public double Test1 { get; set; }
+ [Newtonsoft.Json.JsonProperty("test2")]
+ public MyGame.Example.Color Test2 { get; set; }
+ [Newtonsoft.Json.JsonProperty("test3")]
+ public MyGame.Example.TestT Test3 { get; set; }
+
+ public Vec3T() {
+ this.X = 0.0f;
+ this.Y = 0.0f;
+ this.Z = 0.0f;
+ this.Test1 = 0.0;
+ this.Test2 = 0;
+ this.Test3 = new MyGame.Example.TestT();
+ }
+}
+
}
diff --git a/tests/MyGame/Example/Vec3.go b/tests/MyGame/Example/Vec3.go
index 9131afd..08311ed 100644
--- a/tests/MyGame/Example/Vec3.go
+++ b/tests/MyGame/Example/Vec3.go
@@ -6,6 +6,35 @@
flatbuffers "github.com/google/flatbuffers/go"
)
+type Vec3T struct {
+ X float32
+ Y float32
+ Z float32
+ Test1 float64
+ Test2 Color
+ Test3 *TestT
+}
+
+func (t *Vec3T) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ 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) {
+ t.X = rcv.X()
+ t.Y = rcv.Y()
+ t.Z = rcv.Z()
+ t.Test1 = rcv.Test1()
+ t.Test2 = rcv.Test2()
+ t.Test3 = rcv.Test3(nil).UnPack()
+}
+
+func (rcv *Vec3) UnPack() *Vec3T {
+ if rcv == nil { return nil }
+ t := &Vec3T{}
+ rcv.UnPackTo(t)
+ return t
+}
+
type Vec3 struct {
_tab flatbuffers.Struct
}
diff --git a/tests/MyGame/Example/Vec3.java b/tests/MyGame/Example/Vec3.java
index 0b67c74..89d38a1 100644
--- a/tests/MyGame/Example/Vec3.java
+++ b/tests/MyGame/Example/Vec3.java
@@ -41,5 +41,12 @@
builder.putFloat(x);
return builder.offset();
}
+
+ public static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+ public Vec3 get(int j) { return get(new Vec3(), j); }
+ public Vec3 get(Vec3 obj, int j) { return obj.__assign(__element(j), bb); }
+ }
}
diff --git a/tests/MyGame/Example/Vec3.py b/tests/MyGame/Example/Vec3.py
index 1f32390..69cd511 100644
--- a/tests/MyGame/Example/Vec3.py
+++ b/tests/MyGame/Example/Vec3.py
@@ -3,10 +3,16 @@
# namespace: Example
import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
class Vec3(object):
__slots__ = ['_tab']
+ @classmethod
+ def SizeOf(cls):
+ return 32
+
# Vec3
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
@@ -42,3 +48,48 @@
builder.PrependFloat32(y)
builder.PrependFloat32(x)
return builder.Offset()
+
+import MyGame.Example.Test
+try:
+ from typing import Optional
+except:
+ pass
+
+class Vec3T(object):
+
+ # Vec3T
+ def __init__(self):
+ self.x = 0.0 # type: float
+ self.y = 0.0 # type: float
+ self.z = 0.0 # type: float
+ self.test1 = 0.0 # type: float
+ self.test2 = 0 # type: int
+ self.test3 = None # type: Optional[MyGame.Example.Test.TestT]
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ vec3 = Vec3()
+ vec3.Init(buf, pos)
+ return cls.InitFromObj(vec3)
+
+ @classmethod
+ def InitFromObj(cls, vec3):
+ x = Vec3T()
+ x._UnPack(vec3)
+ return x
+
+ # Vec3T
+ def _UnPack(self, vec3):
+ if vec3 is None:
+ return
+ self.x = vec3.X()
+ self.y = vec3.Y()
+ self.z = vec3.Z()
+ self.test1 = vec3.Test1()
+ self.test2 = vec3.Test2()
+ if vec3.Test3(MyGame.Example.Test.Test()) is not None:
+ self.test3 = MyGame.Example.Test.TestT.InitFromObj(vec3.Test3(MyGame.Example.Test.Test()))
+
+ # Vec3T
+ def Pack(self, builder):
+ return CreateVec3(builder, self.x, self.y, self.z, self.test1, self.test2, self.test3.a, self.test3.b)
diff --git a/tests/MyGame/Example/monster_test_grpc_fb.py b/tests/MyGame/Example/monster_test_grpc_fb.py
new file mode 100644
index 0000000..8375c98
--- /dev/null
+++ b/tests/MyGame/Example/monster_test_grpc_fb.py
@@ -0,0 +1,241 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+import grpc
+
+
+class MonsterStorageStub(object):
+
+ def __init__(self, channel):
+ """Constructor.
+
+ Args:
+ channel: A grpc.Channel.
+ """
+ self.Store = channel.unary_unary(
+ '/MyGame.Example.MonsterStorage/Store',
+
+
+ )
+ self.Retrieve = channel.unary_stream(
+ '/MyGame.Example.MonsterStorage/Retrieve',
+
+
+ )
+ self.GetMaxHitPoint = channel.stream_unary(
+ '/MyGame.Example.MonsterStorage/GetMaxHitPoint',
+
+
+ )
+ self.GetMinMaxHitPoints = channel.unary_unary(
+ '/MyGame.Example.MonsterStorage/GetMinMaxHitPoints',
+
+
+ )
+
+
+class MonsterStorageServicer(object):
+
+ def Store(self, request, context):
+ context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+ context.set_details('Method not implemented!')
+ raise NotImplementedError('Method not implemented!')
+
+ def Retrieve(self, request, context):
+ context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+ context.set_details('Method not implemented!')
+ raise NotImplementedError('Method not implemented!')
+
+ def GetMaxHitPoint(self, request_iterator, context):
+ context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+ context.set_details('Method not implemented!')
+ raise NotImplementedError('Method not implemented!')
+
+ def GetMinMaxHitPoints(self, request, context):
+ context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+ context.set_details('Method not implemented!')
+ raise NotImplementedError('Method not implemented!')
+
+
+def add_MonsterStorageServicer_to_server(servicer, server):
+ rpc_method_handlers = {
+ 'Store': grpc.unary_unary_rpc_method_handler(
+ servicer.Store,
+
+
+ ),
+ 'Retrieve': grpc.unary_stream_rpc_method_handler(
+ servicer.Retrieve,
+
+
+ ),
+ 'GetMaxHitPoint': grpc.stream_unary_rpc_method_handler(
+ servicer.GetMaxHitPoint,
+
+
+ ),
+ 'GetMinMaxHitPoints': grpc.unary_unary_rpc_method_handler(
+ servicer.GetMinMaxHitPoints,
+
+
+ ),
+ }
+ generic_handler = grpc.method_handlers_generic_handler(
+ 'MyGame.Example.MonsterStorage', rpc_method_handlers)
+ server.add_generic_rpc_handlers((generic_handler,))
+try:
+ # THESE ELEMENTS WILL BE DEPRECATED.
+ # Please use the generated *_pb2_grpc.py files instead.
+ import grpc
+ from grpc.beta import implementations as beta_implementations
+ from grpc.beta import interfaces as beta_interfaces
+ from grpc.framework.common import cardinality
+ from grpc.framework.interfaces.face import utilities as face_utilities
+
+
+ class MonsterStorageStub(object):
+
+ def __init__(self, channel):
+ """Constructor.
+
+ Args:
+ channel: A grpc.Channel.
+ """
+ self.Store = channel.unary_unary(
+ '/MyGame.Example.MonsterStorage/Store',
+
+
+ )
+ self.Retrieve = channel.unary_stream(
+ '/MyGame.Example.MonsterStorage/Retrieve',
+
+
+ )
+ self.GetMaxHitPoint = channel.stream_unary(
+ '/MyGame.Example.MonsterStorage/GetMaxHitPoint',
+
+
+ )
+ self.GetMinMaxHitPoints = channel.unary_unary(
+ '/MyGame.Example.MonsterStorage/GetMinMaxHitPoints',
+
+
+ )
+
+
+ class MonsterStorageServicer(object):
+
+ def Store(self, request, context):
+ context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+ context.set_details('Method not implemented!')
+ raise NotImplementedError('Method not implemented!')
+
+ def Retrieve(self, request, context):
+ context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+ context.set_details('Method not implemented!')
+ raise NotImplementedError('Method not implemented!')
+
+ def GetMaxHitPoint(self, request_iterator, context):
+ context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+ context.set_details('Method not implemented!')
+ raise NotImplementedError('Method not implemented!')
+
+ def GetMinMaxHitPoints(self, request, context):
+ context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+ context.set_details('Method not implemented!')
+ raise NotImplementedError('Method not implemented!')
+
+
+ def add_MonsterStorageServicer_to_server(servicer, server):
+ rpc_method_handlers = {
+ 'Store': grpc.unary_unary_rpc_method_handler(
+ servicer.Store,
+
+
+ ),
+ 'Retrieve': grpc.unary_stream_rpc_method_handler(
+ servicer.Retrieve,
+
+
+ ),
+ 'GetMaxHitPoint': grpc.stream_unary_rpc_method_handler(
+ servicer.GetMaxHitPoint,
+
+
+ ),
+ 'GetMinMaxHitPoints': grpc.unary_unary_rpc_method_handler(
+ servicer.GetMinMaxHitPoints,
+
+
+ ),
+ }
+ generic_handler = grpc.method_handlers_generic_handler(
+ 'MyGame.Example.MonsterStorage', rpc_method_handlers)
+ server.add_generic_rpc_handlers((generic_handler,))
+
+
+ class BetaMonsterStorageServicer(object):
+ """The Beta API is deprecated for 0.15.0 and later.
+
+ It is recommended to use the GA API (classes and functions in this
+ file not marked beta) for all further purposes. This class was generated
+ only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0."""
+ def Store(self, request, context):
+ context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)
+ def Retrieve(self, request, context):
+ context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)
+ def GetMaxHitPoint(self, request_iterator, context):
+ context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)
+ def GetMinMaxHitPoints(self, request, context):
+ context.code(beta_interfaces.StatusCode.UNIMPLEMENTED)
+
+
+ class BetaMonsterStorageStub(object):
+ """The Beta API is deprecated for 0.15.0 and later.
+
+ It is recommended to use the GA API (classes and functions in this
+ file not marked beta) for all further purposes. This class was generated
+ only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0."""
+ def Store(self, request, timeout, metadata=None, with_call=False, protocol_options=None):
+ raise NotImplementedError()
+ Store.future = None
+ def Retrieve(self, request, timeout, metadata=None, with_call=False, protocol_options=None):
+ raise NotImplementedError()
+ def GetMaxHitPoint(self, request_iterator, timeout, metadata=None, with_call=False, protocol_options=None):
+ raise NotImplementedError()
+ GetMaxHitPoint.future = None
+ def GetMinMaxHitPoints(self, request, timeout, metadata=None, with_call=False, protocol_options=None):
+ raise NotImplementedError()
+ GetMinMaxHitPoints.future = None
+
+
+ def beta_create_MonsterStorage_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None):
+ """The Beta API is deprecated for 0.15.0 and later.
+
+ It is recommended to use the GA API (classes and functions in this
+ file not marked beta) for all further purposes. This function was
+ generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0"""
+ method_implementations = {
+ ('MyGame.Example.MonsterStorage', 'GetMaxHitPoint'): face_utilities.stream_unary_inline(servicer.GetMaxHitPoint),
+ ('MyGame.Example.MonsterStorage', 'GetMinMaxHitPoints'): face_utilities.unary_unary_inline(servicer.GetMinMaxHitPoints),
+ ('MyGame.Example.MonsterStorage', 'Retrieve'): face_utilities.unary_stream_inline(servicer.Retrieve),
+ ('MyGame.Example.MonsterStorage', 'Store'): face_utilities.unary_unary_inline(servicer.Store),
+ }
+ server_options = beta_implementations.server_options(thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout)
+ return beta_implementations.server(method_implementations, options=server_options)
+
+
+ def beta_create_MonsterStorage_stub(channel, host=None, metadata_transformer=None, pool=None, pool_size=None):
+ """The Beta API is deprecated for 0.15.0 and later.
+
+ It is recommended to use the GA API (classes and functions in this
+ file not marked beta) for all further purposes. This function was
+ generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0"""
+ cardinalities = {
+ 'GetMaxHitPoint': cardinality.Cardinality.STREAM_UNARY,
+ 'GetMinMaxHitPoints': cardinality.Cardinality.UNARY_UNARY,
+ 'Retrieve': cardinality.Cardinality.UNARY_STREAM,
+ 'Store': cardinality.Cardinality.UNARY_UNARY,
+ }
+ stub_options = beta_implementations.stub_options(host=host, metadata_transformer=metadata_transformer, thread_pool=pool, thread_pool_size=pool_size)
+ return beta_implementations.dynamic_stub(channel, 'MyGame.Example.MonsterStorage', cardinalities, options=stub_options)
+except ImportError:
+ pass
\ No newline at end of file
diff --git a/tests/MyGame/Example2/Monster.cs b/tests/MyGame/Example2/Monster.cs
index a6e9dce..3291ee8 100644
--- a/tests/MyGame/Example2/Monster.cs
+++ b/tests/MyGame/Example2/Monster.cs
@@ -6,13 +6,14 @@
{
using global::System;
+using global::System.Collections.Generic;
using global::FlatBuffers;
public struct Monster : IFlatbufferObject
{
private Table __p;
public ByteBuffer ByteBuffer { get { return __p.bb; } }
- public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_11_1(); }
+ public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_12_0(); }
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 void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
@@ -24,7 +25,26 @@
int o = builder.EndTable();
return new Offset<MyGame.Example2.Monster>(o);
}
+ public MonsterT UnPack() {
+ var _o = new MonsterT();
+ this.UnPackTo(_o);
+ return _o;
+ }
+ public void UnPackTo(MonsterT _o) {
+ }
+ public static Offset<MyGame.Example2.Monster> Pack(FlatBufferBuilder builder, MonsterT _o) {
+ if (_o == null) return default(Offset<MyGame.Example2.Monster>);
+ StartMonster(builder);
+ return EndMonster(builder);
+ }
};
+public class MonsterT
+{
+
+ public MonsterT() {
+ }
+}
+
}
diff --git a/tests/MyGame/Example2/Monster.go b/tests/MyGame/Example2/Monster.go
index d0fae94..792011f 100644
--- a/tests/MyGame/Example2/Monster.go
+++ b/tests/MyGame/Example2/Monster.go
@@ -6,6 +6,25 @@
flatbuffers "github.com/google/flatbuffers/go"
)
+type MonsterT struct {
+}
+
+func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil { return 0 }
+ MonsterStart(builder)
+ return MonsterEnd(builder)
+}
+
+func (rcv *Monster) UnPackTo(t *MonsterT) {
+}
+
+func (rcv *Monster) UnPack() *MonsterT {
+ if rcv == nil { return nil }
+ t := &MonsterT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
type Monster struct {
_tab flatbuffers.Table
}
@@ -17,6 +36,13 @@
return x
}
+func GetSizePrefixedRootAsMonster(buf []byte, offset flatbuffers.UOffsetT) *Monster {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &Monster{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
func (rcv *Monster) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/tests/MyGame/Example2/Monster.java b/tests/MyGame/Example2/Monster.java
index 7e0cae1..950c427 100644
--- a/tests/MyGame/Example2/Monster.java
+++ b/tests/MyGame/Example2/Monster.java
@@ -9,7 +9,7 @@
@SuppressWarnings("unused")
public final class Monster extends Table {
- public static void ValidateVersion() { Constants.FLATBUFFERS_1_11_1(); }
+ public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
public static Monster getRootAsMonster(ByteBuffer _bb) { return getRootAsMonster(_bb, new Monster()); }
public static Monster getRootAsMonster(ByteBuffer _bb, Monster obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
@@ -21,5 +21,12 @@
int o = builder.endTable();
return o;
}
+
+ public static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+ public Monster get(int j) { return get(new Monster(), j); }
+ public Monster get(Monster obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); }
+ }
}
diff --git a/tests/MyGame/Example2/Monster.kt b/tests/MyGame/Example2/Monster.kt
index de587ba..f1df2e0 100644
--- a/tests/MyGame/Example2/Monster.kt
+++ b/tests/MyGame/Example2/Monster.kt
@@ -18,7 +18,7 @@
return this
}
companion object {
- fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
+ fun validateVersion() = Constants.FLATBUFFERS_1_12_0()
fun getRootAsMonster(_bb: ByteBuffer): Monster = getRootAsMonster(_bb, Monster())
fun getRootAsMonster(_bb: ByteBuffer, obj: Monster): Monster {
_bb.order(ByteOrder.LITTLE_ENDIAN)
diff --git a/tests/MyGame/Example2/Monster.py b/tests/MyGame/Example2/Monster.py
index 44cc906..538b035 100644
--- a/tests/MyGame/Example2/Monster.py
+++ b/tests/MyGame/Example2/Monster.py
@@ -3,6 +3,8 @@
# namespace: Example2
import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
class Monster(object):
__slots__ = ['_tab']
@@ -24,3 +26,33 @@
def MonsterStart(builder): builder.StartObject(0)
def MonsterEnd(builder): return builder.EndObject()
+
+
+class MonsterT(object):
+
+ # MonsterT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ monster = Monster()
+ monster.Init(buf, pos)
+ return cls.InitFromObj(monster)
+
+ @classmethod
+ def InitFromObj(cls, monster):
+ x = MonsterT()
+ x._UnPack(monster)
+ return x
+
+ # MonsterT
+ def _UnPack(self, monster):
+ if monster is None:
+ return
+
+ # MonsterT
+ def Pack(self, builder):
+ MonsterStart(builder)
+ monster = MonsterEnd(builder)
+ return monster
diff --git a/tests/MyGame/InParentNamespace.cs b/tests/MyGame/InParentNamespace.cs
index 869c400..efefa34 100644
--- a/tests/MyGame/InParentNamespace.cs
+++ b/tests/MyGame/InParentNamespace.cs
@@ -6,13 +6,14 @@
{
using global::System;
+using global::System.Collections.Generic;
using global::FlatBuffers;
public struct InParentNamespace : IFlatbufferObject
{
private Table __p;
public ByteBuffer ByteBuffer { get { return __p.bb; } }
- public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_11_1(); }
+ public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_12_0(); }
public static InParentNamespace GetRootAsInParentNamespace(ByteBuffer _bb) { return GetRootAsInParentNamespace(_bb, new InParentNamespace()); }
public static InParentNamespace GetRootAsInParentNamespace(ByteBuffer _bb, InParentNamespace obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
@@ -24,7 +25,26 @@
int o = builder.EndTable();
return new Offset<MyGame.InParentNamespace>(o);
}
+ public InParentNamespaceT UnPack() {
+ var _o = new InParentNamespaceT();
+ this.UnPackTo(_o);
+ return _o;
+ }
+ public void UnPackTo(InParentNamespaceT _o) {
+ }
+ public static Offset<MyGame.InParentNamespace> Pack(FlatBufferBuilder builder, InParentNamespaceT _o) {
+ if (_o == null) return default(Offset<MyGame.InParentNamespace>);
+ StartInParentNamespace(builder);
+ return EndInParentNamespace(builder);
+ }
};
+public class InParentNamespaceT
+{
+
+ public InParentNamespaceT() {
+ }
+}
+
}
diff --git a/tests/MyGame/InParentNamespace.go b/tests/MyGame/InParentNamespace.go
index fc6ce32..2c4a4e0 100644
--- a/tests/MyGame/InParentNamespace.go
+++ b/tests/MyGame/InParentNamespace.go
@@ -6,6 +6,25 @@
flatbuffers "github.com/google/flatbuffers/go"
)
+type InParentNamespaceT struct {
+}
+
+func (t *InParentNamespaceT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil { return 0 }
+ InParentNamespaceStart(builder)
+ return InParentNamespaceEnd(builder)
+}
+
+func (rcv *InParentNamespace) UnPackTo(t *InParentNamespaceT) {
+}
+
+func (rcv *InParentNamespace) UnPack() *InParentNamespaceT {
+ if rcv == nil { return nil }
+ t := &InParentNamespaceT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
type InParentNamespace struct {
_tab flatbuffers.Table
}
@@ -17,6 +36,13 @@
return x
}
+func GetSizePrefixedRootAsInParentNamespace(buf []byte, offset flatbuffers.UOffsetT) *InParentNamespace {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &InParentNamespace{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
func (rcv *InParentNamespace) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
diff --git a/tests/MyGame/InParentNamespace.java b/tests/MyGame/InParentNamespace.java
index fd10bc3..20a1ea8 100644
--- a/tests/MyGame/InParentNamespace.java
+++ b/tests/MyGame/InParentNamespace.java
@@ -9,7 +9,7 @@
@SuppressWarnings("unused")
public final class InParentNamespace extends Table {
- public static void ValidateVersion() { Constants.FLATBUFFERS_1_11_1(); }
+ public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
public static InParentNamespace getRootAsInParentNamespace(ByteBuffer _bb) { return getRootAsInParentNamespace(_bb, new InParentNamespace()); }
public static InParentNamespace getRootAsInParentNamespace(ByteBuffer _bb, InParentNamespace obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
@@ -21,5 +21,12 @@
int o = builder.endTable();
return o;
}
+
+ public static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+ public InParentNamespace get(int j) { return get(new InParentNamespace(), j); }
+ public InParentNamespace get(InParentNamespace obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); }
+ }
}
diff --git a/tests/MyGame/InParentNamespace.kt b/tests/MyGame/InParentNamespace.kt
index 76779fc..02f078e 100644
--- a/tests/MyGame/InParentNamespace.kt
+++ b/tests/MyGame/InParentNamespace.kt
@@ -18,7 +18,7 @@
return this
}
companion object {
- fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
+ fun validateVersion() = Constants.FLATBUFFERS_1_12_0()
fun getRootAsInParentNamespace(_bb: ByteBuffer): InParentNamespace = getRootAsInParentNamespace(_bb, InParentNamespace())
fun getRootAsInParentNamespace(_bb: ByteBuffer, obj: InParentNamespace): InParentNamespace {
_bb.order(ByteOrder.LITTLE_ENDIAN)
diff --git a/tests/MyGame/InParentNamespace.py b/tests/MyGame/InParentNamespace.py
index 3bfcca7..e78ea6a 100644
--- a/tests/MyGame/InParentNamespace.py
+++ b/tests/MyGame/InParentNamespace.py
@@ -3,6 +3,8 @@
# namespace: MyGame
import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
class InParentNamespace(object):
__slots__ = ['_tab']
@@ -24,3 +26,33 @@
def InParentNamespaceStart(builder): builder.StartObject(0)
def InParentNamespaceEnd(builder): return builder.EndObject()
+
+
+class InParentNamespaceT(object):
+
+ # InParentNamespaceT
+ def __init__(self):
+ pass
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ inParentNamespace = InParentNamespace()
+ inParentNamespace.Init(buf, pos)
+ return cls.InitFromObj(inParentNamespace)
+
+ @classmethod
+ def InitFromObj(cls, inParentNamespace):
+ x = InParentNamespaceT()
+ x._UnPack(inParentNamespace)
+ return x
+
+ # InParentNamespaceT
+ def _UnPack(self, inParentNamespace):
+ if inParentNamespace is None:
+ return
+
+ # InParentNamespaceT
+ def Pack(self, builder):
+ InParentNamespaceStart(builder)
+ inParentNamespace = InParentNamespaceEnd(builder)
+ return inParentNamespace
diff --git a/tests/MyGame/MonsterExtra.cs b/tests/MyGame/MonsterExtra.cs
index 5706390..d74ae8b 100644
--- a/tests/MyGame/MonsterExtra.cs
+++ b/tests/MyGame/MonsterExtra.cs
@@ -6,13 +6,14 @@
{
using global::System;
+using global::System.Collections.Generic;
using global::FlatBuffers;
public struct MonsterExtra : IFlatbufferObject
{
private Table __p;
public ByteBuffer ByteBuffer { get { return __p.bb; } }
- public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_11_1(); }
+ public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_1_12_0(); }
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"); }
@@ -38,7 +39,7 @@
public double Dvec(int j) { int o = __p.__offset(20); return o != 0 ? __p.bb.GetDouble(__p.__vector(o) + j * 8) : (double)0; }
public int DvecLength { get { int o = __p.__offset(20); return o != 0 ? __p.__vector_len(o) : 0; } }
#if ENABLE_SPAN_T
- public Span<byte> GetDvecBytes() { return __p.__vector_as_span(20); }
+ public Span<double> GetDvecBytes() { return __p.__vector_as_span<double>(20, 8); }
#else
public ArraySegment<byte>? GetDvecBytes() { return __p.__vector_as_arraysegment(20); }
#endif
@@ -47,7 +48,7 @@
public float Fvec(int j) { int o = __p.__offset(22); return o != 0 ? __p.bb.GetFloat(__p.__vector(o) + j * 4) : (float)0; }
public int FvecLength { get { int o = __p.__offset(22); return o != 0 ? __p.__vector_len(o) : 0; } }
#if ENABLE_SPAN_T
- public Span<byte> GetFvecBytes() { return __p.__vector_as_span(22); }
+ public Span<float> GetFvecBytes() { return __p.__vector_as_span<float>(22, 4); }
#else
public ArraySegment<byte>? GetFvecBytes() { return __p.__vector_as_arraysegment(22); }
#endif
@@ -65,7 +66,7 @@
float f3 = Single.NegativeInfinity,
VectorOffset dvecOffset = default(VectorOffset),
VectorOffset fvecOffset = default(VectorOffset)) {
- builder.StartTable(10);
+ builder.StartTable(11);
MonsterExtra.AddD3(builder, d3);
MonsterExtra.AddD2(builder, d2);
MonsterExtra.AddD1(builder, d1);
@@ -79,7 +80,7 @@
return MonsterExtra.EndMonsterExtra(builder);
}
- public static void StartMonsterExtra(FlatBufferBuilder builder) { builder.StartTable(10); }
+ public static void StartMonsterExtra(FlatBufferBuilder builder) { builder.StartTable(11); }
public static void AddD0(FlatBufferBuilder builder, double d0) { builder.AddDouble(0, d0, Double.NaN); }
public static void AddD1(FlatBufferBuilder builder, double d1) { builder.AddDouble(1, d1, Double.NaN); }
public static void AddD2(FlatBufferBuilder builder, double d2) { builder.AddDouble(2, d2, Double.PositiveInfinity); }
@@ -102,7 +103,103 @@
}
public static void FinishMonsterExtraBuffer(FlatBufferBuilder builder, Offset<MyGame.MonsterExtra> offset) { builder.Finish(offset.Value, "MONE"); }
public static void FinishSizePrefixedMonsterExtraBuffer(FlatBufferBuilder builder, Offset<MyGame.MonsterExtra> offset) { builder.FinishSizePrefixed(offset.Value, "MONE"); }
+ public MonsterExtraT UnPack() {
+ var _o = new MonsterExtraT();
+ this.UnPackTo(_o);
+ return _o;
+ }
+ public void UnPackTo(MonsterExtraT _o) {
+ _o.D0 = this.D0;
+ _o.D1 = this.D1;
+ _o.D2 = this.D2;
+ _o.D3 = this.D3;
+ _o.F0 = this.F0;
+ _o.F1 = this.F1;
+ _o.F2 = this.F2;
+ _o.F3 = this.F3;
+ _o.Dvec = new List<double>();
+ for (var _j = 0; _j < this.DvecLength; ++_j) {_o.Dvec.Add(this.Dvec(_j));}
+ _o.Fvec = new List<float>();
+ for (var _j = 0; _j < this.FvecLength; ++_j) {_o.Fvec.Add(this.Fvec(_j));}
+ }
+ public static Offset<MyGame.MonsterExtra> Pack(FlatBufferBuilder builder, MonsterExtraT _o) {
+ if (_o == null) return default(Offset<MyGame.MonsterExtra>);
+ var _dvec = default(VectorOffset);
+ if (_o.Dvec != null) {
+ var __dvec = _o.Dvec.ToArray();
+ _dvec = CreateDvecVector(builder, __dvec);
+ }
+ var _fvec = default(VectorOffset);
+ if (_o.Fvec != null) {
+ var __fvec = _o.Fvec.ToArray();
+ _fvec = CreateFvecVector(builder, __fvec);
+ }
+ return CreateMonsterExtra(
+ builder,
+ _o.D0,
+ _o.D1,
+ _o.D2,
+ _o.D3,
+ _o.F0,
+ _o.F1,
+ _o.F2,
+ _o.F3,
+ _dvec,
+ _fvec);
+ }
};
+public class MonsterExtraT
+{
+ [Newtonsoft.Json.JsonProperty("d0")]
+ public double D0 { get; set; }
+ [Newtonsoft.Json.JsonProperty("d1")]
+ public double D1 { get; set; }
+ [Newtonsoft.Json.JsonProperty("d2")]
+ public double D2 { get; set; }
+ [Newtonsoft.Json.JsonProperty("d3")]
+ public double D3 { get; set; }
+ [Newtonsoft.Json.JsonProperty("f0")]
+ public float F0 { get; set; }
+ [Newtonsoft.Json.JsonProperty("f1")]
+ public float F1 { get; set; }
+ [Newtonsoft.Json.JsonProperty("f2")]
+ public float F2 { get; set; }
+ [Newtonsoft.Json.JsonProperty("f3")]
+ public float F3 { get; set; }
+ [Newtonsoft.Json.JsonProperty("dvec")]
+ public List<double> Dvec { get; set; }
+ [Newtonsoft.Json.JsonProperty("fvec")]
+ public List<float> Fvec { get; set; }
+
+ public MonsterExtraT() {
+ this.D0 = Double.NaN;
+ this.D1 = Double.NaN;
+ this.D2 = Double.PositiveInfinity;
+ this.D3 = Double.NegativeInfinity;
+ this.F0 = Single.NaN;
+ this.F1 = Single.NaN;
+ this.F2 = Single.PositiveInfinity;
+ this.F3 = Single.NegativeInfinity;
+ this.Dvec = null;
+ this.Fvec = null;
+ }
+
+ public static MonsterExtraT DeserializeFromJson(string jsonText) {
+ return Newtonsoft.Json.JsonConvert.DeserializeObject<MonsterExtraT>(jsonText);
+ }
+ public string SerializeToJson() {
+ return Newtonsoft.Json.JsonConvert.SerializeObject(this, Newtonsoft.Json.Formatting.Indented);
+ }
+ public static MonsterExtraT DeserializeFromBinary(byte[] fbBuffer) {
+ return MonsterExtra.GetRootAsMonsterExtra(new ByteBuffer(fbBuffer)).UnPack();
+ }
+ public byte[] SerializeToBinary() {
+ var fbb = new FlatBufferBuilder(0x10000);
+ MonsterExtra.FinishMonsterExtraBuffer(fbb, MonsterExtra.Pack(fbb, this));
+ return fbb.DataBuffer.ToSizedArray();
+ }
+}
+
}
diff --git a/tests/MyGame/MonsterExtra.java b/tests/MyGame/MonsterExtra.java
index 3022596..8a5fe75 100644
--- a/tests/MyGame/MonsterExtra.java
+++ b/tests/MyGame/MonsterExtra.java
@@ -9,7 +9,7 @@
@SuppressWarnings("unused")
public final class MonsterExtra extends Table {
- public static void ValidateVersion() { Constants.FLATBUFFERS_1_11_1(); }
+ public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
public static MonsterExtra getRootAsMonsterExtra(ByteBuffer _bb) { return getRootAsMonsterExtra(_bb, new MonsterExtra()); }
public static MonsterExtra getRootAsMonsterExtra(ByteBuffer _bb, MonsterExtra obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
public static boolean MonsterExtraBufferHasIdentifier(ByteBuffer _bb) { return __has_identifier(_bb, "MONE"); }
@@ -34,11 +34,15 @@
public boolean mutateF3(float f3) { int o = __offset(18); if (o != 0) { bb.putFloat(o + bb_pos, f3); return true; } else { return false; } }
public double dvec(int j) { int o = __offset(20); return o != 0 ? bb.getDouble(__vector(o) + j * 8) : 0; }
public int dvecLength() { int o = __offset(20); return o != 0 ? __vector_len(o) : 0; }
+ public DoubleVector dvecVector() { return dvecVector(new DoubleVector()); }
+ public DoubleVector dvecVector(DoubleVector obj) { int o = __offset(20); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
public ByteBuffer dvecAsByteBuffer() { return __vector_as_bytebuffer(20, 8); }
public ByteBuffer dvecInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 20, 8); }
public boolean mutateDvec(int j, double dvec) { int o = __offset(20); if (o != 0) { bb.putDouble(__vector(o) + j * 8, dvec); return true; } else { return false; } }
public float fvec(int j) { int o = __offset(22); return o != 0 ? bb.getFloat(__vector(o) + j * 4) : 0; }
public int fvecLength() { int o = __offset(22); return o != 0 ? __vector_len(o) : 0; }
+ public FloatVector fvecVector() { return fvecVector(new FloatVector()); }
+ public FloatVector fvecVector(FloatVector obj) { int o = __offset(22); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
public ByteBuffer fvecAsByteBuffer() { return __vector_as_bytebuffer(22, 4); }
public ByteBuffer fvecInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 22, 4); }
public boolean mutateFvec(int j, float fvec) { int o = __offset(22); if (o != 0) { bb.putFloat(__vector(o) + j * 4, fvec); return true; } else { return false; } }
@@ -54,7 +58,7 @@
float f3,
int dvecOffset,
int fvecOffset) {
- builder.startTable(10);
+ builder.startTable(11);
MonsterExtra.addD3(builder, d3);
MonsterExtra.addD2(builder, d2);
MonsterExtra.addD1(builder, d1);
@@ -68,7 +72,7 @@
return MonsterExtra.endMonsterExtra(builder);
}
- public static void startMonsterExtra(FlatBufferBuilder builder) { builder.startTable(10); }
+ public static void startMonsterExtra(FlatBufferBuilder builder) { builder.startTable(11); }
public static void addD0(FlatBufferBuilder builder, double d0) { builder.addDouble(0, d0, Double.NaN); }
public static void addD1(FlatBufferBuilder builder, double d1) { builder.addDouble(1, d1, Double.NaN); }
public static void addD2(FlatBufferBuilder builder, double d2) { builder.addDouble(2, d2, Double.POSITIVE_INFINITY); }
@@ -89,5 +93,12 @@
}
public static void finishMonsterExtraBuffer(FlatBufferBuilder builder, int offset) { builder.finish(offset, "MONE"); }
public static void finishSizePrefixedMonsterExtraBuffer(FlatBufferBuilder builder, int offset) { builder.finishSizePrefixed(offset, "MONE"); }
+
+ public static final class Vector extends BaseVector {
+ public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+ public MonsterExtra get(int j) { return get(new MonsterExtra(), j); }
+ public MonsterExtra get(MonsterExtra obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); }
+ }
}
diff --git a/tests/MyGame/MonsterExtra.kt b/tests/MyGame/MonsterExtra.kt
index 96ea731..e025c2f 100644
--- a/tests/MyGame/MonsterExtra.kt
+++ b/tests/MyGame/MonsterExtra.kt
@@ -176,7 +176,7 @@
}
}
companion object {
- fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
+ fun validateVersion() = Constants.FLATBUFFERS_1_12_0()
fun getRootAsMonsterExtra(_bb: ByteBuffer): MonsterExtra = getRootAsMonsterExtra(_bb, MonsterExtra())
fun getRootAsMonsterExtra(_bb: ByteBuffer, obj: MonsterExtra): MonsterExtra {
_bb.order(ByteOrder.LITTLE_ENDIAN)
@@ -184,7 +184,7 @@
}
fun MonsterExtraBufferHasIdentifier(_bb: ByteBuffer) : Boolean = __has_identifier(_bb, "MONE")
fun createMonsterExtra(builder: FlatBufferBuilder, d0: Double, d1: Double, d2: Double, d3: Double, f0: Float, f1: Float, f2: Float, f3: Float, dvecOffset: Int, fvecOffset: Int) : Int {
- builder.startTable(10)
+ builder.startTable(11)
addD3(builder, d3)
addD2(builder, d2)
addD1(builder, d1)
@@ -197,7 +197,7 @@
addF0(builder, f0)
return endMonsterExtra(builder)
}
- fun startMonsterExtra(builder: FlatBufferBuilder) = builder.startTable(10)
+ fun startMonsterExtra(builder: FlatBufferBuilder) = builder.startTable(11)
fun addD0(builder: FlatBufferBuilder, d0: Double) = builder.addDouble(0, d0, Double.NaN)
fun addD1(builder: FlatBufferBuilder, d1: Double) = builder.addDouble(1, d1, Double.NaN)
fun addD2(builder: FlatBufferBuilder, d2: Double) = builder.addDouble(2, d2, Double.POSITIVE_INFINITY)
diff --git a/tests/MyGame/MonsterExtra.py b/tests/MyGame/MonsterExtra.py
index 1f7dcb2..eafea7c 100644
--- a/tests/MyGame/MonsterExtra.py
+++ b/tests/MyGame/MonsterExtra.py
@@ -3,6 +3,8 @@
# namespace: MyGame
import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
class MonsterExtra(object):
__slots__ = ['_tab']
@@ -101,6 +103,11 @@
return 0
# MonsterExtra
+ def DvecIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+ return o == 0
+
+ # MonsterExtra
def Fvec(self, j):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
if o != 0:
@@ -122,7 +129,12 @@
return self._tab.VectorLen(o)
return 0
-def MonsterExtraStart(builder): builder.StartObject(10)
+ # MonsterExtra
+ def FvecIsNone(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+ return o == 0
+
+def MonsterExtraStart(builder): builder.StartObject(11)
def MonsterExtraAddD0(builder, d0): builder.PrependFloat64Slot(0, d0, float('nan'))
def MonsterExtraAddD1(builder, d1): builder.PrependFloat64Slot(1, d1, float('nan'))
def MonsterExtraAddD2(builder, d2): builder.PrependFloat64Slot(2, d2, float('inf'))
@@ -136,3 +148,96 @@
def MonsterExtraAddFvec(builder, fvec): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0)
def MonsterExtraStartFvecVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def MonsterExtraEnd(builder): return builder.EndObject()
+
+try:
+ from typing import List
+except:
+ pass
+
+class MonsterExtraT(object):
+
+ # MonsterExtraT
+ def __init__(self):
+ self.d0 = float('nan') # type: float
+ self.d1 = float('nan') # type: float
+ self.d2 = float('inf') # type: float
+ self.d3 = float('-inf') # type: float
+ self.f0 = float('nan') # type: float
+ self.f1 = float('nan') # type: float
+ self.f2 = float('inf') # type: float
+ self.f3 = float('-inf') # type: float
+ self.dvec = None # type: List[float]
+ self.fvec = None # type: List[float]
+
+ @classmethod
+ def InitFromBuf(cls, buf, pos):
+ monsterExtra = MonsterExtra()
+ monsterExtra.Init(buf, pos)
+ return cls.InitFromObj(monsterExtra)
+
+ @classmethod
+ def InitFromObj(cls, monsterExtra):
+ x = MonsterExtraT()
+ x._UnPack(monsterExtra)
+ return x
+
+ # MonsterExtraT
+ def _UnPack(self, monsterExtra):
+ if monsterExtra is None:
+ return
+ self.d0 = monsterExtra.D0()
+ self.d1 = monsterExtra.D1()
+ self.d2 = monsterExtra.D2()
+ self.d3 = monsterExtra.D3()
+ self.f0 = monsterExtra.F0()
+ self.f1 = monsterExtra.F1()
+ self.f2 = monsterExtra.F2()
+ self.f3 = monsterExtra.F3()
+ if not monsterExtra.DvecIsNone():
+ if np is None:
+ self.dvec = []
+ for i in range(monsterExtra.DvecLength()):
+ self.dvec.append(monsterExtra.Dvec(i))
+ else:
+ self.dvec = monsterExtra.DvecAsNumpy()
+ if not monsterExtra.FvecIsNone():
+ if np is None:
+ self.fvec = []
+ for i in range(monsterExtra.FvecLength()):
+ self.fvec.append(monsterExtra.Fvec(i))
+ else:
+ self.fvec = monsterExtra.FvecAsNumpy()
+
+ # MonsterExtraT
+ def Pack(self, builder):
+ if self.dvec is not None:
+ if np is not None and type(self.dvec) is np.ndarray:
+ dvec = builder.CreateNumpyVector(self.dvec)
+ else:
+ MonsterExtraStartDvecVector(builder, len(self.dvec))
+ for i in reversed(range(len(self.dvec))):
+ builder.PrependFloat64(self.dvec[i])
+ dvec = builder.EndVector(len(self.dvec))
+ if self.fvec is not None:
+ if np is not None and type(self.fvec) is np.ndarray:
+ fvec = builder.CreateNumpyVector(self.fvec)
+ else:
+ MonsterExtraStartFvecVector(builder, len(self.fvec))
+ for i in reversed(range(len(self.fvec))):
+ builder.PrependFloat32(self.fvec[i])
+ fvec = builder.EndVector(len(self.fvec))
+ MonsterExtraStart(builder)
+ MonsterExtraAddD0(builder, self.d0)
+ MonsterExtraAddD1(builder, self.d1)
+ MonsterExtraAddD2(builder, self.d2)
+ MonsterExtraAddD3(builder, self.d3)
+ MonsterExtraAddF0(builder, self.f0)
+ MonsterExtraAddF1(builder, self.f1)
+ MonsterExtraAddF2(builder, self.f2)
+ MonsterExtraAddF3(builder, self.f3)
+ if self.dvec is not None:
+ MonsterExtraAddDvec(builder, dvec)
+ if self.fvec is not None:
+ MonsterExtraAddFvec(builder, fvec)
+ monsterExtra = MonsterExtraEnd(builder)
+ return monsterExtra