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/ts/builder.ts b/ts/builder.ts
new file mode 100644
index 0000000..6be72fb
--- /dev/null
+++ b/ts/builder.ts
@@ -0,0 +1,628 @@
+import { ByteBuffer } from "./byte-buffer"
+import { SIZEOF_SHORT, SIZE_PREFIX_LENGTH, SIZEOF_INT, FILE_IDENTIFIER_LENGTH } from "./constants"
+import { Offset, IGeneratedObject } from "./types"
+import { Long } from "./long"
+
+export class Builder {
+ private bb: ByteBuffer
+ /** Remaining space in the ByteBuffer. */
+ private space: number
+ /** Minimum alignment encountered so far. */
+ private minalign = 1
+ /** The vtable for the current table. */
+ private vtable: number[] | null = null
+ /** The amount of fields we're actually using. */
+ private vtable_in_use = 0
+ /** Whether we are currently serializing a table. */
+ private isNested = false;
+ /** Starting offset of the current struct/table. */
+ private object_start = 0
+ /** List of offsets of all vtables. */
+ private vtables: number[] = []
+ /** For the current vector being built. */
+ private vector_num_elems = 0
+ /** False omits default values from the serialized data */
+ private force_defaults = false;
+
+ private string_maps: Map<string | Uint8Array, number> | null = null;
+
+ /**
+ * Create a FlatBufferBuilder.
+ */
+ constructor(opt_initial_size?: number) {
+ let initial_size: number;
+
+ if (!opt_initial_size) {
+ initial_size = 1024;
+ } else {
+ initial_size = opt_initial_size;
+ }
+
+ /**
+ * @type {ByteBuffer}
+ * @private
+ */
+ this.bb = ByteBuffer.allocate(initial_size);
+ this.space = initial_size;
+ }
+
+
+ clear(): void {
+ this.bb.clear();
+ this.space = this.bb.capacity();
+ this.minalign = 1;
+ this.vtable = null;
+ this.vtable_in_use = 0;
+ this.isNested = false;
+ this.object_start = 0;
+ this.vtables = [];
+ this.vector_num_elems = 0;
+ this.force_defaults = false;
+ this.string_maps = null;
+ }
+
+ /**
+ * In order to save space, fields that are set to their default value
+ * don't get serialized into the buffer. Forcing defaults provides a
+ * way to manually disable this optimization.
+ *
+ * @param forceDefaults true always serializes default values
+ */
+ forceDefaults(forceDefaults: boolean): void {
+ this.force_defaults = forceDefaults;
+ }
+
+ /**
+ * Get the ByteBuffer representing the FlatBuffer. Only call this after you've
+ * called finish(). The actual data starts at the ByteBuffer's current position,
+ * not necessarily at 0.
+ */
+ dataBuffer(): ByteBuffer {
+ return this.bb;
+ }
+
+ /**
+ * Get the bytes representing the FlatBuffer. Only call this after you've
+ * called finish().
+ */
+ asUint8Array(): Uint8Array {
+ return this.bb.bytes().subarray(this.bb.position(), this.bb.position() + this.offset());
+ }
+
+ /**
+ * Prepare to write an element of `size` after `additional_bytes` have been
+ * written, e.g. if you write a string, you need to align such the int length
+ * field is aligned to 4 bytes, and the string data follows it directly. If all
+ * you need to do is alignment, `additional_bytes` will be 0.
+ *
+ * @param size This is the of the new element to write
+ * @param additional_bytes The padding size
+ */
+ prep(size: number, additional_bytes: number): void {
+ // Track the biggest thing we've ever aligned to.
+ if (size > this.minalign) {
+ this.minalign = size;
+ }
+
+ // Find the amount of alignment needed such that `size` is properly
+ // aligned after `additional_bytes`
+ const align_size = ((~(this.bb.capacity() - this.space + additional_bytes)) + 1) & (size - 1);
+
+ // Reallocate the buffer if needed.
+ while (this.space < align_size + size + additional_bytes) {
+ const old_buf_size = this.bb.capacity();
+ this.bb = Builder.growByteBuffer(this.bb);
+ this.space += this.bb.capacity() - old_buf_size;
+ }
+
+ this.pad(align_size);
+ }
+
+ pad(byte_size: number): void {
+ for (let i = 0; i < byte_size; i++) {
+ this.bb.writeInt8(--this.space, 0);
+ }
+ }
+
+ writeInt8(value: number): void {
+ this.bb.writeInt8(this.space -= 1, value);
+ }
+
+ writeInt16(value: number): void {
+ this.bb.writeInt16(this.space -= 2, value);
+ }
+
+ writeInt32(value: number): void {
+ this.bb.writeInt32(this.space -= 4, value);
+ }
+
+ writeInt64(value: Long): void {
+ this.bb.writeInt64(this.space -= 8, value);
+ }
+
+ writeFloat32(value: number): void {
+ this.bb.writeFloat32(this.space -= 4, value);
+ }
+
+ writeFloat64(value: number): void {
+ this.bb.writeFloat64(this.space -= 8, value);
+ }
+
+ /**
+ * Add an `int8` to the buffer, properly aligned, and grows the buffer (if necessary).
+ * @param value The `int8` to add the the buffer.
+ */
+ addInt8(value: number): void {
+ this.prep(1, 0);
+ this.writeInt8(value);
+ }
+
+ /**
+ * Add an `int16` to the buffer, properly aligned, and grows the buffer (if necessary).
+ * @param value The `int16` to add the the buffer.
+ */
+ addInt16(value: number): void {
+ this.prep(2, 0);
+ this.writeInt16(value);
+ }
+
+ /**
+ * Add an `int32` to the buffer, properly aligned, and grows the buffer (if necessary).
+ * @param value The `int32` to add the the buffer.
+ */
+ addInt32(value: number): void {
+ this.prep(4, 0);
+ this.writeInt32(value);
+ }
+
+ /**
+ * Add an `int64` to the buffer, properly aligned, and grows the buffer (if necessary).
+ * @param value The `int64` to add the the buffer.
+ */
+ addInt64(value: Long): void {
+ this.prep(8, 0);
+ this.writeInt64(value);
+ }
+
+ /**
+ * Add a `float32` to the buffer, properly aligned, and grows the buffer (if necessary).
+ * @param value The `float32` to add the the buffer.
+ */
+ addFloat32(value: number): void {
+ this.prep(4, 0);
+ this.writeFloat32(value);
+ }
+
+ /**
+ * Add a `float64` to the buffer, properly aligned, and grows the buffer (if necessary).
+ * @param value The `float64` to add the the buffer.
+ */
+ addFloat64(value: number): void {
+ this.prep(8, 0);
+ this.writeFloat64(value);
+ }
+
+ addFieldInt8(voffset: number, value: number, defaultValue: number): void {
+ if (this.force_defaults || value != defaultValue) {
+ this.addInt8(value);
+ this.slot(voffset);
+ }
+ }
+
+ addFieldInt16(voffset: number, value: number, defaultValue: number): void {
+ if (this.force_defaults || value != defaultValue) {
+ this.addInt16(value);
+ this.slot(voffset);
+ }
+ }
+
+ addFieldInt32(voffset: number, value: number, defaultValue: number): void {
+ if (this.force_defaults || value != defaultValue) {
+ this.addInt32(value);
+ this.slot(voffset);
+ }
+ }
+
+ addFieldInt64(voffset: number, value: Long, defaultValue: Long): void {
+ if (this.force_defaults || !value.equals(defaultValue)) {
+ this.addInt64(value);
+ this.slot(voffset);
+ }
+ }
+
+ addFieldFloat32(voffset: number, value: number, defaultValue: number): void {
+ if (this.force_defaults || value != defaultValue) {
+ this.addFloat32(value);
+ this.slot(voffset);
+ }
+ }
+
+ addFieldFloat64(voffset: number, value: number, defaultValue: number): void {
+ if (this.force_defaults || value != defaultValue) {
+ this.addFloat64(value);
+ this.slot(voffset);
+ }
+ }
+
+ addFieldOffset(voffset: number, value: Offset, defaultValue: Offset): void {
+ if (this.force_defaults || value != defaultValue) {
+ this.addOffset(value);
+ this.slot(voffset);
+ }
+ }
+
+ /**
+ * Structs are stored inline, so nothing additional is being added. `d` is always 0.
+ */
+ addFieldStruct(voffset: number, value: Offset, defaultValue: Offset): void {
+ if (value != defaultValue) {
+ this.nested(value);
+ this.slot(voffset);
+ }
+ }
+
+ /**
+ * Structures are always stored inline, they need to be created right
+ * where they're used. You'll get this assertion failure if you
+ * created it elsewhere.
+ */
+ nested(obj: Offset): void {
+ if (obj != this.offset()) {
+ throw new Error('FlatBuffers: struct must be serialized inline.');
+ }
+ }
+
+ /**
+ * Should not be creating any other object, string or vector
+ * while an object is being constructed
+ */
+ notNested(): void {
+ if (this.isNested) {
+ throw new Error('FlatBuffers: object serialization must not be nested.');
+ }
+ }
+
+ /**
+ * Set the current vtable at `voffset` to the current location in the buffer.
+ */
+ slot(voffset: number): void {
+ if (this.vtable !== null)
+ this.vtable[voffset] = this.offset();
+ }
+
+ /**
+ * @returns Offset relative to the end of the buffer.
+ */
+ offset(): Offset {
+ return this.bb.capacity() - this.space;
+ }
+
+ /**
+ * Doubles the size of the backing ByteBuffer and copies the old data towards
+ * the end of the new buffer (since we build the buffer backwards).
+ *
+ * @param bb The current buffer with the existing data
+ * @returns A new byte buffer with the old data copied
+ * to it. The data is located at the end of the buffer.
+ *
+ * uint8Array.set() formally takes {Array<number>|ArrayBufferView}, so to pass
+ * it a uint8Array we need to suppress the type check:
+ * @suppress {checkTypes}
+ */
+ static growByteBuffer(bb: ByteBuffer): ByteBuffer {
+ const old_buf_size = bb.capacity();
+
+ // Ensure we don't grow beyond what fits in an int.
+ if (old_buf_size & 0xC0000000) {
+ throw new Error('FlatBuffers: cannot grow buffer beyond 2 gigabytes.');
+ }
+
+ const new_buf_size = old_buf_size << 1;
+ const nbb = ByteBuffer.allocate(new_buf_size);
+ nbb.setPosition(new_buf_size - old_buf_size);
+ nbb.bytes().set(bb.bytes(), new_buf_size - old_buf_size);
+ return nbb;
+ }
+
+ /**
+ * Adds on offset, relative to where it will be written.
+ *
+ * @param offset The offset to add.
+ */
+ addOffset(offset: Offset): void {
+ this.prep(SIZEOF_INT, 0); // Ensure alignment is already done.
+ this.writeInt32(this.offset() - offset + SIZEOF_INT);
+ }
+
+ /**
+ * Start encoding a new object in the buffer. Users will not usually need to
+ * call this directly. The FlatBuffers compiler will generate helper methods
+ * that call this method internally.
+ */
+ startObject(numfields: number): void {
+ this.notNested();
+ if (this.vtable == null) {
+ this.vtable = [];
+ }
+ this.vtable_in_use = numfields;
+ for (let i = 0; i < numfields; i++) {
+ this.vtable[i] = 0; // This will push additional elements as needed
+ }
+ this.isNested = true;
+ this.object_start = this.offset();
+ }
+
+ /**
+ * Finish off writing the object that is under construction.
+ *
+ * @returns The offset to the object inside `dataBuffer`
+ */
+ endObject(): Offset {
+ if (this.vtable == null || !this.isNested) {
+ throw new Error('FlatBuffers: endObject called without startObject');
+ }
+
+ this.addInt32(0);
+ const vtableloc = this.offset();
+
+ // Trim trailing zeroes.
+ let i = this.vtable_in_use - 1;
+ // eslint-disable-next-line no-empty
+ for (; i >= 0 && this.vtable[i] == 0; i--) {}
+ const trimmed_size = i + 1;
+
+ // Write out the current vtable.
+ for (; i >= 0; i--) {
+ // Offset relative to the start of the table.
+ this.addInt16(this.vtable[i] != 0 ? vtableloc - this.vtable[i] : 0);
+ }
+
+ const standard_fields = 2; // The fields below:
+ this.addInt16(vtableloc - this.object_start);
+ const len = (trimmed_size + standard_fields) * SIZEOF_SHORT;
+ this.addInt16(len);
+
+ // Search for an existing vtable that matches the current one.
+ let existing_vtable = 0;
+ const vt1 = this.space;
+ outer_loop:
+ for (i = 0; i < this.vtables.length; i++) {
+ const vt2 = this.bb.capacity() - this.vtables[i];
+ if (len == this.bb.readInt16(vt2)) {
+ for (let j = SIZEOF_SHORT; j < len; j += SIZEOF_SHORT) {
+ if (this.bb.readInt16(vt1 + j) != this.bb.readInt16(vt2 + j)) {
+ continue outer_loop;
+ }
+ }
+ existing_vtable = this.vtables[i];
+ break;
+ }
+ }
+
+ if (existing_vtable) {
+ // Found a match:
+ // Remove the current vtable.
+ this.space = this.bb.capacity() - vtableloc;
+
+ // Point table to existing vtable.
+ this.bb.writeInt32(this.space, existing_vtable - vtableloc);
+ } else {
+ // No match:
+ // Add the location of the current vtable to the list of vtables.
+ this.vtables.push(this.offset());
+
+ // Point table to current vtable.
+ this.bb.writeInt32(this.bb.capacity() - vtableloc, this.offset() - vtableloc);
+ }
+
+ this.isNested = false;
+ return vtableloc as Offset;
+ }
+
+ /**
+ * Finalize a buffer, poiting to the given `root_table`.
+ */
+ finish(root_table: Offset, opt_file_identifier?: string, opt_size_prefix?: boolean): void {
+ const size_prefix = opt_size_prefix ? SIZE_PREFIX_LENGTH : 0;
+ if (opt_file_identifier) {
+ const file_identifier = opt_file_identifier;
+ this.prep(this.minalign, SIZEOF_INT +
+ FILE_IDENTIFIER_LENGTH + size_prefix);
+ if (file_identifier.length != FILE_IDENTIFIER_LENGTH) {
+ throw new Error('FlatBuffers: file identifier must be length ' +
+ FILE_IDENTIFIER_LENGTH);
+ }
+ for (let i = FILE_IDENTIFIER_LENGTH - 1; i >= 0; i--) {
+ this.writeInt8(file_identifier.charCodeAt(i));
+ }
+ }
+ this.prep(this.minalign, SIZEOF_INT + size_prefix);
+ this.addOffset(root_table);
+ if (size_prefix) {
+ this.addInt32(this.bb.capacity() - this.space);
+ }
+ this.bb.setPosition(this.space);
+ }
+
+ /**
+ * Finalize a size prefixed buffer, pointing to the given `root_table`.
+ */
+ finishSizePrefixed(this: Builder, root_table: Offset, opt_file_identifier?: string): void {
+ this.finish(root_table, opt_file_identifier, true);
+ }
+
+ /**
+ * This checks a required field has been set in a given table that has
+ * just been constructed.
+ */
+ requiredField(table: Offset, field: number): void {
+ const table_start = this.bb.capacity() - table;
+ const vtable_start = table_start - this.bb.readInt32(table_start);
+ const ok = this.bb.readInt16(vtable_start + field) != 0;
+
+ // If this fails, the caller will show what field needs to be set.
+ if (!ok) {
+ throw new Error('FlatBuffers: field ' + field + ' must be set');
+ }
+ }
+
+ /**
+ * Start a new array/vector of objects. Users usually will not call
+ * this directly. The FlatBuffers compiler will create a start/end
+ * method for vector types in generated code.
+ *
+ * @param elem_size The size of each element in the array
+ * @param num_elems The number of elements in the array
+ * @param alignment The alignment of the array
+ */
+ startVector(elem_size: number, num_elems: number, alignment: number): void {
+ this.notNested();
+ this.vector_num_elems = num_elems;
+ this.prep(SIZEOF_INT, elem_size * num_elems);
+ this.prep(alignment, elem_size * num_elems); // Just in case alignment > int.
+ }
+
+ /**
+ * Finish off the creation of an array and all its elements. The array must be
+ * created with `startVector`.
+ *
+ * @returns The offset at which the newly created array
+ * starts.
+ */
+ endVector(): Offset {
+ this.writeInt32(this.vector_num_elems);
+ return this.offset();
+ }
+
+ /**
+ * Encode the string `s` in the buffer using UTF-8. If the string passed has
+ * already been seen, we return the offset of the already written string
+ *
+ * @param s The string to encode
+ * @return The offset in the buffer where the encoded string starts
+ */
+ createSharedString(s: string | Uint8Array): Offset {
+ if (!s) { return 0 }
+
+ if (!this.string_maps) {
+ this.string_maps = new Map();
+ }
+
+ if (this.string_maps.has(s)) {
+ return this.string_maps.get(s) as Offset
+ }
+ const offset = this.createString(s)
+ this.string_maps.set(s, offset)
+ return offset
+ }
+
+ /**
+ * Encode the string `s` in the buffer using UTF-8. If a Uint8Array is passed
+ * instead of a string, it is assumed to contain valid UTF-8 encoded data.
+ *
+ * @param s The string to encode
+ * @return The offset in the buffer where the encoded string starts
+ */
+ createString(s: string | Uint8Array): Offset {
+ if (!s) { return 0 }
+ let utf8: string | Uint8Array | number[];
+ if (s instanceof Uint8Array) {
+ utf8 = s;
+ } else {
+ utf8 = [];
+ let i = 0;
+
+ while (i < s.length) {
+ let codePoint;
+
+ // Decode UTF-16
+ const a = s.charCodeAt(i++);
+ if (a < 0xD800 || a >= 0xDC00) {
+ codePoint = a;
+ } else {
+ const b = s.charCodeAt(i++);
+ codePoint = (a << 10) + b + (0x10000 - (0xD800 << 10) - 0xDC00);
+ }
+
+ // Encode UTF-8
+ if (codePoint < 0x80) {
+ utf8.push(codePoint);
+ } else {
+ if (codePoint < 0x800) {
+ utf8.push(((codePoint >> 6) & 0x1F) | 0xC0);
+ } else {
+ if (codePoint < 0x10000) {
+ utf8.push(((codePoint >> 12) & 0x0F) | 0xE0);
+ } else {
+ utf8.push(
+ ((codePoint >> 18) & 0x07) | 0xF0,
+ ((codePoint >> 12) & 0x3F) | 0x80);
+ }
+ utf8.push(((codePoint >> 6) & 0x3F) | 0x80);
+ }
+ utf8.push((codePoint & 0x3F) | 0x80);
+ }
+ }
+ }
+
+ this.addInt8(0);
+ this.startVector(1, utf8.length, 1);
+ this.bb.setPosition(this.space -= utf8.length);
+ for (let i = 0, offset = this.space, bytes = this.bb.bytes(); i < utf8.length; i++) {
+ bytes[offset++] = utf8[i];
+ }
+ return this.endVector();
+ }
+
+ /**
+ * A helper function to avoid generated code depending on this file directly.
+ */
+ createLong(low: number, high: number): Long {
+ return Long.create(low, high);
+ }
+
+ /**
+ * A helper function to pack an object
+ *
+ * @returns offset of obj
+ */
+ createObjectOffset(obj: string | IGeneratedObject): Offset {
+ if(obj === null) {
+ return 0
+ }
+
+ if(typeof obj === 'string') {
+ return this.createString(obj);
+ } else {
+ return obj.pack(this);
+ }
+ }
+
+ /**
+ * A helper function to pack a list of object
+ *
+ * @returns list of offsets of each non null object
+ */
+ createObjectOffsetList(list: string[]): Offset[] {
+ const ret = [];
+
+ for(let i = 0; i < list.length; ++i) {
+ const val = list[i];
+
+ if(val !== null) {
+ ret.push(this.createObjectOffset(val));
+ } else {
+ throw new Error(
+ 'FlatBuffers: Argument for createObjectOffsetList cannot contain null.');
+ }
+ }
+
+ return ret;
+ }
+
+ createStructOffsetList(list: string[], startFunc: (builder: Builder, length: number) => void): Offset {
+ startFunc(this, list.length);
+ this.createObjectOffsetList(list);
+ return this.endVector();
+ }
+ }
\ No newline at end of file
diff --git a/ts/byte-buffer.ts b/ts/byte-buffer.ts
new file mode 100644
index 0000000..b936c7b
--- /dev/null
+++ b/ts/byte-buffer.ts
@@ -0,0 +1,351 @@
+import { FILE_IDENTIFIER_LENGTH, SIZEOF_INT } from "./constants";
+import { Long } from "./long";
+import { int32, isLittleEndian, float32, float64 } from "./utils";
+import { Offset, Table, IGeneratedObject } from "./types";
+import { Encoding } from "./encoding";
+
+export class ByteBuffer {
+ private position_ = 0;
+
+ /**
+ * Create a new ByteBuffer with a given array of bytes (`Uint8Array`)
+ */
+ constructor(private bytes_: Uint8Array) { }
+
+ /**
+ * Create and allocate a new ByteBuffer with a given size.
+ */
+ static allocate(byte_size: number): ByteBuffer {
+ return new ByteBuffer(new Uint8Array(byte_size));
+ }
+
+ clear(): void {
+ this.position_ = 0;
+ }
+
+ /**
+ * Get the underlying `Uint8Array`.
+ */
+ bytes(): Uint8Array {
+ return this.bytes_;
+ }
+
+ /**
+ * Get the buffer's position.
+ */
+ position(): number {
+ return this.position_;
+ }
+
+ /**
+ * Set the buffer's position.
+ */
+ setPosition(position: number): void {
+ this.position_ = position;
+ }
+
+ /**
+ * Get the buffer's capacity.
+ */
+ capacity(): number {
+ return this.bytes_.length;
+ }
+
+ readInt8(offset: number): number {
+ return this.readUint8(offset) << 24 >> 24;
+ }
+
+ readUint8(offset: number): number {
+ return this.bytes_[offset];
+ }
+
+ readInt16(offset: number): number {
+ return this.readUint16(offset) << 16 >> 16;
+ }
+
+ readUint16(offset: number): number {
+ return this.bytes_[offset] | this.bytes_[offset + 1] << 8;
+ }
+
+ readInt32(offset: number): number {
+ return this.bytes_[offset] | this.bytes_[offset + 1] << 8 | this.bytes_[offset + 2] << 16 | this.bytes_[offset + 3] << 24;
+ }
+
+ readUint32(offset: number): number {
+ return this.readInt32(offset) >>> 0;
+ }
+
+ readInt64(offset: number): Long {
+ return new Long(this.readInt32(offset), this.readInt32(offset + 4));
+ }
+
+ readUint64(offset: number): Long {
+ return new Long(this.readUint32(offset), this.readUint32(offset + 4));
+ }
+
+ readFloat32(offset: number): number {
+ int32[0] = this.readInt32(offset);
+ return float32[0];
+ }
+
+ readFloat64(offset: number): number {
+ int32[isLittleEndian ? 0 : 1] = this.readInt32(offset);
+ int32[isLittleEndian ? 1 : 0] = this.readInt32(offset + 4);
+ return float64[0];
+ }
+
+ writeInt8(offset: number, value: number): void {
+ this.bytes_[offset] = value;
+ }
+
+ writeUint8(offset: number, value: number): void {
+ this.bytes_[offset] = value;
+ }
+
+ writeInt16(offset: number, value: number): void {
+ this.bytes_[offset] = value;
+ this.bytes_[offset + 1] = value >> 8;
+ }
+
+ writeUint16(offset: number, value: number): void {
+ this.bytes_[offset] = value;
+ this.bytes_[offset + 1] = value >> 8;
+ }
+
+ writeInt32(offset: number, value: number): void {
+ this.bytes_[offset] = value;
+ this.bytes_[offset + 1] = value >> 8;
+ this.bytes_[offset + 2] = value >> 16;
+ this.bytes_[offset + 3] = value >> 24;
+ }
+
+ writeUint32(offset: number, value: number): void {
+ this.bytes_[offset] = value;
+ this.bytes_[offset + 1] = value >> 8;
+ this.bytes_[offset + 2] = value >> 16;
+ this.bytes_[offset + 3] = value >> 24;
+ }
+
+ writeInt64(offset: number, value: Long): void {
+ this.writeInt32(offset, value.low);
+ this.writeInt32(offset + 4, value.high);
+ }
+
+ writeUint64(offset: number, value: Long): void {
+ this.writeUint32(offset, value.low);
+ this.writeUint32(offset + 4, value.high);
+ }
+
+ writeFloat32(offset: number, value: number): void {
+ float32[0] = value;
+ this.writeInt32(offset, int32[0]);
+ }
+
+ writeFloat64(offset: number, value: number): void {
+ float64[0] = value;
+ this.writeInt32(offset, int32[isLittleEndian ? 0 : 1]);
+ this.writeInt32(offset + 4, int32[isLittleEndian ? 1 : 0]);
+ }
+
+ /**
+ * Return the file identifier. Behavior is undefined for FlatBuffers whose
+ * schema does not include a file_identifier (likely points at padding or the
+ * start of a the root vtable).
+ */
+ getBufferIdentifier(): string {
+ if (this.bytes_.length < this.position_ + SIZEOF_INT +
+ FILE_IDENTIFIER_LENGTH) {
+ throw new Error(
+ 'FlatBuffers: ByteBuffer is too short to contain an identifier.');
+ }
+ let result = "";
+ for (let i = 0; i < FILE_IDENTIFIER_LENGTH; i++) {
+ result += String.fromCharCode(
+ this.readInt8(this.position_ + SIZEOF_INT + i));
+ }
+ return result;
+ }
+
+ /**
+ * Look up a field in the vtable, return an offset into the object, or 0 if the
+ * field is not present.
+ */
+ __offset(bb_pos: number, vtable_offset: number): Offset {
+ const vtable = bb_pos - this.readInt32(bb_pos);
+ return vtable_offset < this.readInt16(vtable) ? this.readInt16(vtable + vtable_offset) : 0;
+ }
+
+ /**
+ * Initialize any Table-derived type to point to the union at the given offset.
+ */
+ __union(t: Table, offset: number): Table {
+ t.bb_pos = offset + this.readInt32(offset);
+ t.bb = this;
+ return t;
+ }
+
+ /**
+ * Create a JavaScript string from UTF-8 data stored inside the FlatBuffer.
+ * This allocates a new string and converts to wide chars upon each access.
+ *
+ * To avoid the conversion to UTF-16, pass Encoding.UTF8_BYTES as
+ * the "optionalEncoding" argument. This is useful for avoiding conversion to
+ * and from UTF-16 when the data will just be packaged back up in another
+ * FlatBuffer later on.
+ *
+ * @param offset
+ * @param opt_encoding Defaults to UTF16_STRING
+ */
+ __string(offset: number, opt_encoding?: Encoding): string | Uint8Array {
+ offset += this.readInt32(offset);
+
+ const length = this.readInt32(offset);
+ let result = '';
+ let i = 0;
+
+ offset += SIZEOF_INT;
+
+ if (opt_encoding === Encoding.UTF8_BYTES) {
+ return this.bytes_.subarray(offset, offset + length);
+ }
+
+ while (i < length) {
+ let codePoint;
+
+ // Decode UTF-8
+ const a = this.readUint8(offset + i++);
+ if (a < 0xC0) {
+ codePoint = a;
+ } else {
+ const b = this.readUint8(offset + i++);
+ if (a < 0xE0) {
+ codePoint =
+ ((a & 0x1F) << 6) |
+ (b & 0x3F);
+ } else {
+ const c = this.readUint8(offset + i++);
+ if (a < 0xF0) {
+ codePoint =
+ ((a & 0x0F) << 12) |
+ ((b & 0x3F) << 6) |
+ (c & 0x3F);
+ } else {
+ const d = this.readUint8(offset + i++);
+ codePoint =
+ ((a & 0x07) << 18) |
+ ((b & 0x3F) << 12) |
+ ((c & 0x3F) << 6) |
+ (d & 0x3F);
+ }
+ }
+ }
+
+ // Encode UTF-16
+ if (codePoint < 0x10000) {
+ result += String.fromCharCode(codePoint);
+ } else {
+ codePoint -= 0x10000;
+ result += String.fromCharCode(
+ (codePoint >> 10) + 0xD800,
+ (codePoint & ((1 << 10) - 1)) + 0xDC00);
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * Handle unions that can contain string as its member, if a Table-derived type then initialize it,
+ * if a string then return a new one
+ *
+ * WARNING: strings are immutable in JS so we can't change the string that the user gave us, this
+ * makes the behaviour of __union_with_string different compared to __union
+ */
+ __union_with_string(o: Table | string, offset: number) : Table | string {
+ if(typeof o === 'string') {
+ return this.__string(offset) as string;
+ }
+ return this.__union(o, offset);
+ }
+
+ /**
+ * Retrieve the relative offset stored at "offset"
+ */
+ __indirect(offset: Offset): Offset {
+ return offset + this.readInt32(offset);
+ }
+
+ /**
+ * Get the start of data of a vector whose offset is stored at "offset" in this object.
+ */
+ __vector(offset: Offset): Offset {
+ return offset + this.readInt32(offset) + SIZEOF_INT; // data starts after the length
+ }
+
+ /**
+ * Get the length of a vector whose offset is stored at "offset" in this object.
+ */
+ __vector_len(offset: Offset): Offset {
+ return this.readInt32(offset + this.readInt32(offset));
+ }
+
+ __has_identifier(ident: string): boolean {
+ if (ident.length != FILE_IDENTIFIER_LENGTH) {
+ throw new Error('FlatBuffers: file identifier must be length ' +
+ FILE_IDENTIFIER_LENGTH);
+ }
+ for (let i = 0; i < FILE_IDENTIFIER_LENGTH; i++) {
+ if (ident.charCodeAt(i) != this.readInt8(this.position() + SIZEOF_INT + i)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * A helper function to avoid generated code depending on this file directly.
+ */
+ createLong(low: number, high: number): Long {
+ return Long.create(low, high);
+ }
+
+ /**
+ * A helper function for generating list for obj api
+ */
+ createScalarList(listAccessor: (i: number) => unknown, listLength: number) : unknown[] {
+ const ret: unknown[] = [];
+ for(let i = 0; i < listLength; ++i) {
+ if(listAccessor(i) !== null) {
+ ret.push(listAccessor(i));
+ }
+ }
+
+ return ret;
+ }
+
+ /**
+ * This function is here only to get around typescript type system
+ */
+ createStringList(listAccessor: (i: number) => unknown, listLength: number): unknown[] {
+ return this.createScalarList(listAccessor, listLength);
+ }
+
+ /**
+ * A helper function for generating list for obj api
+ * @param listAccessor function that accepts an index and return data at that index
+ * @param listLength listLength
+ * @param res result list
+ */
+ createObjList(listAccessor: (i: number) => IGeneratedObject, listLength: number): IGeneratedObject[] {
+ const ret: IGeneratedObject[] = [];
+ for(let i = 0; i < listLength; ++i) {
+ const val = listAccessor(i);
+ if(val !== null) {
+ ret.push(val.unpack());
+ }
+ }
+
+ return ret;
+ }
+
+ }
\ No newline at end of file
diff --git a/ts/constants.ts b/ts/constants.ts
new file mode 100644
index 0000000..04510fb
--- /dev/null
+++ b/ts/constants.ts
@@ -0,0 +1,4 @@
+export const SIZEOF_SHORT = 2;
+export const SIZEOF_INT = 4;
+export const FILE_IDENTIFIER_LENGTH = 4;
+export const SIZE_PREFIX_LENGTH = 4;
\ No newline at end of file
diff --git a/ts/encoding.ts b/ts/encoding.ts
new file mode 100644
index 0000000..856792c
--- /dev/null
+++ b/ts/encoding.ts
@@ -0,0 +1,4 @@
+export enum Encoding {
+ UTF8_BYTES = 1,
+ UTF16_STRING = 2
+}
\ No newline at end of file
diff --git a/ts/flatbuffers.ts b/ts/flatbuffers.ts
new file mode 100644
index 0000000..9184527
--- /dev/null
+++ b/ts/flatbuffers.ts
@@ -0,0 +1,34 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+import * as constants from './constants'
+import * as types from './types'
+import * as utils from './utils'
+
+import { Long as LongClass } from './long'
+import { Encoding as EncodingEnum } from './encoding'
+import { Builder as BuilderClass } from './builder'
+import { ByteBuffer as ByteBufferClass } from './byte-buffer'
+
+export namespace flatbuffers {
+
+ export type Offset = types.Offset;
+
+ export type Table = types.Table;
+
+ export const SIZEOF_SHORT = constants.SIZEOF_SHORT;
+ export const SIZEOF_INT = constants.SIZEOF_INT;
+ export const FILE_IDENTIFIER_LENGTH = constants.FILE_IDENTIFIER_LENGTH;
+ export const SIZE_PREFIX_LENGTH = constants.SIZE_PREFIX_LENGTH;
+
+ export const Encoding = EncodingEnum;
+
+ export const int32 = utils.int32;
+ export const float32 = utils.float32;
+ export const float64 = utils.float64;
+ export const isLittleEndian = utils.isLittleEndian;
+
+ export const Long = LongClass;
+ export const Builder = BuilderClass;
+ export const ByteBuffer = ByteBufferClass;
+}
+
+export default flatbuffers;
diff --git a/ts/flexbuffers.ts b/ts/flexbuffers.ts
new file mode 100644
index 0000000..40482dc
--- /dev/null
+++ b/ts/flexbuffers.ts
@@ -0,0 +1,30 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+import { Builder } from './flexbuffers/builder'
+import { toReference as toReferenceFunction } from './flexbuffers/reference';
+
+export function builder(): Builder {
+ return new Builder();
+}
+
+export function toObject(buffer: Uint8Array): unknown {
+ return toReferenceFunction(buffer).toObject();
+}
+
+export function encode(object: unknown, size = 2048, deduplicateStrings = true, deduplicateKeys = true, deduplicateKeyVectors = true): Uint8Array {
+ const builder = new Builder(size > 0 ? size : 2048, deduplicateStrings, deduplicateKeys, deduplicateKeyVectors);
+ builder.add(object);
+ return builder.finish();
+}
+
+const builderFunction = builder
+const toObjectFunction = toObject
+const encodeFunction = encode
+
+export namespace flexbuffers {
+ export const builder = builderFunction;
+ export const toObject = toObjectFunction;
+ export const encode = encodeFunction;
+ export const toReference = toReferenceFunction;
+}
+
+export default flexbuffers;
diff --git a/ts/flexbuffers/bit-width-util.ts b/ts/flexbuffers/bit-width-util.ts
new file mode 100644
index 0000000..acb3c96
--- /dev/null
+++ b/ts/flexbuffers/bit-width-util.ts
@@ -0,0 +1,34 @@
+import { BitWidth } from './bit-width'
+
+export function toByteWidth(bitWidth: BitWidth): number {
+ return 1 << bitWidth;
+}
+
+export function iwidth(value: number | bigint): BitWidth {
+ if (value >= -128 && value <= 127) return BitWidth.WIDTH8;
+ if (value >= -32768 && value <= 32767) return BitWidth.WIDTH16;
+ if (value >= -2147483648 && value <= 2147483647) return BitWidth.WIDTH32;
+ return BitWidth.WIDTH64;
+}
+
+export function fwidth(value: number): BitWidth {
+ return value === Math.fround(value) ? BitWidth.WIDTH32 : BitWidth.WIDTH64;
+}
+
+export function uwidth(value: number): BitWidth {
+ if (value <= 255) return BitWidth.WIDTH8;
+ if (value <= 65535) return BitWidth.WIDTH16;
+ if (value <= 4294967295) return BitWidth.WIDTH32;
+ return BitWidth.WIDTH64;
+}
+
+export function fromByteWidth(value: number): BitWidth {
+ if (value === 1) return BitWidth.WIDTH8;
+ if (value === 2) return BitWidth.WIDTH16;
+ if (value === 4) return BitWidth.WIDTH32;
+ return BitWidth.WIDTH64;
+}
+
+export function paddingSize(bufSize: number, scalarSize: number): number {
+ return (~bufSize + 1) & (scalarSize - 1);
+}
\ No newline at end of file
diff --git a/ts/flexbuffers/bit-width.ts b/ts/flexbuffers/bit-width.ts
new file mode 100644
index 0000000..5f85b61
--- /dev/null
+++ b/ts/flexbuffers/bit-width.ts
@@ -0,0 +1,6 @@
+export enum BitWidth {
+ WIDTH8 = 0,
+ WIDTH16 = 1,
+ WIDTH32 = 2,
+ WIDTH64 = 3,
+}
\ No newline at end of file
diff --git a/ts/flexbuffers/builder.ts b/ts/flexbuffers/builder.ts
new file mode 100644
index 0000000..4321547
--- /dev/null
+++ b/ts/flexbuffers/builder.ts
@@ -0,0 +1,549 @@
+import { BitWidth } from './bit-width'
+import { paddingSize, iwidth, uwidth, fwidth, toByteWidth, fromByteWidth } from './bit-width-util'
+import { toUTF8Array } from './flexbuffers-util'
+import { ValueType } from './value-type'
+import { isNumber, isTypedVectorElement, toTypedVector } from './value-type-util'
+import { StackValue } from './stack-value'
+
+interface StackPointer {
+ stackPosition: number,
+ isVector: boolean
+ presorted?: boolean
+}
+
+export class Builder {
+ buffer: ArrayBuffer
+ view: DataView
+
+ readonly stack: Array<StackValue> = [];
+ readonly stackPointers: Array<StackPointer> = [];
+ offset = 0;
+ finished = false;
+ readonly stringLookup: Record<string, StackValue> = {};
+ readonly keyLookup: Record<string, StackValue> = {};
+ readonly keyVectorLookup: Record<string, StackValue> = {};
+ readonly indirectIntLookup: Record<number, StackValue> = {};
+ readonly indirectUIntLookup: Record<number, StackValue> = {};
+ readonly indirectFloatLookup: Record<number, StackValue> = {};
+
+ constructor(size = 2048, private dedupStrings = true, private dedupKeys = true, private dedupKeyVectors = true) {
+ this.buffer = new ArrayBuffer(size > 0 ? size : 2048);
+ this.view = new DataView(this.buffer);
+ }
+
+ private align(width: BitWidth) {
+ const byteWidth = toByteWidth(width);
+ this.offset += paddingSize(this.offset, byteWidth);
+ return byteWidth;
+ }
+
+ computeOffset(newValueSize: number): number {
+ const targetOffset = this.offset + newValueSize;
+ let size = this.buffer.byteLength;
+ const prevSize = size;
+ while (size < targetOffset) {
+ size <<= 1;
+ }
+ if (prevSize < size) {
+ const prevBuffer = this.buffer;
+ this.buffer = new ArrayBuffer(size);
+ this.view = new DataView(this.buffer);
+ new Uint8Array(this.buffer).set(new Uint8Array(prevBuffer), 0);
+ }
+ return targetOffset;
+ }
+
+ pushInt(value: number, width: BitWidth): void {
+ if (width === BitWidth.WIDTH8) {
+ this.view.setInt8(this.offset, value);
+ } else if (width === BitWidth.WIDTH16) {
+ this.view.setInt16(this.offset, value, true);
+ } else if (width === BitWidth.WIDTH32) {
+ this.view.setInt32(this.offset, value, true);
+ } else if (width === BitWidth.WIDTH64) {
+ this.view.setBigInt64(this.offset, BigInt(value), true);
+ } else {
+ throw `Unexpected width: ${width} for value: ${value}`;
+ }
+ }
+
+ pushUInt(value: number, width: BitWidth): void {
+ if (width === BitWidth.WIDTH8) {
+ this.view.setUint8(this.offset, value);
+ } else if (width === BitWidth.WIDTH16) {
+ this.view.setUint16(this.offset, value, true);
+ } else if (width === BitWidth.WIDTH32) {
+ this.view.setUint32(this.offset, value, true);
+ } else if (width === BitWidth.WIDTH64) {
+ this.view.setBigUint64(this.offset, BigInt(value), true);
+ } else {
+ throw `Unexpected width: ${width} for value: ${value}`;
+ }
+ }
+
+ private writeInt(value: number, byteWidth: number) {
+ const newOffset = this.computeOffset(byteWidth);
+ this.pushInt(value, fromByteWidth(byteWidth));
+ this.offset = newOffset;
+ }
+
+ private writeUInt(value: number, byteWidth: number) {
+ const newOffset = this.computeOffset(byteWidth);
+ this.pushUInt(value, fromByteWidth(byteWidth));
+ this.offset = newOffset;
+ }
+
+ private writeBlob(arrayBuffer: ArrayBuffer) {
+ const length = arrayBuffer.byteLength;
+ const bitWidth = uwidth(length);
+ const byteWidth = this.align(bitWidth);
+ this.writeUInt(length, byteWidth);
+ const blobOffset = this.offset;
+ const newOffset = this.computeOffset(length);
+ new Uint8Array(this.buffer).set(new Uint8Array(arrayBuffer), blobOffset);
+ this.stack.push(this.offsetStackValue(blobOffset, ValueType.BLOB, bitWidth));
+ this.offset = newOffset;
+ }
+
+ private writeString(str: string): void {
+ if (this.dedupStrings && Object.prototype.hasOwnProperty.call(this.stringLookup, str)) {
+ this.stack.push(this.stringLookup[str]);
+ return;
+ }
+ const utf8 = toUTF8Array(str);
+ const length = utf8.length;
+ const bitWidth = uwidth(length);
+ const byteWidth = this.align(bitWidth);
+ this.writeUInt(length, byteWidth);
+ const stringOffset = this.offset;
+ const newOffset = this.computeOffset(length + 1);
+ new Uint8Array(this.buffer).set(utf8, stringOffset);
+ const stackValue = this.offsetStackValue(stringOffset, ValueType.STRING, bitWidth);
+ this.stack.push(stackValue);
+ if (this.dedupStrings) {
+ this.stringLookup[str] = stackValue;
+ }
+ this.offset = newOffset;
+ }
+
+ private writeKey(str: string): void {
+ if (this.dedupKeys && Object.prototype.hasOwnProperty.call(this.keyLookup, str)) {
+ this.stack.push(this.keyLookup[str]);
+ return;
+ }
+ const utf8 = toUTF8Array(str);
+ const length = utf8.length;
+ const newOffset = this.computeOffset(length + 1);
+ new Uint8Array(this.buffer).set(utf8, this.offset);
+ const stackValue = this.offsetStackValue(this.offset, ValueType.KEY, BitWidth.WIDTH8);
+ this.stack.push(stackValue);
+ if (this.dedupKeys) {
+ this.keyLookup[str] = stackValue;
+ }
+ this.offset = newOffset;
+ }
+
+ private writeStackValue(value: StackValue, byteWidth: number): void {
+ const newOffset = this.computeOffset(byteWidth);
+ if (value.isOffset()) {
+ const relativeOffset = this.offset - value.offset;
+ if (byteWidth === 8 || BigInt(relativeOffset) < (BigInt(1) << BigInt(byteWidth * 8))) {
+ this.writeUInt(relativeOffset, byteWidth);
+ } else {
+ throw `Unexpected size ${byteWidth}. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new`
+ }
+ } else {
+ value.writeToBuffer(byteWidth);
+ }
+ this.offset = newOffset;
+ }
+
+ private integrityCheckOnValueAddition() {
+ if (this.finished) {
+ throw "Adding values after finish is prohibited";
+ }
+ if (this.stackPointers.length !== 0 && this.stackPointers[this.stackPointers.length - 1].isVector === false) {
+ if (this.stack[this.stack.length - 1].type !== ValueType.KEY) {
+ throw "Adding value to a map before adding a key is prohibited";
+ }
+ }
+ }
+
+ private integrityCheckOnKeyAddition() {
+ if (this.finished) {
+ throw "Adding values after finish is prohibited";
+ }
+ if (this.stackPointers.length === 0 || this.stackPointers[this.stackPointers.length - 1].isVector) {
+ throw "Adding key before starting a map is prohibited";
+ }
+ }
+
+ startVector(): void {
+ this.stackPointers.push({ stackPosition: this.stack.length, isVector: true });
+ }
+
+ startMap(presorted = false): void {
+ this.stackPointers.push({ stackPosition: this.stack.length, isVector: false, presorted: presorted });
+ }
+
+ private endVector(stackPointer: StackPointer) {
+ const vecLength = this.stack.length - stackPointer.stackPosition;
+ const vec = this.createVector(stackPointer.stackPosition, vecLength, 1);
+ this.stack.splice(stackPointer.stackPosition, vecLength);
+ this.stack.push(vec);
+ }
+
+ private endMap(stackPointer: StackPointer) {
+ if (!stackPointer.presorted) {
+ this.sort(stackPointer);
+ }
+ let keyVectorHash = "";
+ for (let i = stackPointer.stackPosition; i < this.stack.length; i += 2) {
+ keyVectorHash += `,${this.stack[i].offset}`;
+ }
+ const vecLength = (this.stack.length - stackPointer.stackPosition) >> 1;
+
+ if (this.dedupKeyVectors && !Object.prototype.hasOwnProperty.call(this.keyVectorLookup, keyVectorHash)) {
+ this.keyVectorLookup[keyVectorHash] = this.createVector(stackPointer.stackPosition, vecLength, 2);
+ }
+ const keysStackValue = this.dedupKeyVectors ? this.keyVectorLookup[keyVectorHash] : this.createVector(stackPointer.stackPosition, vecLength, 2);
+ const valuesStackValue = this.createVector(stackPointer.stackPosition + 1, vecLength, 2, keysStackValue);
+ this.stack.splice(stackPointer.stackPosition, vecLength << 1);
+ this.stack.push(valuesStackValue);
+ }
+
+ private sort(stackPointer: StackPointer) {
+ const view = this.view
+ const stack = this.stack
+
+ function shouldFlip(v1: StackValue, v2: StackValue) {
+ if (v1.type !== ValueType.KEY || v2.type !== ValueType.KEY) {
+ throw `Stack values are not keys ${v1} | ${v2}. Check if you combined [addKey] with add... method calls properly.`
+ }
+ let c1, c2;
+ let index = 0;
+ do {
+ c1 = view.getUint8(v1.offset + index);
+ c2 = view.getUint8(v2.offset + index);
+ if (c2 < c1) return true;
+ if (c1 < c2) return false;
+ index += 1;
+ } while (c1 !== 0 && c2 !== 0);
+ return false;
+ }
+
+ function swap(stack: Array<StackValue>, flipIndex: number, i: number) {
+ if (flipIndex === i) return;
+ const k = stack[flipIndex];
+ const v = stack[flipIndex + 1];
+ stack[flipIndex] = stack[i];
+ stack[flipIndex + 1] = stack[i + 1];
+ stack[i] = k;
+ stack[i + 1] = v;
+ }
+
+ function selectionSort() {
+ for (let i = stackPointer.stackPosition; i < stack.length; i += 2) {
+ let flipIndex = i;
+ for (let j = i + 2; j < stack.length; j += 2) {
+ if (shouldFlip(stack[flipIndex], stack[j])) {
+ flipIndex = j;
+ }
+ }
+ if (flipIndex !== i) {
+ swap(stack, flipIndex, i);
+ }
+ }
+ }
+
+ function smaller(v1: StackValue, v2: StackValue) {
+ if (v1.type !== ValueType.KEY || v2.type !== ValueType.KEY) {
+ throw `Stack values are not keys ${v1} | ${v2}. Check if you combined [addKey] with add... method calls properly.`
+ }
+ if (v1.offset === v2.offset) {
+ return false;
+ }
+ let c1, c2;
+ let index = 0;
+ do {
+ c1 = view.getUint8(v1.offset + index);
+ c2 = view.getUint8(v2.offset + index);
+ if (c1 < c2) return true;
+ if (c2 < c1) return false;
+ index += 1;
+ } while (c1 !== 0 && c2 !== 0);
+ return false;
+ }
+
+ function quickSort(left: number, right: number) {
+
+ if (left < right) {
+ const mid = left + (((right - left) >> 2)) * 2;
+ const pivot = stack[mid];
+ let left_new = left;
+ let right_new = right;
+
+ do {
+ while (smaller(stack[left_new], pivot)) {
+ left_new += 2;
+ }
+ while (smaller(pivot, stack[right_new])) {
+ right_new -= 2;
+ }
+ if (left_new <= right_new) {
+ swap(stack, left_new, right_new);
+ left_new += 2;
+ right_new -= 2;
+ }
+ } while (left_new <= right_new);
+
+ quickSort(left, right_new);
+ quickSort(left_new, right);
+
+ }
+ }
+
+ let sorted = true;
+ for (let i = stackPointer.stackPosition; i < this.stack.length - 2; i += 2) {
+ if (shouldFlip(this.stack[i], this.stack[i + 2])) {
+ sorted = false;
+ break;
+ }
+ }
+
+ if (!sorted) {
+ if (this.stack.length - stackPointer.stackPosition > 40) {
+ quickSort(stackPointer.stackPosition, this.stack.length - 2);
+ } else {
+ selectionSort();
+ }
+ }
+ }
+
+ end(): void {
+ if (this.stackPointers.length < 1) return;
+ const pointer = this.stackPointers.pop() as StackPointer;
+ if (pointer.isVector) {
+ this.endVector(pointer);
+ } else {
+ this.endMap(pointer);
+ }
+ }
+
+ private createVector(start: number, vecLength: number, step: number, keys: StackValue | null = null) {
+ let bitWidth = uwidth(vecLength);
+ let prefixElements = 1;
+ if (keys !== null) {
+ const elementWidth = keys.elementWidth(this.offset, 0);
+ if (elementWidth > bitWidth) {
+ bitWidth = elementWidth;
+ }
+ prefixElements += 2;
+ }
+ let vectorType = ValueType.KEY;
+ let typed = keys === null;
+ for (let i = start; i < this.stack.length; i += step) {
+ const elementWidth = this.stack[i].elementWidth(this.offset, i + prefixElements);
+ if (elementWidth > bitWidth) {
+ bitWidth = elementWidth;
+ }
+ if (i === start) {
+ vectorType = this.stack[i].type;
+ typed = typed && isTypedVectorElement(vectorType);
+ } else {
+ if (vectorType !== this.stack[i].type) {
+ typed = false;
+ }
+ }
+ }
+ const byteWidth = this.align(bitWidth);
+ const fix = typed && isNumber(vectorType) && vecLength >= 2 && vecLength <= 4;
+ if (keys !== null) {
+ this.writeStackValue(keys, byteWidth);
+ this.writeUInt(1 << keys.width, byteWidth);
+ }
+ if (!fix) {
+ this.writeUInt(vecLength, byteWidth);
+ }
+ const vecOffset = this.offset;
+ for (let i = start; i < this.stack.length; i += step) {
+ this.writeStackValue(this.stack[i], byteWidth);
+ }
+ if (!typed) {
+ for (let i = start; i < this.stack.length; i += step) {
+ this.writeUInt(this.stack[i].storedPackedType(), 1);
+ }
+ }
+ if (keys !== null) {
+ return this.offsetStackValue(vecOffset, ValueType.MAP, bitWidth);
+ }
+ if (typed) {
+ const vType = toTypedVector(vectorType, fix ? vecLength : 0);
+ return this.offsetStackValue(vecOffset, vType, bitWidth);
+ }
+ return this.offsetStackValue(vecOffset, ValueType.VECTOR, bitWidth);
+ }
+
+ private nullStackValue() {
+ return new StackValue(this, ValueType.NULL, BitWidth.WIDTH8);
+ }
+
+ private boolStackValue(value: boolean) {
+ return new StackValue(this, ValueType.BOOL, BitWidth.WIDTH8, value);
+ }
+
+ private intStackValue(value: number | bigint) {
+ return new StackValue(this, ValueType.INT, iwidth(value), value as number);
+ }
+
+ private uintStackValue(value: number) {
+ return new StackValue(this, ValueType.UINT, uwidth(value), value);
+ }
+
+ private floatStackValue(value: number) {
+ return new StackValue(this, ValueType.FLOAT, fwidth(value), value);
+ }
+
+ private offsetStackValue(offset: number, valueType: ValueType, bitWidth: BitWidth): StackValue {
+ return new StackValue(this, valueType, bitWidth, null, offset);
+ }
+
+ private finishBuffer() {
+ if (this.stack.length !== 1) {
+ throw `Stack has to be exactly 1, but it is ${this.stack.length}. You have to end all started vectors and maps before calling [finish]`;
+ }
+ const value = this.stack[0];
+ const byteWidth = this.align(value.elementWidth(this.offset, 0));
+ this.writeStackValue(value, byteWidth);
+ this.writeUInt(value.storedPackedType(), 1);
+ this.writeUInt(byteWidth, 1);
+ this.finished = true;
+ }
+
+ add(value: undefined | null | boolean | bigint | number | DataView | string | Array<unknown> | Record<string, unknown> | unknown): void {
+ this.integrityCheckOnValueAddition();
+ if (typeof value === 'undefined') {
+ throw "You need to provide a value";
+ }
+ if (value === null) {
+ this.stack.push(this.nullStackValue());
+ } else if (typeof value === "boolean") {
+ this.stack.push(this.boolStackValue(value));
+ } else if (typeof value === "bigint") {
+ this.stack.push(this.intStackValue(value));
+ } else if (typeof value == 'number') {
+ if (Number.isInteger(value)) {
+ this.stack.push(this.intStackValue(value));
+ } else {
+ this.stack.push(this.floatStackValue(value));
+ }
+ } else if (ArrayBuffer.isView(value)) {
+ this.writeBlob(value.buffer);
+ } else if (typeof value === 'string' || value instanceof String) {
+ this.writeString(value as string);
+ } else if (Array.isArray(value)) {
+ this.startVector();
+ for (let i = 0; i < value.length; i++) {
+ this.add(value[i]);
+ }
+ this.end();
+ } else if (typeof value === 'object') {
+ const properties = Object.getOwnPropertyNames(value).sort();
+ this.startMap(true);
+ for (let i = 0; i < properties.length; i++) {
+ const key = properties[i];
+ this.addKey(key);
+ this.add((value as Record<string, unknown>)[key]);
+ }
+ this.end();
+ } else {
+ throw `Unexpected value input ${value}`;
+ }
+ }
+
+ finish(): Uint8Array {
+ if (!this.finished) {
+ this.finishBuffer();
+ }
+ const result = this.buffer.slice(0, this.offset);
+ return new Uint8Array(result);
+ }
+
+ isFinished(): boolean {
+ return this.finished;
+ }
+
+ addKey(key: string): void {
+ this.integrityCheckOnKeyAddition();
+ this.writeKey(key);
+ }
+
+ addInt(value: number, indirect = false, deduplicate = false): void {
+ this.integrityCheckOnValueAddition();
+ if (!indirect) {
+ this.stack.push(this.intStackValue(value));
+ return;
+ }
+ if (deduplicate && Object.prototype.hasOwnProperty.call(this.indirectIntLookup, value)) {
+ this.stack.push(this.indirectIntLookup[value]);
+ return;
+ }
+ const stackValue = this.intStackValue(value);
+ const byteWidth = this.align(stackValue.width);
+ const newOffset = this.computeOffset(byteWidth);
+ const valueOffset = this.offset;
+ stackValue.writeToBuffer(byteWidth);
+ const stackOffset = this.offsetStackValue(valueOffset, ValueType.INDIRECT_INT, stackValue.width);
+ this.stack.push(stackOffset);
+ this.offset = newOffset;
+ if (deduplicate) {
+ this.indirectIntLookup[value] = stackOffset;
+ }
+ }
+
+ addUInt(value: number, indirect = false, deduplicate = false): void {
+ this.integrityCheckOnValueAddition();
+ if (!indirect) {
+ this.stack.push(this.uintStackValue(value));
+ return;
+ }
+ if (deduplicate && Object.prototype.hasOwnProperty.call(this.indirectUIntLookup, value)) {
+ this.stack.push(this.indirectUIntLookup[value]);
+ return;
+ }
+ const stackValue = this.uintStackValue(value);
+ const byteWidth = this.align(stackValue.width);
+ const newOffset = this.computeOffset(byteWidth);
+ const valueOffset = this.offset;
+ stackValue.writeToBuffer(byteWidth);
+ const stackOffset = this.offsetStackValue(valueOffset, ValueType.INDIRECT_UINT, stackValue.width);
+ this.stack.push(stackOffset);
+ this.offset = newOffset;
+ if (deduplicate) {
+ this.indirectUIntLookup[value] = stackOffset;
+ }
+ }
+
+ addFloat(value: number, indirect = false, deduplicate = false): void {
+ this.integrityCheckOnValueAddition();
+ if (!indirect) {
+ this.stack.push(this.floatStackValue(value));
+ return;
+ }
+ if (deduplicate && Object.prototype.hasOwnProperty.call(this.indirectFloatLookup, value)) {
+ this.stack.push(this.indirectFloatLookup[value]);
+ return;
+ }
+ const stackValue = this.floatStackValue(value);
+ const byteWidth = this.align(stackValue.width);
+ const newOffset = this.computeOffset(byteWidth);
+ const valueOffset = this.offset;
+ stackValue.writeToBuffer(byteWidth);
+ const stackOffset = this.offsetStackValue(valueOffset, ValueType.INDIRECT_FLOAT, stackValue.width);
+ this.stack.push(stackOffset);
+ this.offset = newOffset;
+ if (deduplicate) {
+ this.indirectFloatLookup[value] = stackOffset;
+ }
+ }
+}
diff --git a/ts/flexbuffers/flexbuffers-util.ts b/ts/flexbuffers/flexbuffers-util.ts
new file mode 100644
index 0000000..83186e9
--- /dev/null
+++ b/ts/flexbuffers/flexbuffers-util.ts
@@ -0,0 +1,9 @@
+export function fromUTF8Array(data: BufferSource): string {
+ const decoder = new TextDecoder();
+ return decoder.decode(data);
+}
+
+export function toUTF8Array(str: string) : Uint8Array {
+ const encoder = new TextEncoder();
+ return encoder.encode(str);
+}
\ No newline at end of file
diff --git a/ts/flexbuffers/reference-util.ts b/ts/flexbuffers/reference-util.ts
new file mode 100644
index 0000000..a5eb48d
--- /dev/null
+++ b/ts/flexbuffers/reference-util.ts
@@ -0,0 +1,119 @@
+import { BitWidth } from './bit-width'
+import { toByteWidth, fromByteWidth } from './bit-width-util'
+import { toUTF8Array, fromUTF8Array } from './flexbuffers-util'
+import { Reference } from './reference'
+
+import { Long } from '../long'
+
+export function validateOffset(dataView: DataView, offset: number, width: number): void {
+ if (dataView.byteLength <= offset + width || (offset & (toByteWidth(width) - 1)) !== 0) {
+ throw "Bad offset: " + offset + ", width: " + width;
+ }
+}
+
+export function readInt(dataView: DataView, offset: number, width: number): number | Long | bigint {
+ if (width < 2) {
+ if (width < 1) {
+ return dataView.getInt8(offset);
+ } else {
+ return dataView.getInt16(offset, true);
+ }
+ } else {
+ if (width < 3) {
+ return dataView.getInt32(offset, true)
+ } else {
+ if (dataView.setBigInt64 === undefined) {
+ return new Long(dataView.getUint32(offset, true), dataView.getUint32(offset + 4, true))
+ }
+ return dataView.getBigInt64(offset, true)
+ }
+ }
+}
+
+export function readUInt(dataView: DataView, offset: number, width: number): number | Long | bigint {
+ if (width < 2) {
+ if (width < 1) {
+ return dataView.getUint8(offset);
+ } else {
+ return dataView.getUint16(offset, true);
+ }
+ } else {
+ if (width < 3) {
+ return dataView.getUint32(offset, true)
+ } else {
+ if (dataView.getBigUint64 === undefined) {
+ return new Long(dataView.getUint32(offset, true), dataView.getUint32(offset + 4, true))
+ }
+ return dataView.getBigUint64(offset, true)
+ }
+ }
+}
+
+export function readFloat(dataView: DataView, offset: number, width: number): number {
+ if (width < BitWidth.WIDTH32) {
+ throw "Bad width: " + width;
+ }
+ if (width === BitWidth.WIDTH32) {
+ return dataView.getFloat32(offset, true);
+ }
+ return dataView.getFloat64(offset, true);
+}
+
+export function indirect(dataView: DataView, offset: number, width: number): number {
+ const step = readUInt(dataView, offset, width) as number;
+ return offset - step;
+}
+
+export function keyIndex(key: string, dataView: DataView, offset: number, parentWidth: number, byteWidth: number, length: number): number | null {
+ const input = toUTF8Array(key);
+ const keysVectorOffset = indirect(dataView, offset, parentWidth) - byteWidth * 3;
+ const bitWidth = fromByteWidth(byteWidth);
+ const indirectOffset = keysVectorOffset - (readUInt(dataView, keysVectorOffset, bitWidth) as number);
+ const _byteWidth = readUInt(dataView, keysVectorOffset + byteWidth, bitWidth) as number;
+ let low = 0;
+ let high = length - 1;
+ while (low <= high) {
+ const mid = (high + low) >> 1;
+ const dif = diffKeys(input, mid, dataView, indirectOffset, _byteWidth);
+ if (dif === 0) return mid;
+ if (dif < 0) {
+ high = mid - 1;
+ } else {
+ low = mid + 1;
+ }
+ }
+ return null;
+}
+
+export function diffKeys(input: Uint8Array, index: number, dataView: DataView, offset: number, width: number): number {
+ const keyOffset = offset + index * width;
+ const keyIndirectOffset = keyOffset - (readUInt(dataView, keyOffset, fromByteWidth(width)) as number);
+ for (let i = 0; i < input.length; i++) {
+ const dif = input[i] - dataView.getUint8(keyIndirectOffset + i);
+ if (dif !== 0) {
+ return dif;
+ }
+ }
+ return dataView.getUint8(keyIndirectOffset + input.length) === 0 ? 0 : -1;
+}
+
+export function valueForIndexWithKey(index: number, key: string, dataView: DataView, offset: number, parentWidth: number, byteWidth: number, length: number, path: string): Reference {
+ const _indirect = indirect(dataView, offset, parentWidth);
+ const elementOffset = _indirect + index * byteWidth;
+ const packedType = dataView.getUint8(_indirect + length * byteWidth + index);
+ return new Reference(dataView, elementOffset, fromByteWidth(byteWidth), packedType, `${path}/${key}`)
+}
+
+export function keyForIndex(index: number, dataView: DataView, offset: number, parentWidth: number, byteWidth: number): string {
+ const keysVectorOffset = indirect(dataView, offset, parentWidth) - byteWidth * 3;
+ const bitWidth = fromByteWidth(byteWidth);
+ const indirectOffset = keysVectorOffset - (readUInt(dataView, keysVectorOffset, bitWidth) as number);
+ const _byteWidth = readUInt(dataView, keysVectorOffset + byteWidth, bitWidth) as number;
+ const keyOffset = indirectOffset + index * _byteWidth;
+ const keyIndirectOffset = keyOffset - (readUInt(dataView, keyOffset, fromByteWidth(_byteWidth)) as number);
+ let length = 0;
+ while (dataView.getUint8(keyIndirectOffset + length) !== 0) {
+ length++;
+ }
+ return fromUTF8Array(new Uint8Array(dataView.buffer, keyIndirectOffset, length));
+}
\ No newline at end of file
diff --git a/ts/flexbuffers/reference.ts b/ts/flexbuffers/reference.ts
new file mode 100644
index 0000000..a93c743
--- /dev/null
+++ b/ts/flexbuffers/reference.ts
@@ -0,0 +1,185 @@
+import { fromByteWidth } from './bit-width-util'
+import { ValueType } from './value-type'
+import { isNumber, isIndirectNumber, isAVector, fixedTypedVectorElementSize, isFixedTypedVector, isTypedVector, typedVectorElementType, packedType, fixedTypedVectorElementType } from './value-type-util'
+import { indirect, keyForIndex, keyIndex, readFloat, readInt, readUInt, valueForIndexWithKey } from './reference-util'
+import { Long } from '../long';
+import { fromUTF8Array } from './flexbuffers-util';
+import { BitWidth } from './bit-width';
+
+export function toReference(buffer: Uint8Array): Reference {
+ const len = buffer.byteLength;
+
+ if (len < 3) {
+ throw "Buffer needs to be bigger than 3";
+ }
+
+ const dataView = new DataView(buffer);
+ const byteWidth = dataView.getUint8(len - 1);
+ const packedType = dataView.getUint8(len - 2);
+ const parentWidth = fromByteWidth(byteWidth);
+ const offset = len - byteWidth - 2;
+
+ return new Reference(dataView, offset, parentWidth, packedType, "/")
+}
+
+export class Reference {
+ private readonly byteWidth: number
+ private readonly valueType: ValueType
+ private _length = -1
+ constructor(private dataView: DataView, private offset: number, private parentWidth: number, private packedType: ValueType, private path: string) {
+ this.byteWidth = 1 << (packedType & 3)
+ this.valueType = packedType >> 2
+ }
+
+ isNull(): boolean { return this.valueType === ValueType.NULL; }
+ isNumber(): boolean { return isNumber(this.valueType) || isIndirectNumber(this.valueType); }
+ isFloat(): boolean { return ValueType.FLOAT === this.valueType || ValueType.INDIRECT_FLOAT === this.valueType; }
+ isInt(): boolean { return this.isNumber() && !this.isFloat(); }
+ isString(): boolean { return ValueType.STRING === this.valueType || ValueType.KEY === this.valueType; }
+ isBool(): boolean { return ValueType.BOOL === this.valueType; }
+ isBlob(): boolean { return ValueType.BLOB === this.valueType; }
+ isVector(): boolean { return isAVector(this.valueType); }
+ isMap(): boolean { return ValueType.MAP === this.valueType; }
+
+ boolValue(): boolean | null {
+ if (this.isBool()) {
+ return readInt(this.dataView, this.offset, this.parentWidth) > 0;
+ }
+ return null;
+ }
+
+ intValue(): number | Long | bigint | null {
+ if (this.valueType === ValueType.INT) {
+ return readInt(this.dataView, this.offset, this.parentWidth);
+ }
+ if (this.valueType === ValueType.UINT) {
+ return readUInt(this.dataView, this.offset, this.parentWidth);
+ }
+ if (this.valueType === ValueType.INDIRECT_INT) {
+ return readInt(this.dataView, indirect(this.dataView, this.offset, this.parentWidth), fromByteWidth(this.byteWidth));
+ }
+ if (this.valueType === ValueType.INDIRECT_UINT) {
+ return readUInt(this.dataView, indirect(this.dataView, this.offset, this.parentWidth), fromByteWidth(this.byteWidth));
+ }
+ return null;
+ }
+
+ floatValue(): number | null {
+ if (this.valueType === ValueType.FLOAT) {
+ return readFloat(this.dataView, this.offset, this.parentWidth);
+ }
+ if (this.valueType === ValueType.INDIRECT_FLOAT) {
+ return readFloat(this.dataView, indirect(this.dataView, this.offset, this.parentWidth), fromByteWidth(this.byteWidth));
+ }
+ return null;
+ }
+
+ numericValue(): number | Long | bigint | null { return this.floatValue() || this.intValue()}
+
+ stringValue(): string | null {
+ if (this.valueType === ValueType.STRING || this.valueType === ValueType.KEY) {
+ const begin = indirect(this.dataView, this.offset, this.parentWidth);
+ return fromUTF8Array(new Uint8Array(this.dataView.buffer, begin, this.length()));
+ }
+ return null;
+ }
+
+ blobValue(): Uint8Array | null {
+ if (this.isBlob()) {
+ const begin = indirect(this.dataView, this.offset, this.parentWidth);
+ return new Uint8Array(this.dataView.buffer, begin, this.length());
+ }
+ return null;
+ }
+
+ get(key: number): Reference {
+ const length = this.length();
+ if (Number.isInteger(key) && isAVector(this.valueType)) {
+ if (key >= length || key < 0) {
+ throw `Key: [${key}] is not applicable on ${this.path} of ${this.valueType} length: ${length}`;
+ }
+ const _indirect = indirect(this.dataView, this.offset, this.parentWidth);
+ const elementOffset = _indirect + key * this.byteWidth;
+ let _packedType = this.dataView.getUint8(_indirect + length * this.byteWidth + key);
+ if (isTypedVector(this.valueType)) {
+ const _valueType = typedVectorElementType(this.valueType);
+ _packedType = packedType(_valueType, BitWidth.WIDTH8);
+ } else if (isFixedTypedVector(this.valueType)) {
+ const _valueType = fixedTypedVectorElementType(this.valueType);
+ _packedType = packedType(_valueType, BitWidth.WIDTH8);
+ }
+ return new Reference(this.dataView, elementOffset, fromByteWidth(this.byteWidth), _packedType, `${this.path}[${key}]`);
+ }
+ if (typeof key === 'string') {
+ const index = keyIndex(key, this.dataView, this.offset, this.parentWidth, this.byteWidth, length);
+ if (index !== null) {
+ return valueForIndexWithKey(index, key, this.dataView, this.offset, this.parentWidth, this.byteWidth, length, this.path)
+ }
+ }
+ throw `Key [${key}] is not applicable on ${this.path} of ${this.valueType}`;
+ }
+
+ length(): number {
+ let size;
+ if (this._length > -1) {
+ return this._length;
+ }
+ if (isFixedTypedVector(this.valueType)) {
+ this._length = fixedTypedVectorElementSize(this.valueType);
+ } else if (this.valueType === ValueType.BLOB
+ || this.valueType === ValueType.MAP
+ || isAVector(this.valueType)) {
+ this._length = readUInt(this.dataView, indirect(this.dataView, this.offset, this.parentWidth) - this.byteWidth, fromByteWidth(this.byteWidth)) as number
+ } else if (this.valueType === ValueType.NULL) {
+ this._length = 0;
+ } else if (this.valueType === ValueType.STRING) {
+ const _indirect = indirect(this.dataView, this.offset, this.parentWidth);
+ let sizeByteWidth = this.byteWidth;
+ size = readUInt(this.dataView, _indirect - sizeByteWidth, fromByteWidth(this.byteWidth));
+ while (this.dataView.getInt8(_indirect + (size as number)) !== 0) {
+ sizeByteWidth <<= 1;
+ size = readUInt(this.dataView, _indirect - sizeByteWidth, fromByteWidth(this.byteWidth));
+ }
+ this._length = size as number;
+ } else if (this.valueType === ValueType.KEY) {
+ const _indirect = indirect(this.dataView, this.offset, this.parentWidth);
+ size = 1;
+ while (this.dataView.getInt8(_indirect + size) !== 0) {
+ size++;
+ }
+ this._length = size;
+ } else {
+ this._length = 1;
+ }
+ return this._length;
+ }
+
+ toObject(): unknown {
+ const length = this.length();
+ if (this.isVector()) {
+ const result = [];
+ for (let i = 0; i < length; i++) {
+ result.push(this.get(i).toObject());
+ }
+ return result;
+ }
+ if (this.isMap()) {
+ const result: Record<string, unknown> = {};
+ for (let i = 0; i < length; i++) {
+ const key = keyForIndex(i, this.dataView, this.offset, this.parentWidth, this.byteWidth);
+ result[key] = valueForIndexWithKey(i, key, this.dataView, this.offset, this.parentWidth, this.byteWidth, length, this.path).toObject();
+ }
+ return result;
+ }
+ if (this.isNull()) {
+ return null;
+ }
+ if (this.isBool()) {
+ return this.boolValue();
+ }
+ if (this.isNumber()) {
+ return this.numericValue();
+ }
+ return this.blobValue() || this.stringValue();
+ }
+}
diff --git a/ts/flexbuffers/stack-value.ts b/ts/flexbuffers/stack-value.ts
new file mode 100644
index 0000000..ef8e2f1
--- /dev/null
+++ b/ts/flexbuffers/stack-value.ts
@@ -0,0 +1,61 @@
+import { Builder } from './builder'
+import { BitWidth } from './bit-width'
+import { paddingSize, uwidth, fromByteWidth } from './bit-width-util'
+import { ValueType } from './value-type'
+import { isInline, packedType } from './value-type-util'
+
+export class StackValue {
+ constructor(private builder: Builder, public type: ValueType, public width: number, public value: number | boolean | null = null, public offset: number = 0) {
+
+ }
+
+ elementWidth(size: number, index: number): BitWidth {
+ if (isInline(this.type)) return this.width;
+ for (let i = 0; i < 4; i++) {
+ const width = 1 << i;
+ const offsetLoc = size + paddingSize(size, width) + index * width;
+ const offset = offsetLoc - this.offset;
+ const bitWidth = uwidth(offset);
+ if (1 << bitWidth === width) {
+ return bitWidth;
+ }
+ }
+ throw `Element is unknown. Size: ${size} at index: ${index}. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new`;
+ }
+
+ writeToBuffer(byteWidth: number): void {
+ const newOffset = this.builder.computeOffset(byteWidth);
+ if (this.type === ValueType.FLOAT) {
+ if (this.width === BitWidth.WIDTH32) {
+ this.builder.view.setFloat32(this.builder.offset, this.value as number, true);
+ } else {
+ this.builder.view.setFloat64(this.builder.offset, this.value as number, true);
+ }
+ } else if (this.type === ValueType.INT) {
+ const bitWidth = fromByteWidth(byteWidth);
+ this.builder.pushInt(this.value as number, bitWidth);
+ } else if (this.type === ValueType.UINT) {
+ const bitWidth = fromByteWidth(byteWidth);
+ this.builder.pushUInt(this.value as number, bitWidth);
+ } else if (this.type === ValueType.NULL) {
+ this.builder.pushInt(0, this.width);
+ } else if (this.type === ValueType.BOOL) {
+ this.builder.pushInt(this.value ? 1 : 0, this.width);
+ } else {
+ throw `Unexpected type: ${this.type}. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new`
+ }
+ this.offset = newOffset;
+ }
+
+ storedWidth(width = BitWidth.WIDTH8): BitWidth {
+ return isInline(this.type) ? Math.max(width, this.width) : this.width;
+ }
+
+ storedPackedType(width = BitWidth.WIDTH8): ValueType {
+ return packedType(this.type, this.storedWidth(width));
+ }
+
+ isOffset(): boolean {
+ return !isInline(this.type)
+ }
+}
\ No newline at end of file
diff --git a/ts/flexbuffers/value-type-util.ts b/ts/flexbuffers/value-type-util.ts
new file mode 100644
index 0000000..da869a9
--- /dev/null
+++ b/ts/flexbuffers/value-type-util.ts
@@ -0,0 +1,64 @@
+import { ValueType } from './value-type'
+
+export function isInline(value: ValueType): boolean {
+ return value === ValueType.BOOL
+ || value <= ValueType.FLOAT;
+}
+
+export function isNumber(value: ValueType): boolean {
+ return value >= ValueType.INT
+ && value <= ValueType.FLOAT;
+}
+
+export function isIndirectNumber(value: ValueType): boolean {
+ return value >= ValueType.INDIRECT_INT
+ && value <= ValueType.INDIRECT_FLOAT;
+}
+
+export function isTypedVectorElement(value: ValueType): boolean {
+ return value === ValueType.BOOL
+ || (value >= ValueType.INT
+ && value <= ValueType.STRING);
+}
+
+export function isTypedVector(value: ValueType): boolean {
+ return value === ValueType.VECTOR_BOOL
+ || (value >= ValueType.VECTOR_INT
+ && value <= ValueType.VECTOR_STRING_DEPRECATED);
+}
+
+export function isFixedTypedVector(value: ValueType): boolean {
+ return value >= ValueType.VECTOR_INT2
+ && value <= ValueType.VECTOR_FLOAT4;
+}
+
+export function isAVector(value: ValueType): boolean {
+ return isTypedVector(value)
+ || isFixedTypedVector(value)
+ || value === ValueType.VECTOR;
+}
+
+export function toTypedVector(valueType: ValueType, length: number): ValueType {
+ if (length === 0) return valueType - ValueType.INT + ValueType.VECTOR_INT;
+ if (length === 2) return valueType - ValueType.INT + ValueType.VECTOR_INT2;
+ if (length === 3) return valueType - ValueType.INT + ValueType.VECTOR_INT3;
+ if (length === 4) return valueType - ValueType.INT + ValueType.VECTOR_INT4;
+ throw "Unexpected length " + length;
+}
+
+export function typedVectorElementType(valueType: ValueType): ValueType {
+ return valueType - ValueType.VECTOR_INT + ValueType.INT;
+}
+
+export function fixedTypedVectorElementType(valueType: ValueType): ValueType {
+ return ((valueType - ValueType.VECTOR_INT2) % 3) + ValueType.INT;
+}
+
+export function fixedTypedVectorElementSize(valueType: ValueType): ValueType {
+ // The x / y >> 0 trick is to have an int division. Suppose to be faster than Math.floor()
+ return (((valueType - ValueType.VECTOR_INT2) / 3) >> 0) + 2;
+}
+
+export function packedType(valueType: ValueType, bitWidth: number): ValueType {
+ return bitWidth | (valueType << 2);
+}
\ No newline at end of file
diff --git a/ts/flexbuffers/value-type.ts b/ts/flexbuffers/value-type.ts
new file mode 100644
index 0000000..9c88ba2
--- /dev/null
+++ b/ts/flexbuffers/value-type.ts
@@ -0,0 +1,30 @@
+export enum ValueType {
+ NULL = 0,
+ INT = 1,
+ UINT = 2,
+ FLOAT = 3,
+ KEY = 4,
+ STRING = 5,
+ INDIRECT_INT = 6,
+ INDIRECT_UINT = 7,
+ INDIRECT_FLOAT = 8,
+ MAP = 9,
+ VECTOR = 10,
+ VECTOR_INT = 11,
+ VECTOR_UINT = 12,
+ VECTOR_FLOAT = 13,
+ VECTOR_KEY = 14,
+ VECTOR_STRING_DEPRECATED = 15,
+ VECTOR_INT2 = 16,
+ VECTOR_UINT2 = 17,
+ VECTOR_FLOAT2 = 18,
+ VECTOR_INT3 = 19,
+ VECTOR_UINT3 = 20,
+ VECTOR_FLOAT3 = 21,
+ VECTOR_INT4 = 22,
+ VECTOR_UINT4 = 23,
+ VECTOR_FLOAT4 = 24,
+ BLOB = 25,
+ BOOL = 26,
+ VECTOR_BOOL = 36,
+}
\ No newline at end of file
diff --git a/ts/long.ts b/ts/long.ts
new file mode 100644
index 0000000..50a3ea8
--- /dev/null
+++ b/ts/long.ts
@@ -0,0 +1,23 @@
+export function createLong(low: number, high: number): Long {
+ return Long.create(low, high);
+}
+
+export class Long {
+ static readonly ZERO = new Long(0, 0)
+ low: number
+ high: number
+ constructor(low: number, high: number) {
+ this.low = low | 0;
+ this.high = high | 0;
+ }
+ static create(low: number, high: number): Long {
+ // Special-case zero to avoid GC overhead for default values
+ return low == 0 && high == 0 ? Long.ZERO : new Long(low, high);
+ }
+ toFloat64(): number {
+ return (this.low >>> 0) + this.high * 0x100000000;
+ }
+ equals(other: Long): boolean {
+ return this.low == other.low && this.high == other.high;
+ }
+}
\ No newline at end of file
diff --git a/ts/types.ts b/ts/types.ts
new file mode 100644
index 0000000..30e4050
--- /dev/null
+++ b/ts/types.ts
@@ -0,0 +1,14 @@
+import { ByteBuffer } from './byte-buffer'
+import { Builder } from './builder'
+
+export type Offset = number;
+
+export type Table = {
+ bb: ByteBuffer
+ bb_pos: number
+};
+
+export interface IGeneratedObject {
+ pack(builder:Builder): Offset
+ unpack(): IGeneratedObject
+}
\ No newline at end of file
diff --git a/ts/utils.ts b/ts/utils.ts
new file mode 100644
index 0000000..a2902e3
--- /dev/null
+++ b/ts/utils.ts
@@ -0,0 +1,4 @@
+export const int32 = new Int32Array(2);
+export const float32 = new Float32Array(int32.buffer);
+export const float64 = new Float64Array(int32.buffer);
+export const isLittleEndian = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
\ No newline at end of file