Bumping to Version 2.0.5 (#6967)

* Fix C/C++ Create<Type>Direct with sorted vectors

If a struct has a key the vector has to be sorted. To sort the vector
you can't use "const".

* Changes due to code review

* Improve code readability

* Add generate of JSON schema to string to lib

* option indent_step is supported

* Remove unused variables

* Fix break in test

* Fix style to be consistent with rest of the code

* [TS] Fix reserved words as arguments (#6955)

.appveyor/check-generate-code.bat

@@ -1,41 +0,0 @@
-:: Copyright 2018 Google Inc. All rights reserved.
-::
-:: Licensed under the Apache License, Version 2.0 (the "License");
-:: you may not use this file except in compliance with the License.
-:: You may obtain a copy of the License at
-::
-::     http://www.apache.org/licenses/LICENSE-2.0
-::
-:: Unless required by applicable law or agreed to in writing, software
-:: distributed under the License is distributed on an "AS IS" BASIS,
-:: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-:: See the License for the specific language governing permissions and
-:: limitations under the License.
-set buildtype=Release
-if "%1"=="-b" set buildtype=%2
-
-cd tests
-call generate_code.bat -b %buildtype% || goto FAIL
-
-:: TODO: Release and Debug builds produce differences here for some reason.
-git checkout HEAD -- monster_test.bfbs
-git checkout HEAD -- arrays_test.bfbs
-
-git -c core.autocrlf=true diff --exit-code --quiet || goto :DIFFFOUND
-goto SUCCESS
-
-:DIFFFOUND
-@echo "" >&2
-@echo "ERROR: ********************************************************" >&2
-@echo "ERROR: The following differences were found after running the" >&2
-@echo "ERROR: tests/generate_code.sh script.  Maybe you forgot to run" >&2
-@echo "ERROR: it after making changes in a generator or schema?" >&2
-@echo "ERROR: ********************************************************" >&2
-@echo "" >&2
-@git -c core.autocrlf=true --no-pager diff --binary
-
-:FAIL
-set EXITCODE=1
-:SUCCESS
-cd ..
-EXIT /B %EXITCODE%

.bazelci/presubmit.yml

@@ -1,18 +1,18 @@
 ---
 buildifier: latest
 platforms:
-  ubuntu1604:
-    build_targets:
-    - "..."
-    test_targets:
-    - "..."
   ubuntu1804:
     build_targets:
-    - "..."
+    - "//..."
     test_targets:
-    - "..."
+    - "//..."
+  ubuntu2004:
+    build_targets:
+    - "//..."
+    test_targets:
+    - "//..."
   macos:
     build_targets:
-    - "..."
+    - "//..."
     test_targets:
-    - "..."
+    - "//..."

.eslintrc.js

@@ -0,0 +1,13 @@
+/* eslint-env node */
+
+module.exports = {
+    root: true,
+    parser: '@typescript-eslint/parser',
+    plugins: [
+        '@typescript-eslint',
+    ],
+    extends: [
+        'eslint:recommended',
+        'plugin:@typescript-eslint/recommended',
+    ]
+};

.github/PULL_REQUEST_TEMPLATE.md

@@ -2,18 +2,17 @@ Thank you for submitting a PR!
 
 Please delete this standard text once you've created your own description.
 
-Make sure you include the names of the affected language(s) in your PR title.
-This helps us get the correct maintainers to look at your issue.
+If you make changes to any of the code generators (`src/idl_gen*`) be sure to
+build your project, as it will generate code based on the changes. If necessary
+the code generation script can be directly run (`scripts/generate_code.py`),
+requires Python3. This allows us to better see the effect of the PR.
 
-If you make changes to any of the code generators, be sure to run
-`cd tests && sh generate_code.sh` (or equivalent .bat) and include the generated
-code changes in the PR. This allows us to better see the effect of the PR.
-
-If your PR includes C++ code, please adhere to the Google C++ Style Guide,
+If your PR includes C++ code, please adhere to the
+[Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html),
 and don't forget we try to support older compilers (e.g. VS2010, GCC 4.6.3),
 so only some C++11 support is available.
 
-For any C++ changes, please make sure to run `sh src/clang-format-git.sh`
+For any C++ changes, please make sure to run `sh scripts/clang-format-git.sh`
 
 Include other details as appropriate.
 

.github/labeler.yml

@@ -0,0 +1,97 @@
+# Configuration for Auto Labeler during pull request
+#
+# See https://github.com/actions/labeler for file format
+# and https://github.com/google/flatbuffers/labels for a list of valid labels
+#
+# See .github/workflows/label.yml for Github Action workflow script
+
+c#:
+  - '**/*.cs'
+  - net/**/*
+  - tests/FlatBuffers.Test/**/*
+  - tests/FlatBuffers.Benchmarks/**/*
+  - src/idl_gen_csharp.cpp
+
+swift:
+  - '**/*.swift'
+  - swift/**/*
+  - tests/FlatBuffers.GRPC.Swift/**/*
+  - tests/FlatBuffers.Benchmarks.swift/**/*
+  - tests/FlatBuffers.Test.Swift/**/*
+  - src/idl_gen_swift.cpp
+
+javascript:
+  - '**/*.js'
+  - src/idl_gen_ts.cpp
+
+typescript:
+  - '**/*.ts'
+  - src/idl_gen_ts.cpp
+  - grpc/flatbuffers-js-grpc/**/*.ts
+
+golang:
+  - '**/*.go'
+  - src/idl_gen_go.cpp
+
+python:
+  - '**/*.py'
+  - src/idl_gen_python.cpp
+
+java:
+  - '**/*.java'
+  - src/idl_gen_java.cpp
+
+kotlin:
+  - '**/*.kt'
+  - src/idl_gen_kotlin.cpp
+
+lua:
+  - '**/*.lua'
+  - lua/**/*
+  - src/idl_gen_lua.cpp
+  - src/bfbs_gen_lua.cpp
+
+lobster:
+  - '**/*.lobster'
+  - src/idl_gen_lobster.cpp
+
+php:
+  - '**/*.php'
+  - src/idl_gen_php.cpp
+
+rust:
+  - '**/*.rs'
+  - rust/**/*
+  - src/idl_gen_rust.cpp
+  
+dart:
+  - '**/*.dart'
+  - src/idl_gen_dart.cpp
+
+c++:
+  - '**/*.cc'
+  - '**/*.cpp'
+  - '**/*.h'
+
+json:
+  - '**/*.json'
+  - src/idl_gen_json_schema.cpp
+
+codegen:
+  - src/**/*
+
+documentation:
+  - docs/**/*
+  - '**/*.md'
+
+CI:
+  - '.github/**/*'
+  - '.appveyor/**/*'
+  - '.travis/**/*'
+  - '.bazelci/**/*'
+  - .travis.yml
+  - appveyor.yml
+
+grpc:
+  - grpc/**/*
+  - src/idl_gen_grpc.cpp

.github/stale.yml

@@ -1,18 +0,0 @@
-# Number of days of inactivity before an issue becomes stale
-daysUntilStale: 365
-# Number of days of inactivity before a stale issue is closed
-daysUntilClose: 14
-# Issues with these labels will never be considered stale
-exemptLabels:
-  - pinned
-  - security
-# Label to use when marking an issue as stale
-staleLabel: stale
-# Comment to post when marking an issue as stale. Set to `false` to disable
-markComment: >
-  This issue has been automatically marked as stale because it has not had
-  activity for 1 year. It will be automatically closed if no further activity occurs.
-  To keep it open, simply post a new comment. Maintainers will re-open on
-  new activity. Thank you for your contributions.
-# Comment to post when closing a stale issue. Set to `false` to disable
-closeComment: false

.github/workflows/build.yml

@@ -0,0 +1,274 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build-linux:
+    name: Build Linux
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        cxx: [g++-10, clang++-12]
+    steps:
+    - uses: actions/checkout@v1
+    - name: cmake
+      run: CXX=${{ matrix.cxx }} cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release .
+    - name: build
+      run: make -j4
+    - name: test
+      run: ./flattests
+    - name: make flatc executable
+      run: |
+        chmod +x flatc
+        ./flatc --version
+    - name: upload build artifacts
+      uses: actions/upload-artifact@v1
+      with:
+        name: Linux flatc binary ${{ matrix.cxx }}
+        path: flatc
+
+  build-windows:
+    name: Build Windows 2019 
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: Add msbuild to PATH
+      uses: microsoft/setup-msbuild@v1.1
+    - name: cmake
+      run: cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_CPP17=ON .
+    - name: build
+      run: msbuild.exe FlatBuffers.sln /p:Configuration=Release /p:Platform=x64
+    - name: test
+      run: Release\flattests.exe
+    - name: upload build artifacts
+      uses: actions/upload-artifact@v1
+      with:
+        name: Windows flatc binary
+        path: Release\flatc.exe
+
+  build-windows-2017:
+    name: Build Windows 2017
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: Add msbuild to PATH
+      uses: microsoft/setup-msbuild@v1.1
+    - name: cmake
+      run: cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_BUILD_TYPE=Release .
+    - name: build tool version 15 (VS 2017)
+      run: msbuild.exe FlatBuffers.sln /p:Configuration=Release /p:Platform=x64 /p:VisualStudioVersion=15.0
+    - name: test
+      run: Release\flattests.exe
+
+  build-windows-2015:
+    name: Build Windows 2015
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: Add msbuild to PATH
+      uses: microsoft/setup-msbuild@v1.1
+    - name: cmake
+      run: cmake -G "Visual Studio 14 2015" -A x64 -DCMAKE_BUILD_TYPE=Release .
+    - name: build tool version 14 (VS 2015)
+      run: msbuild.exe FlatBuffers.sln /p:Configuration=Release /p:Platform=x64 /p:VisualStudioVersion=14.0
+    - name: test
+      run: Release\flattests.exe
+
+  build-mac:
+    name: Build Mac
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: cmake
+      run: cmake -G "Xcode" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_FLATC_EXECUTABLE=_build/Release/flatc .
+    - name: build
+      # NOTE: we need this _build dir to not have xcodebuild's default ./build dir clash with the BUILD file.
+      run: xcodebuild -toolchain clang -configuration Release -target flattests SYMROOT=$(PWD)/_build
+    - name: check that the binary is "universal"
+      run: |
+        info=$(file _build/Release/flatc)
+        echo $info
+        echo $info | grep "universal binary with 2 architectures"
+    - name: test
+      run: _build/Release/flattests
+    - name: make flatc executable
+      run: |
+        chmod +x _build/Release/flatc
+        ./_build/Release/flatc --version
+    - name: upload build artifacts
+      uses: actions/upload-artifact@v1
+      with:
+        name: Mac flatc binary
+        path: _build/Release/flatc
+
+  build-android:
+   name: Build Android (on Linux)
+   runs-on: ubuntu-latest
+   steps:
+   - uses: actions/checkout@v1
+   - name: set up JDK 1.8
+     uses: actions/setup-java@v1
+     with:
+       java-version: 1.8
+   - name: set up flatc
+     run: |
+       cmake -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF .
+       make
+       echo "${PWD}" >> $GITHUB_PATH
+   - name: build
+     working-directory: android
+     run: bash ./gradlew clean build
+
+  build-generator:
+    name: Check Generated Code
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        cxx: [g++-10, clang++-12]
+    steps:
+    - uses: actions/checkout@v1
+    - name: cmake
+      run: CXX=${{ matrix.cxx }} cmake -G "Unix Makefiles" -DFLATBUFFERS_BUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=Release . && make -j4
+    - name: Generate
+      run: scripts/check_generate_code.py
+    - name: Generate gRPC
+      run: bash scripts/check-grpc-generated-code.sh
+
+  build-benchmarks:
+    name: Build Benchmarks (on Linux)
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        cxx: [g++-10]
+    steps:
+    - uses: actions/checkout@v1
+    - name: cmake
+      run: CXX=${{ matrix.cxx }} cmake -G "Unix Makefiles" -DFLATBUFFERS_CXX_FLAGS="-Wno-unused-parameter -fno-aligned-new" -DFLATBUFFERS_BUILD_BENCHMARKS=ON -DCMAKE_BUILD_TYPE=Release . && make -j4
+    - name: Run benchmarks
+      run: ./flatbenchmark --benchmark_repetitions=5 --benchmark_display_aggregates_only=true --benchmark_out_format=console --benchmark_out=benchmarks/results_${{matrix.cxx}}
+    - name: Upload benchmarks results
+      uses: actions/upload-artifact@v1
+      with:
+        name: Linux flatbenchmark results ${{matrix.cxx}}
+        path: benchmarks/results_${{matrix.cxx}}
+
+  build-java:
+    name: Build Java
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: test
+      working-directory: tests
+      run: bash JavaTest.sh
+
+  build-kotlin-macos:
+    name: Build Kotlin MacOS
+    runs-on: macos-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+    - uses: actions/setup-java@v2
+      with:
+        distribution: 'adopt-hotspot'
+        java-version: '11'
+    - name: Build
+      working-directory: kotlin
+      run: ./gradlew clean iosX64Test macosX64Test jsTest jsBrowserTest
+
+  build-kotlin-linux:
+    name: Build Kotlin Linux
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+    - uses: actions/setup-java@v2
+      with:
+        distribution: 'adopt-hotspot'
+        java-version: '8'
+    - name: Build
+      working-directory: kotlin
+      run: ./gradlew jvmMainClasses jvmTest
+    - name: Run Benchmark
+      working-directory: kotlin
+      run: ./gradlew jvmBenchmark
+    - name: Generate Benchmark Report
+      working-directory: kotlin
+      run: |
+        ./gradlew jmhReport;
+        mv benchmark/build/reports/benchmarks/main/* benchmark_latest
+    - name: Archive benchmark report
+      uses: actions/upload-artifact@v1
+      with:
+        name: Kotlin Benchmark Report
+        path: kotlin/benchmark_latest
+
+  build-rust:
+    name: Build Rust
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: test
+      working-directory: tests
+      run: bash RustTest.sh
+
+  build-python:
+    name: Build Python
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: test
+      working-directory: tests
+      run: bash PythonTest.sh
+
+  build-go:
+    name: Build Go
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: flatc
+      # FIXME: make test script not rely on flatc
+      run: cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_INSTALL=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF . && make -j4
+    - name: test
+      working-directory: tests
+      run: bash GoTest.sh
+
+  build-swift:
+    name: Build Swift
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: test
+      working-directory: tests/FlatBuffers.Test.Swift
+      run: sh SwiftTest.sh
+
+  build-ts:
+    name: Build TS
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: compile
+      run: npm run compile
+    - name: test
+      working-directory: tests
+      run: sh TypeScriptTest.sh
+
+  build-dart:
+    name: Build Dart
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: dart-lang/setup-dart@v1
+        with:
+          sdk: stable
+      - name: flatc
+        # FIXME: make test script not rely on flatc
+        run: cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_INSTALL=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF . && make -j4
+      - name: test
+        working-directory: tests
+        run: bash DartTest.sh

.github/workflows/label.yml

@@ -0,0 +1,19 @@
+# This workflow will triage pull requests and apply a label based on the
+# paths that are modified in the pull request.
+#
+# To use this workflow, you will need to set up a .github/labeler.yml
+# file with configuration.  For more information, see:
+# https://github.com/actions/labeler
+
+name: Labeler
+on: [pull_request_target]
+
+jobs:
+  label:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/labeler@main
+      with:
+        repo-token: "${{ secrets.GITHUB_TOKEN }}"

.github/workflows/stale.yml

@@ -0,0 +1,23 @@
+name: Mark stale issues and pull requests
+
+on:
+  schedule:
+  - cron: "30 20 * * *"
+
+jobs:
+  stale:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/stale@v4.0.0
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        stale-pr-message: 'This pull request is stale because it has been open 6 months with no activity. Please comment or this will be closed in 14 days.'
+        stale-issue-message: 'This issue is stale because it has been open 6 months with no activity. Please comment or this will be closed in 14 days.'
+        days-before-stale: 182 # 6 months
+        days-before-close: 14
+        operations-per-run: 1500
+        exempt-issue-labels: not-stale
+        exempt-pr-labels: not-stale
+        exempt-all-milestones: true

.gitignore

@@ -2,6 +2,7 @@
 *_wire.bin
 .DS_Store
 **/.build
+build
 **/Packages
 /*.xcodeproj
 **/xcuserdata/
@@ -45,6 +46,8 @@ project.properties
 proguard-project.txt
 linklint_results
 Makefile
+flatbenchmark
+flatbenchmark.exe
 flatc
 flatc.exe
 flathash
@@ -69,8 +72,6 @@ tests/monsterdata_go_wire.mon
 tests/monsterdata_javascript_wire.mon
 tests/monsterdata_lobster_wire.mon
 tests/monsterdata_rust_wire.mon
-tests/unicode_test.mon
-tests/ts/
 tests/php/
 CMakeLists.txt.user
 CMakeScripts/**
@@ -102,7 +103,10 @@ android/build/
 samples/android/.externalNativeBuild/
 samples/android/.gradle/
 samples/android/build/
-js/flatbuffers.mjs
+js/**/*.js
+js/**/*.d.ts
+mjs/**/*.js
+mjs/**/*.d.ts
 /bazel-bin
 /bazel-flatbuffers
 /bazel-genfiles
@@ -122,6 +126,24 @@ dart/doc/api/
 Cargo.lock
 .corpus**
 .seed**
+.crash**
 grpc/google/
 **/Package.resolved
 .clangd/**
+package-lock.json
+/*.ilk
+/*.pdb
+.clwb
+yarn-error.log
+.cache/
+/flatbuffers.lib
+.cmake/
+**/dist
+**/vendor
+**/go.sum
+flatbuffers.pc
+**/FlatBuffers.Test.Swift.xcodeproj
+**/html/**
+**/latex/**
+# https://cmake.org/cmake/help/latest/module/FetchContent.html#variable:FETCHCONTENT_BASE_DIR
+_deps/

.travis.yml

@@ -104,6 +104,7 @@ matrix:
       - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo ln -s -v -f $(which gcc-$GCC_VERSION) /usr/bin/gcc; fi
 
       script:
+      - pip install cmake
       - bash .travis/check-sources.sh
       - bash grpc/build_grpc.sh
       - cmake .
@@ -114,7 +115,6 @@ matrix:
         -DFLATBUFFERS_CODE_SANITIZE=ON
       - cmake --build . --target all --clean-first -- -j${JOBS}
       - LD_LIBRARY_PATH=$TRAVIS_BUILD_DIR/google/grpc/install/lib ctest --extra-verbose --output-on-failure
-      - bash .travis/check-generate-code.sh
 
     - language: cpp
       os: osx
@@ -125,6 +125,11 @@ matrix:
           - BUILD_TYPE=Release
 
       script:
+      - pip install --user cmake
+      - mkdir ~/cmake_path
+      - ln -s $(find ~/Library/Python -name cmake -type f | head -n 1) ~/cmake_path/cmake
+      - ln -s $(find ~/Library/Python -name ctest -type f | head -n 1) ~/cmake_path/ctest
+      - export PATH=~/cmake_path:${PATH}
       - bash grpc/build_grpc.sh
       - cmake .
         -DCMAKE_BUILD_TYPE=$BUILD_TYPE
@@ -134,7 +139,6 @@ matrix:
         -DFLATBUFFERS_CODE_SANITIZE=ON
       - cmake --build . -- -j${JOBS}
       - DYLD_LIBRARY_PATH=$TRAVIS_BUILD_DIR/google/grpc/install/lib ctest --extra-verbose --output-on-failure
-      - bash .travis/check-generate-code.sh
 
     - <<: *conan-linux-master
       env: CONAN_GCC_VERSIONS=8 CONAN_DOCKER_IMAGE=conanio/gcc8
@@ -185,37 +189,27 @@ matrix:
         components:
           - tools
           - platform-tools
-          - build-tools-25.0.2
-          - android-25
           - extra-android-m2repository
+        licenses:
+          - 'android-sdk-preview-license-52d11cd2'
+          - 'android-sdk-license-.+'
+          - 'google-gdk-license-.+'
       compiler:
         - gcc
-
       before_install:
-        # Output something every 10 minutes or Travis kills the job
-        - while sleep 540; do echo "=====[ $SECONDS seconds still running ]====="; done &
-        # Install the r17c version of the NDK that still so that we can continue to test with gnustl
-        # and stlport.
-        - export ANDROID_NDK_HOME=$HOME/android-ndk
-        - NDK_ZIP=$ANDROID_NDK_HOME/ndk.zip
-        - mkdir -p $ANDROID_NDK_HOME
-        - curl -o $NDK_ZIP https://dl.google.com/android/repository/android-ndk-r17c-linux-x86_64.zip
-        - unzip -q -d $ANDROID_NDK_HOME $NDK_ZIP
-        - rm $NDK_ZIP
-        - mv $ANDROID_NDK_HOME/android-ndk-*/* $ANDROID_NDK_HOME
-        - rmdir $ANDROID_NDK_HOME/android-ndk-*
-        - export CMAKE=$(which cmake)
-        # libc required for prebuilt llvm toolchain the NDK r17c.
-        - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get update -qq; fi
-        - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install -qq libc6; fi
-        # Setup environment for Linux build which is required to build the sample.
-        - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test; fi
-        - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get update -qq; fi
-        - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install -qq g++-$GCC_VERSION; fi
-        - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install -qq gcc-$GCC_VERSION; fi
-        - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo ln -s -v -f $(which g++-$GCC_VERSION) /usr/bin/g++; fi
-        - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo ln -s -v -f $(which gcc-$GCC_VERSION) /usr/bin/gcc; fi
+        - echo y | sdkmanager "platforms;android-30"
+        - echo y | sdkmanager "build-tools;30.0.2"
+        - echo y | sdkmanager "ndk-bundle"
+        - echo y | sdkmanager "cmake;3.6.4111459"
       script:
-        - failed=0; for build_gradle in $(git ls-files | grep build.gradle); do ( cd "$(dirname "${build_gradle}")" && ./gradlew build ) || failed=1; done; exit $((failed))
-        # Kill the sleep loop
-        - kill %1
+        - cmake -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF .; make; export PATH="$PATH:${PWD}"
+        - cd android; ./gradlew clean build
+
+    - language: generic
+      if: type IN (pull_request)
+      os: linux
+      install:
+        - bash .travis/format_install.sh
+
+      script:
+        - bash .travis/format_check.sh

.travis/format_check.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+#
+# Copyright 2021 Google Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set -e
+
+# HACKY solution to make nodejs work.
+source ~/.nvm/nvm.sh
+nvm alias default node
+nvm use default
+
+sh scripts/clang-format-git.sh
+
+# Check formatting for go lang
+
+cd go
+gofmt -w .
+cd ..
+cd grpc/examples/go
+sh format.sh
+cd ../../..
+
+node_modules/.bin/eslint ts/** --ext .ts --quiet --fix
+
+#PYTHON IS DISABLED UNTIL WE CREATE A .pylintrc FILE FOR IT
+pylint python/** --disable=all
+
+swiftformat --config swift.swiftformat .
+
+
+if ! git diff --quiet; then
+  echo >&2
+  echo "ERROR: ********************************************************" >&2
+  echo "ERROR: The following differences were found after running" >&2
+  echo "ERROR: .travis/format_check.sh script. Maybe you forgot to format" >&2
+  echo "ERROR: the code after making changes? please check Formatters.md" >&2
+  echo "ERROR: ********************************************************" >&2
+  echo >&2
+  git diff --binary --exit-code
+fi

.travis/format_install.sh

@@ -0,0 +1,90 @@
+#!/bin/bash
+#
+# Copyright 2020 Google Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set -e
+set -x
+
+# install devtools
+install_languages() {
+  sudo apt update
+
+  # Install nodeJS and yarn
+  wget https://raw.githubusercontent.com/creationix/nvm/v0.31.0/nvm.sh -O ~/.nvm/nvm.sh
+  source ~/.nvm/nvm.sh
+  nvm install node
+  node --version
+  curl -o- -L https://yarnpkg.com/install.sh | bash
+  export PATH="$HOME/.yarn/bin:$PATH"
+  yarn config set prefix ~/.yarn -g
+  export PATH="$HOME/.yarn/bin:$HOME/.config/yarn/global/node_modules/.bin:$PATH"
+
+  # Install swift
+  sudo apt-get install \
+          binutils \
+          git \
+          libc6-dev \
+          libcurl3 \
+          libedit2 \
+          libgcc-5-dev \
+          libpython2.7 \
+          libsqlite3-0 \
+          libstdc++-5-dev \
+          libxml2 \
+          pkg-config \
+          tzdata \
+          zlib1g-dev
+
+  SWIFT_URL=https://swift.org/builds/swift-5.3.1-release/ubuntu1604/swift-5.3.1-RELEASE/swift-5.3.1-RELEASE-ubuntu16.04.tar.gz
+  curl -fSsL "$SWIFT_URL" -o swift.tar.gz
+
+  mkdir ~/swiftbuild
+  tar -xvzf swift.tar.gz -C ~/swiftbuild
+
+  export PATH="~/swiftbuild/swift-5.3.1-RELEASE-ubuntu16.04/usr/bin:$PATH"
+
+
+  mkdir ~/gobuild
+  wget -c https://golang.org/dl/go1.15.2.linux-amd64.tar.gz
+  tar -xvzf go1.15.2.linux-amd64.tar.gz -C ~/gobuild
+
+  export  PATH="~/gobuild/go/bin:$PATH"
+
+  swift --version
+  go version
+  yarn -v
+  node -v
+}
+
+install_formatters() {
+  # installing swift formatter
+  git clone --depth 1 --branch 0.47.4 https://github.com/nicklockwood/SwiftFormat.git
+  cd SwiftFormat
+  swift build -c release
+  sudo cp .build/release/swiftformat /usr/local/bin/swiftformat
+  cd ..
+
+  which yarn
+  which node
+  yarn -v
+  node -v
+
+  yarn install
+  pip install pylint
+}
+
+install_languages
+export PATH="~/swift/swift/usr/bin:$PATH"
+install_formatters

BUILD.bazel

@@ -1,7 +1,7 @@
-licenses(["notice"])
-
 load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library")
 
+licenses(["notice"])
+
 package(
     default_visibility = ["//visibility:public"],
 )
@@ -10,6 +10,20 @@ exports_files([
     "LICENSE",
 ])
 
+config_setting(
+    name = "platform_freebsd",
+    constraint_values = [
+        "@platforms//os:freebsd",
+    ],
+)
+
+config_setting(
+    name = "platform_openbsd",
+    constraint_values = [
+        "@platforms//os:openbsd",
+    ],
+)
+
 # Public flatc library to compile flatbuffer files at runtime.
 cc_library(
     name = "flatbuffers",
@@ -23,10 +37,19 @@ cc_library(
 filegroup(
     name = "public_headers",
     srcs = [
+        "include/flatbuffers/allocator.h",
+        "include/flatbuffers/array.h",
         "include/flatbuffers/base.h",
+        "include/flatbuffers/bfbs_generator.h",
+        "include/flatbuffers/buffer.h",
+        "include/flatbuffers/buffer_ref.h",
         "include/flatbuffers/code_generators.h",
+        "include/flatbuffers/default_allocator.h",
+        "include/flatbuffers/detached_buffer.h",
+        "include/flatbuffers/flatbuffer_builder.h",
         "include/flatbuffers/flatbuffers.h",
         "include/flatbuffers/flexbuffers.h",
+        "include/flatbuffers/grpc.h",
         "include/flatbuffers/hash.h",
         "include/flatbuffers/idl.h",
         "include/flatbuffers/minireflect.h",
@@ -34,7 +57,13 @@ filegroup(
         "include/flatbuffers/reflection_generated.h",
         "include/flatbuffers/registry.h",
         "include/flatbuffers/stl_emulation.h",
+        "include/flatbuffers/string.h",
+        "include/flatbuffers/struct.h",
+        "include/flatbuffers/table.h",
         "include/flatbuffers/util.h",
+        "include/flatbuffers/vector.h",
+        "include/flatbuffers/vector_downward.h",
+        "include/flatbuffers/verifier.h",
     ],
 )
 
@@ -72,6 +101,8 @@ cc_library(
         "include/flatbuffers/flexbuffers.h",
         "include/flatbuffers/stl_emulation.h",
         "include/flatbuffers/util.h",
+        "include/flatbuffers/vector.h",
+        "include/flatbuffers/verifier.h",
     ],
     linkstatic = 1,
     strip_include_prefix = "/include",

CMake/BuildFlatBuffers.cmake

@@ -95,7 +95,7 @@ function(build_flatbuffers flatbuffers_schemas
       set(generated_include ${generated_includes_dir}/${filename}_generated.h)
       add_custom_command(
         OUTPUT ${generated_include}
-        COMMAND ${FLATC} ${FLATC_SCHEMA_ARGS}
+        COMMAND ${FLATC} ${FLATC_ARGS}
         -o ${generated_includes_dir}
         ${include_params}
         -c ${schema}
@@ -150,3 +150,254 @@ function(build_flatbuffers flatbuffers_schemas
       ${copy_text_schemas_dir})
   endif()
 endfunction()
+
+# Creates a target that can be linked against that generates flatbuffer headers.
+#
+# This function takes a target name and a list of schemas. You can also specify
+# other flagc flags using the FLAGS option to change the behavior of the flatc
+# tool.
+#
+# Arguments:
+#   TARGET: The name of the target to generate.
+#   SCHEMAS: The list of schema files to generate code for.
+#   BINARY_SCHEMAS_DIR: Optional. The directory in which to generate binary
+#       schemas. Binary schemas will only be generated if a path is provided.
+#   INCLUDE: Optional. Search for includes in the specified paths. (Use this
+#       instead of "-I <path>" and the FLAGS option so that CMake is aware of
+#       the directories that need to be searched).
+#   INCLUDE_PREFIX: Optional. The directory in which to place the generated
+#       files. Use this instead of the --include-prefix option.
+#   FLAGS: Optional. A list of any additional flags that you would like to pass
+#       to flatc.
+#
+# Example:
+#
+#     flatbuffers_generate_headers(
+#         TARGET my_generated_headers_target
+#         INCLUDE_PREFIX ${MY_INCLUDE_PREFIX}"
+#         SCHEMAS ${MY_SCHEMA_FILES}
+#         BINARY_SCHEMAS_DIR "${MY_BINARY_SCHEMA_DIRECTORY}"
+#         FLAGS --gen-object-api)
+#
+#     target_link_libraries(MyExecutableTarget
+#         PRIVATE my_generated_headers_target
+#     )
+function(flatbuffers_generate_headers)
+  # Parse function arguments.
+  set(options)
+  set(one_value_args
+    "TARGET"
+    "INCLUDE_PREFIX"
+    "BINARY_SCHEMAS_DIR")
+  set(multi_value_args
+    "SCHEMAS"
+    "INCLUDE"
+    "FLAGS")
+  cmake_parse_arguments(
+    PARSE_ARGV 0
+    FLATBUFFERS_GENERATE_HEADERS
+    "${options}"
+    "${one_value_args}"
+    "${multi_value_args}")
+
+  # Test if including from FindFlatBuffers
+  if(FLATBUFFERS_FLATC_EXECUTABLE)
+    set(FLATC_TARGET "")
+    set(FLATC ${FLATBUFFERS_FLATC_EXECUTABLE})
+  else()
+    set(FLATC_TARGET flatc)
+    set(FLATC flatc)
+  endif()
+
+  set(working_dir "${CMAKE_CURRENT_SOURCE_DIR}")
+
+  # Generate the include files parameters.
+  set(include_params "")
+  foreach (include_dir ${FLATBUFFERS_GENERATE_HEADERS_INCLUDE})
+    set(include_params -I ${include_dir} ${include_params})
+  endforeach()
+
+  # Create a directory to place the generated code.
+  set(generated_target_dir "${CMAKE_CURRENT_BINARY_DIR}/${FLATBUFFERS_GENERATE_HEADERS_TARGET}")
+  set(generated_include_dir "${generated_target_dir}")
+  if (NOT ${FLATBUFFERS_GENERATE_HEADERS_INCLUDE_PREFIX} STREQUAL "")
+    set(generated_include_dir "${generated_include_dir}/${FLATBUFFERS_GENERATE_HEADERS_INCLUDE_PREFIX}")
+    list(APPEND FLATBUFFERS_GENERATE_HEADERS_FLAGS 
+         "--include-prefix" ${FLATBUFFERS_GENERATE_HEADERS_INCLUDE_PREFIX})
+  endif()
+
+  # Create rules to generate the code for each schema.
+  foreach(schema ${FLATBUFFERS_GENERATE_HEADERS_SCHEMAS})
+    get_filename_component(filename ${schema} NAME_WE)
+    set(generated_include "${generated_include_dir}/${filename}_generated.h")
+    add_custom_command(
+      OUTPUT ${generated_include}
+      COMMAND ${FLATC} ${FLATC_ARGS}
+      -o ${generated_include_dir}
+      ${include_params}
+      -c ${schema}
+      ${FLATBUFFERS_GENERATE_HEADERS_FLAGS}
+      DEPENDS ${FLATC_TARGET} ${schema}
+      WORKING_DIRECTORY "${working_dir}")
+    list(APPEND all_generated_header_files ${generated_include})
+
+    # Geneate the binary flatbuffers schemas if instructed to.
+    if (NOT ${FLATBUFFERS_GENERATE_HEADERS_BINARY_SCHEMAS_DIR} STREQUAL "")
+      set(binary_schema
+          "${FLATBUFFERS_GENERATE_HEADERS_BINARY_SCHEMAS_DIR}/${filename}.bfbs")
+      add_custom_command(
+        OUTPUT ${binary_schema}
+        COMMAND ${FLATC} -b --schema
+        -o ${FLATBUFFERS_GENERATE_HEADERS_BINARY_SCHEMAS_DIR}
+        ${include_params}
+        ${schema}
+        DEPENDS ${FLATC_TARGET} ${schema}
+        WORKING_DIRECTORY "${working_dir}")
+      list(APPEND all_generated_binary_files ${binary_schema})
+    endif()
+  endforeach()
+
+  # Set up interface library
+  add_library(${FLATBUFFERS_GENERATE_HEADERS_TARGET} INTERFACE)
+  target_sources(
+    ${FLATBUFFERS_GENERATE_HEADERS_TARGET}
+    INTERFACE
+      ${all_generated_header_files}
+      ${all_generated_binary_files}
+      ${FLATBUFFERS_GENERATE_HEADERS_SCHEMAS})
+  add_dependencies(
+    ${FLATBUFFERS_GENERATE_HEADERS_TARGET}
+    ${FLATC}
+    ${FLATBUFFERS_GENERATE_HEADERS_SCHEMAS})
+  target_include_directories(
+    ${FLATBUFFERS_GENERATE_HEADERS_TARGET}
+    INTERFACE ${generated_target_dir})
+
+  # Organize file layout for IDEs.
+  source_group(
+    TREE "${generated_target_dir}"
+    PREFIX "Flatbuffers/Generated/Headers Files"
+    FILES ${all_generated_header_files})
+  source_group(
+    TREE ${working_dir}
+    PREFIX "Flatbuffers/Schemas"
+    FILES ${FLATBUFFERS_GENERATE_HEADERS_SCHEMAS})
+  if (NOT ${FLATBUFFERS_GENERATE_HEADERS_BINARY_SCHEMAS_DIR} STREQUAL "")
+    source_group(
+      TREE "${FLATBUFFERS_GENERATE_HEADERS_BINARY_SCHEMAS_DIR}"
+      PREFIX "Flatbuffers/Generated/Binary Schemas"
+      FILES ${all_generated_binary_files})
+  endif()
+endfunction()
+
+# Creates a target that can be linked against that generates flatbuffer binaries
+# from json files.
+#
+# This function takes a target name and a list of schemas and Json files. You
+# can also specify other flagc flags and options to change the behavior of the
+# flatc compiler.
+#
+# Adding this target to your executable ensurses that the flatbuffer binaries
+# are compiled before your executable is run.
+#
+# Arguments:
+#   TARGET: The name of the target to generate.
+#   JSON_FILES: The list of json files to compile to flatbuffers binaries.
+#   SCHEMA: The flatbuffers schema of the Json files to be compiled.
+#   INCLUDE: Optional. Search for includes in the specified paths. (Use this 
+#       instead of "-I <path>" and the FLAGS option so that CMake is aware of 
+#       the directories that need to be searched).
+#   OUTPUT_DIR: The directly where the generated flatbuffers binaries should be
+#       placed.
+#   FLAGS: Optional. A list of any additional flags that you would like to pass
+#       to flatc.
+#
+# Example:
+#
+#     flatbuffers_generate_binary_files(
+#         TARGET my_binary_data
+#         SCHEMA "${MY_SCHEMA_DIR}/my_example_schema.fbs"
+#         JSON_FILES ${MY_JSON_FILES}
+#         OUTPUT_DIR "${MY_BINARY_DATA_DIRECTORY}"
+#         FLAGS --strict-json)
+#
+#     target_link_libraries(MyExecutableTarget
+#         PRIVATE my_binary_data
+#     )
+function(flatbuffers_generate_binary_files)
+  # Parse function arguments.
+  set(options)
+  set(one_value_args
+    "TARGET"
+    "SCHEMA"
+    "OUTPUT_DIR")
+  set(multi_value_args
+    "JSON_FILES"
+    "INCLUDE"
+    "FLAGS")
+  cmake_parse_arguments(
+    PARSE_ARGV 0
+    FLATBUFFERS_GENERATE_BINARY_FILES
+    "${options}"
+    "${one_value_args}"
+    "${multi_value_args}")
+
+  # Test if including from FindFlatBuffers
+  if(FLATBUFFERS_FLATC_EXECUTABLE)
+    set(FLATC_TARGET "")
+    set(FLATC ${FLATBUFFERS_FLATC_EXECUTABLE})
+  else()
+    set(FLATC_TARGET flatc)
+    set(FLATC flatc)
+  endif()
+
+  set(working_dir "${CMAKE_CURRENT_SOURCE_DIR}")
+
+  # Generate the include files parameters.
+  set(include_params "")
+  foreach (include_dir ${FLATBUFFERS_GENERATE_BINARY_FILES_INCLUDE})
+    set(include_params -I ${include_dir} ${include_params})
+  endforeach()
+
+  # Create rules to generate the flatbuffers binary for each json file.
+  foreach(json_file ${FLATBUFFERS_GENERATE_BINARY_FILES_JSON_FILES})
+    get_filename_component(filename ${json_file} NAME_WE)
+    set(generated_binary_file "${FLATBUFFERS_GENERATE_BINARY_FILES_OUTPUT_DIR}/${filename}.bin")
+    add_custom_command(
+      OUTPUT ${generated_binary_file}
+      COMMAND ${FLATC} ${FLATC_ARGS}
+      -o ${FLATBUFFERS_GENERATE_BINARY_FILES_OUTPUT_DIR}
+      ${include_params}
+      -b ${FLATBUFFERS_GENERATE_BINARY_FILES_SCHEMA} ${json_file}
+      ${FLATBUFFERS_GENERATE_BINARY_FILES_FLAGS}
+      DEPENDS ${FLATC_TARGET} ${json_file}
+      WORKING_DIRECTORY "${working_dir}")
+      list(APPEND all_generated_binary_files ${generated_binary_file})
+  endforeach()
+
+  # Set up interface library
+  add_library(${FLATBUFFERS_GENERATE_BINARY_FILES_TARGET} INTERFACE)
+  target_sources(
+    ${FLATBUFFERS_GENERATE_BINARY_FILES_TARGET}
+    INTERFACE
+      ${all_generated_binary_files}
+      ${FLATBUFFERS_GENERATE_BINARY_FILES_JSON_FILES}
+      ${FLATBUFFERS_GENERATE_BINARY_FILES_SCHEMA})
+  add_dependencies(
+    ${FLATBUFFERS_GENERATE_BINARY_FILES_TARGET}
+    ${FLATC})
+
+  # Organize file layout for IDEs.
+  source_group(
+    TREE ${working_dir}
+    PREFIX "Flatbuffers/JSON Files"
+    FILES ${FLATBUFFERS_GENERATE_BINARY_FILES_JSON_FILES})
+  source_group(
+    TREE ${working_dir}
+    PREFIX "Flatbuffers/Schemas"
+    FILES ${FLATBUFFERS_GENERATE_BINARY_FILES_SCHEMA})
+  source_group(
+    TREE ${FLATBUFFERS_GENERATE_BINARY_FILES_OUTPUT_DIR}
+    PREFIX "Flatbuffers/Generated/Binary Files"
+    FILES ${all_generated_binary_files})
+endfunction()

CMake/FindFlatBuffers.cmake

@@ -30,7 +30,7 @@ find_program(FLATBUFFERS_FLATC_EXECUTABLE NAMES flatc)
 find_path(FLATBUFFERS_INCLUDE_DIR NAMES flatbuffers/flatbuffers.h)
 
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(flatbuffers
+find_package_handle_standard_args(FlatBuffers
   DEFAULT_MSG FLATBUFFERS_FLATC_EXECUTABLE FLATBUFFERS_INCLUDE_DIR)
 
 if(FLATBUFFERS_FOUND)
@@ -58,4 +58,4 @@ else()
   set(FLATBUFFERS_INCLUDE_DIR)
 endif()
 
-include("${FLATBUFFERS_CMAKE_DIR}/BuildFlatBuffers.cmake")
+include("${FLATBUFFERS_CMAKE_DIR}/BuildFlatBuffers.cmake")

CMake/PackageRedhat.cmake

@@ -31,4 +31,14 @@ if (UNIX)
     set(CPACK_RPM_PACKAGE_NAME "flatbuffers")
     set(CPACK_PACKAGE_FILE_NAME
         "${CPACK_RPM_PACKAGE_NAME}_${CPACK_RPM_PACKAGE_VERSION}_${CPACK_RPM_PACKAGE_ARCHITECTURE}")
+    if(NOT DEFINED ${CPACK_PACKAGING_INSTALL_PREFIX})
+       # Default packaging install prefix on RedHat systems is /usr.
+       # This is the assumed value when this variable is not defined.
+       # There is currently a conflict with
+       # /usr/${CMAKE_INSTALL_LIBDIR}/cmake which is installed by default
+       # by other packages on RedHat (most notably cmake-filesystem). Ensure
+       # that on these systems, flatbuffers does not package this path.
+       # This patch is required for cmake pre-3.17.
+       list(APPEND CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION "/usr/${CMAKE_INSTALL_LIBDIR}/cmake")
+   endif()
 endif(UNIX)

CMake/Version.cmake

@@ -1,11 +1,28 @@
+set(VERSION_MAJOR 2)
+set(VERSION_MINOR 0)
+set(VERSION_PATCH 5)
+set(VERSION_COMMIT 0)
+
 find_program(GIT git)
-execute_process(
-    COMMAND ${GIT} describe
-    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    OUTPUT_VARIABLE GIT_DESCRIBE_DIRTY
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-)
-string(REGEX REPLACE "^v([0-9]+)\\..*" "\\1" VERSION_MAJOR "${GIT_DESCRIBE_DIRTY}")
-string(REGEX REPLACE "^v[0-9]+\\.([0-9]+).*" "\\1" VERSION_MINOR "${GIT_DESCRIBE_DIRTY}")
-string(REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" VERSION_PATCH "${GIT_DESCRIBE_DIRTY}")
-string(REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.[0-9]+\\-([0-9]+).*" "\\1" VERSION_COMMIT "${GIT_DESCRIBE_DIRTY}")
+if(GIT)
+  execute_process(
+      COMMAND ${GIT} describe --tags
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+      OUTPUT_VARIABLE GIT_DESCRIBE_DIRTY
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      RESULT_VARIABLE GIT_DESCRIBE_RESULT
+  )
+
+  if(GIT_DESCRIBE_RESULT EQUAL 0)
+    string(REGEX REPLACE "^v([0-9]+)\\..*" "\\1" VERSION_MAJOR "${GIT_DESCRIBE_DIRTY}")
+    string(REGEX REPLACE "^v[0-9]+\\.([0-9]+).*" "\\1" VERSION_MINOR "${GIT_DESCRIBE_DIRTY}")
+    string(REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" VERSION_PATCH "${GIT_DESCRIBE_DIRTY}")
+    string(REGEX REPLACE "^v[0-9]+\\.[0-9]+\\.[0-9]+\\-([0-9]+).*" "\\1" VERSION_COMMIT "${GIT_DESCRIBE_DIRTY}")
+  else()
+    message(WARNING "git describe failed with exit code: ${GIT_DESCRIBE_RESULT}")
+  endif()
+else()
+  message(WARNING "git is not found")
+endif()
+
+message(STATUS "Proceeding with version: ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}.${VERSION_COMMIT}")

CMake/flatbuffers.pc.in

@@ -0,0 +1,9 @@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+
+Name: FlatBuffers
+Description: Memory Efficient Serialization Library
+Version: @VERSION_MAJOR@.@VERSION_MINOR@.@VERSION_PATCH@
+
+Libs: -L${libdir} -lflatbuffers
+Cflags: -I${includedir}

CMakeLists.txt

@@ -1,9 +1,19 @@
 cmake_minimum_required(VERSION 2.8.12)
+
+if (POLICY CMP0048)
+  cmake_policy(SET CMP0048 NEW)
+  project(FlatBuffers
+        DESCRIPTION "Flatbuffers serialization library"
+        VERSION 2.0.0
+        LANGUAGES CXX)
+else()
+  project(FlatBuffers)
+endif (POLICY CMP0048)
+
+include(CMake/Version.cmake)
+
 # generate compile_commands.json
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-include(CheckCXXSymbolExists)
-
-project(FlatBuffers)
 
 # NOTE: Code coverage only works on Linux & OSX.
 option(FLATBUFFERS_CODE_COVERAGE "Enable the code coverage build option." OFF)
@@ -16,6 +26,9 @@ option(FLATBUFFERS_BUILD_FLATC "Enable the build of the flatbuffers compiler"
 option(FLATBUFFERS_STATIC_FLATC "Build flatbuffers compiler with -static flag"
        OFF)
 option(FLATBUFFERS_BUILD_FLATHASH "Enable the build of flathash" ON)
+option(FLATBUFFERS_BUILD_BENCHMARKS "Enable the build of flatbenchmark. \"
+       Requires C++11."
+       OFF)
 option(FLATBUFFERS_BUILD_GRPCTEST "Enable the build of grpctest" OFF)
 option(FLATBUFFERS_BUILD_SHAREDLIB
        "Enable the build of the flatbuffers shared library"
@@ -38,6 +51,14 @@ option(FLATBUFFERS_BUILD_CPP17
 option(FLATBUFFERS_BUILD_LEGACY
        "Run C++ code generator with '--cpp-std c++0x' switch."
        OFF)
+option(FLATBUFFERS_ENABLE_PCH
+       "Enable precompile headers support for 'flatbuffers' and 'flatc'. \"
+        Only work if CMake supports 'target_precompile_headers'. \"
+        This can speed up compilation time."
+       OFF)
+option(FLATBUFFERS_SKIP_MONSTER_EXTRA 
+      "Skip generating monster_extra.fbs that contains non-supported numerical\"
+      types." OFF)
 
 if(NOT FLATBUFFERS_BUILD_FLATC AND FLATBUFFERS_BUILD_TESTS)
     message(WARNING
@@ -53,6 +74,8 @@ endif()
 
 # Auto-detect locale-narrow 'strtod_l' and  'strtoull_l' functions.
 if(NOT DEFINED FLATBUFFERS_LOCALE_INDEPENDENT)
+  include(CheckCXXSymbolExists)
+
   set(FLATBUFFERS_LOCALE_INDEPENDENT 0)
   if(MSVC)
     check_cxx_symbol_exists(_strtof_l stdlib.h FLATBUFFERS_HAS_STRTOF_L)
@@ -68,17 +91,31 @@ endif()
 add_definitions(-DFLATBUFFERS_LOCALE_INDEPENDENT=$<BOOL:${FLATBUFFERS_LOCALE_INDEPENDENT}>)
 
 set(FlatBuffers_Library_SRCS
+  include/flatbuffers/allocator.h
+  include/flatbuffers/array.h
   include/flatbuffers/base.h
+  include/flatbuffers/bfbs_generator.h
+  include/flatbuffers/buffer.h
+  include/flatbuffers/buffer_ref.h
+  include/flatbuffers/default_allocator.h
+  include/flatbuffers/detached_buffer.h
+  include/flatbuffers/flatbuffer_builder.h
   include/flatbuffers/flatbuffers.h
+  include/flatbuffers/flexbuffers.h
   include/flatbuffers/hash.h
   include/flatbuffers/idl.h
-  include/flatbuffers/util.h
+  include/flatbuffers/minireflect.h
   include/flatbuffers/reflection.h
   include/flatbuffers/reflection_generated.h
-  include/flatbuffers/stl_emulation.h
-  include/flatbuffers/flexbuffers.h
   include/flatbuffers/registry.h
-  include/flatbuffers/minireflect.h
+  include/flatbuffers/stl_emulation.h
+  include/flatbuffers/string.h
+  include/flatbuffers/struct.h
+  include/flatbuffers/table.h
+  include/flatbuffers/util.h
+  include/flatbuffers/vector.h
+  include/flatbuffers/vector_downward.h
+  include/flatbuffers/verifier.h
   src/idl_parser.cpp
   src/idl_gen_text.cpp
   src/reflection.cpp
@@ -93,7 +130,7 @@ set(FlatBuffers_Compiler_SRCS
   src/idl_gen_kotlin.cpp
   src/idl_gen_go.cpp
   src/idl_gen_java.cpp
-  src/idl_gen_js_ts.cpp
+  src/idl_gen_ts.cpp
   src/idl_gen_php.cpp
   src/idl_gen_python.cpp
   src/idl_gen_lobster.cpp
@@ -105,7 +142,10 @@ set(FlatBuffers_Compiler_SRCS
   src/idl_gen_swift.cpp
   src/flatc.cpp
   src/flatc_main.cpp
+  src/bfbs_gen.h
+  src/bfbs_gen_lua.h
   include/flatbuffers/code_generators.h
+  src/bfbs_gen_lua.cpp
   src/code_generators.cpp
   grpc/src/compiler/schema_interface.h
   grpc/src/compiler/cpp_generator.h
@@ -115,10 +155,11 @@ set(FlatBuffers_Compiler_SRCS
   grpc/src/compiler/java_generator.h
   grpc/src/compiler/java_generator.cc
   grpc/src/compiler/python_generator.h
-  grpc/src/compiler/python_private_generator.h
   grpc/src/compiler/python_generator.cc
   grpc/src/compiler/swift_generator.h
   grpc/src/compiler/swift_generator.cc
+  grpc/src/compiler/ts_generator.h
+  grpc/src/compiler/ts_generator.cc
 )
 
 set(FlatHash_SRCS
@@ -153,6 +194,8 @@ set(FlatBuffers_Tests_SRCS
   ${CMAKE_CURRENT_BINARY_DIR}/tests/monster_extra_generated.h
   # file generate by running compiler on tests/monster_test.fbs
   ${CMAKE_CURRENT_BINARY_DIR}/tests/monster_test_bfbs_generated.h
+  # file generate by running compiler on tests/optional_scalars.fbs
+  ${CMAKE_CURRENT_BINARY_DIR}/tests/optional_scalars_generated.h
 )
 
 set(FlatBuffers_Tests_CPP17_SRCS
@@ -163,6 +206,8 @@ set(FlatBuffers_Tests_CPP17_SRCS
   # file generate by running compiler on tests/monster_test.fbs
   ${CMAKE_CURRENT_BINARY_DIR}/tests/cpp17/generated_cpp17/monster_test_generated.h
   ${CMAKE_CURRENT_BINARY_DIR}/tests/monster_test_generated.h
+  ${CMAKE_CURRENT_BINARY_DIR}/tests/cpp17/generated_cpp17/optional_scalars_generated.h
+  ${CMAKE_CURRENT_BINARY_DIR}/tests/optional_scalars_generated.h
 )
 
 set(FlatBuffers_Sample_Binary_SRCS
@@ -210,10 +255,6 @@ if(EXISTS "${CMAKE_TOOLCHAIN_FILE}")
   # do not apply any global settings if the toolchain
   # is being configured externally
   message(STATUS "Using toolchain file: ${CMAKE_TOOLCHAIN_FILE}.")
-elseif(APPLE)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -stdlib=libc++")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -pedantic -Werror -Wextra -Wno-unused-parameter")
-  set(FLATBUFFERS_PRIVATE_CXX_FLAGS "-Wold-style-cast")
 elseif(CMAKE_COMPILER_IS_GNUCXX)
   if(CYGWIN)
     set(CMAKE_CXX_FLAGS
@@ -240,8 +281,14 @@ elseif(CMAKE_COMPILER_IS_GNUCXX)
     "${CMAKE_CXX_FLAGS} -fsigned-char")
 
 elseif(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
-  set(CMAKE_CXX_FLAGS
-      "${CMAKE_CXX_FLAGS} -std=c++0x -Wall -pedantic -Werror -Wextra -Wno-unused-parameter")
+  if(APPLE)
+    set(CMAKE_OSX_ARCHITECTURES "arm64;x86_64")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+  else()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
+  endif()
+
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -pedantic -Werror -Wextra -Wno-unused-parameter")
   set(FLATBUFFERS_PRIVATE_CXX_FLAGS "-Wold-style-cast")
   if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.8)
     list(APPEND FLATBUFFERS_PRIVATE_CXX_FLAGS "-Wimplicit-fallthrough" "-Wextra-semi" "-Werror=unused-private-field") # enable warning
@@ -268,8 +315,18 @@ elseif(MSVC)
   # warning C4512: assignment operator could not be generated
   # warning C4316: object allocated on the heap may not be aligned
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /WX /wd4512 /wd4316")
+
+  # multi-core build.
+  add_definitions("/MP")
 endif()
 
+# Append FLATBUFFERS_CXX_FLAGS to CMAKE_CXX_FLAGS.
+if(DEFINED FLATBUFFERS_CXX_FLAGS AND NOT EXISTS "${CMAKE_TOOLCHAIN_FILE}")
+  message(STATUS "extend CXX_FLAGS with ${FLATBUFFERS_CXX_FLAGS}")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLATBUFFERS_CXX_FLAGS}")
+endif()
+message(STATUS "CMAKE_CXX_FLAGS: ${CMAKE_CXX_FLAGS}")
+
 if(FLATBUFFERS_CODE_COVERAGE)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -fprofile-arcs -ftest-coverage")
   set(CMAKE_EXE_LINKER_FLAGS
@@ -302,6 +359,15 @@ function(add_fsanitize_to_target _target _sanitizer)
   endif()
 endfunction()
 
+function(add_pch_to_target _target _pch_header)
+  if(COMMAND target_precompile_headers)
+    target_precompile_headers(${_target} PRIVATE ${_pch_header})
+    if(NOT MSVC)
+      set_source_files_properties(src/util.cpp PROPERTIES SKIP_PRECOMPILE_HEADERS ON)
+    endif()
+  endif()
+endfunction()
+
 if(BIICODE)
   include(biicode/cmake/biicode.cmake)
   return()
@@ -316,10 +382,16 @@ if(FLATBUFFERS_BUILD_FLATLIB)
   target_include_directories(flatbuffers INTERFACE
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
   target_compile_options(flatbuffers PRIVATE "${FLATBUFFERS_PRIVATE_CXX_FLAGS}")
+  if(FLATBUFFERS_ENABLE_PCH)
+    add_pch_to_target(flatbuffers include/flatbuffers/pch/pch.h)
+  endif()
 endif()
 
 if(FLATBUFFERS_BUILD_FLATC)
   add_executable(flatc ${FlatBuffers_Compiler_SRCS})
+  if(FLATBUFFERS_ENABLE_PCH)
+    add_pch_to_target(flatc include/flatbuffers/pch/flatc_pch.h)
+  endif()
   target_compile_options(flatc PRIVATE "${FLATBUFFERS_PRIVATE_CXX_FLAGS}")
   if(FLATBUFFERS_CODE_SANITIZE AND NOT WIN32)
     add_fsanitize_to_target(flatc ${FLATBUFFERS_CODE_SANITIZE})
@@ -347,11 +419,14 @@ if(FLATBUFFERS_BUILD_SHAREDLIB)
   # - micro updated every release when there is no API/ABI changes
   # - minor updated when there are additions in API/ABI
   # - major (ABI number) updated when there are changes in ABI (or removals)
-  set(FlatBuffers_Library_SONAME_MAJOR "1")
-  set(FlatBuffers_Library_SONAME_FULL "${FlatBuffers_Library_SONAME_MAJOR}.12.0")
+  set(FlatBuffers_Library_SONAME_MAJOR ${VERSION_MAJOR})
+  set(FlatBuffers_Library_SONAME_FULL "${FlatBuffers_Library_SONAME_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}")
   set_target_properties(flatbuffers_shared PROPERTIES OUTPUT_NAME flatbuffers
                         SOVERSION "${FlatBuffers_Library_SONAME_MAJOR}"
                         VERSION "${FlatBuffers_Library_SONAME_FULL}")
+  if(FLATBUFFERS_ENABLE_PCH)
+    add_pch_to_target(flatbuffers_shared include/flatbuffers/pch/pch.h)
+  endif()
 endif()
 
 # Global list of generated files.
@@ -400,11 +475,12 @@ function(compile_flatbuffers_schema_to_binary SRC_FBS)
   message(STATUS "`${SRC_FBS}`: add generation of binary (.bfbs) schema")
   get_filename_component(SRC_FBS_DIR ${SRC_FBS} PATH)
   string(REGEX REPLACE "\\.fbs$" ".bfbs" GEN_BINARY_SCHEMA ${SRC_FBS})
-  # For details about flags see generate_code.bat(sh)
+  # For details about flags see generate_code.py
   add_custom_command(
     OUTPUT ${GEN_BINARY_SCHEMA}
     COMMAND "${FLATBUFFERS_FLATC_EXECUTABLE}"
             -b --schema --bfbs-comments --bfbs-builtins
+            --bfbs-filenames ${SRC_FBS_DIR}
             -I "${CMAKE_CURRENT_SOURCE_DIR}/tests/include_test"
             -o "${SRC_FBS_DIR}"
             "${CMAKE_CURRENT_SOURCE_DIR}/${SRC_FBS}"
@@ -422,7 +498,7 @@ function(compile_flatbuffers_schema_to_embedded_binary SRC_FBS OPT)
   message(STATUS "`${SRC_FBS}`: add generation of C++ embedded binary schema code with '${OPT}'")
   get_filename_component(SRC_FBS_DIR ${SRC_FBS} PATH)
   string(REGEX REPLACE "\\.fbs$" "_bfbs_generated.h" GEN_BFBS_HEADER ${SRC_FBS})
-  # For details about flags see generate_code.bat(sh)
+  # For details about flags see generate_code.py
   add_custom_command(
           OUTPUT ${GEN_BFBS_HEADER}
           COMMAND "${FLATBUFFERS_FLATC_EXECUTABLE}"
@@ -430,6 +506,7 @@ function(compile_flatbuffers_schema_to_embedded_binary SRC_FBS OPT)
           --cpp-ptr-type flatbuffers::unique_ptr # Used to test with C++98 STLs
           ${OPT}
           --bfbs-comments --bfbs-builtins --bfbs-gen-embed
+          --bfbs-filenames ${SRC_FBS_DIR}
           -I "${CMAKE_CURRENT_SOURCE_DIR}/tests/include_test"
           -o "${SRC_FBS_DIR}"
           "${CMAKE_CURRENT_SOURCE_DIR}/${SRC_FBS}"
@@ -438,6 +515,37 @@ function(compile_flatbuffers_schema_to_embedded_binary SRC_FBS OPT)
   register_generated_output(${GEN_BFBS_HEADER})
 endfunction()
 
+# Look if we have python 3 installed so that we can run the generate code python
+# script after flatc is built.
+find_package(PythonInterp 3)
+
+if(PYTHONINTERP_FOUND AND
+  # Skip doing this if the MSVC version is below VS 12.
+  # https://cmake.org/cmake/help/latest/variable/MSVC_VERSION.html
+  (NOT MSVC OR MSVC_VERSION GREATER 1800))
+  if(WIN32)
+    set(GENERATION_SCRIPT py scripts/generate_code.py) 
+   else()
+    set(GENERATION_SCRIPT scripts/generate_code.py)
+  endif()
+  if(FLATBUFFERS_BUILD_LEGACY)
+    # Need to set --cpp-std c++-0x options
+    set(GENERATION_SCRIPT ${GENERATION_SCRIPT} --cpp-0x)
+  endif()
+  if(FLATBUFFERS_SKIP_MONSTER_EXTRA)
+    set(GENERATION_SCRIPT ${GENERATION_SCRIPT} --skip-monster-extra)
+  endif()
+  add_custom_command(
+    TARGET flatc
+    POST_BUILD
+    COMMAND ${GENERATION_SCRIPT} --flatc "${FLATBUFFERS_FLATC_EXECUTABLE}"
+    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+    COMMENT "Running ${GENERATION_SCRIPT}..."
+    VERBATIM)
+else()
+  message("No Python3 interpreter found! Unable to generate files automatically.")
+endif()
+
 if(FLATBUFFERS_BUILD_TESTS)
   file(COPY "${CMAKE_CURRENT_SOURCE_DIR}/tests" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")
   file(COPY "${CMAKE_CURRENT_SOURCE_DIR}/samples" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")
@@ -445,9 +553,10 @@ if(FLATBUFFERS_BUILD_TESTS)
   # TODO Add (monster_test.fbs monsterdata_test.json)->monsterdata_test.mon
   compile_flatbuffers_schema_to_cpp(tests/monster_test.fbs)
   compile_flatbuffers_schema_to_binary(tests/monster_test.fbs)
-  compile_flatbuffers_schema_to_cpp(tests/namespace_test/namespace_test1.fbs)
-  compile_flatbuffers_schema_to_cpp(tests/namespace_test/namespace_test2.fbs)
-  compile_flatbuffers_schema_to_cpp(tests/union_vector/union_vector.fbs)
+  compile_flatbuffers_schema_to_cpp_opt(tests/namespace_test/namespace_test1.fbs "--no-includes;--gen-compare;--gen-name-strings")
+  compile_flatbuffers_schema_to_cpp_opt(tests/namespace_test/namespace_test2.fbs "--no-includes;--gen-compare;--gen-name-strings")
+  compile_flatbuffers_schema_to_cpp_opt(tests/union_vector/union_vector.fbs "--no-includes;--gen-compare;--gen-name-strings")
+  compile_flatbuffers_schema_to_cpp(tests/optional_scalars.fbs)
   compile_flatbuffers_schema_to_cpp_opt(tests/native_type_test.fbs "")
   compile_flatbuffers_schema_to_cpp_opt(tests/arrays_test.fbs "--scoped-enums;--gen-compare")
   compile_flatbuffers_schema_to_binary(tests/arrays_test.fbs)
@@ -478,7 +587,7 @@ if(FLATBUFFERS_BUILD_TESTS)
   if(FLATBUFFERS_BUILD_CPP17)
     # Don't generate header for flattests_cpp17 target.
     # This target uses "generated_cpp17/monster_test_generated.h"
-    # produced by direct call of generate_code.bat(sh) script.
+    # produced by direct call of generate_code.py script.
     add_executable(flattests_cpp17 ${FlatBuffers_Tests_CPP17_SRCS})
     add_dependencies(flattests_cpp17 generated_code)
     target_compile_features(flattests_cpp17 PRIVATE cxx_std_17)
@@ -504,17 +613,20 @@ if(FLATBUFFERS_BUILD_GRPCTEST)
   endif()
   INCLUDE_DIRECTORIES(${GRPC_INSTALL_PATH}/include)
   INCLUDE_DIRECTORIES(${PROTOBUF_DOWNLOAD_PATH}/src)
-  LINK_DIRECTORIES(${GRPC_INSTALL_PATH}/lib)
+  find_package(Threads REQUIRED)
+  list(APPEND CMAKE_PREFIX_PATH ${GRPC_INSTALL_PATH})
+  find_package(absl CONFIG REQUIRED)
+  find_package(protobuf CONFIG REQUIRED)
+  find_package(gRPC CONFIG REQUIRED)
   add_executable(grpctest ${FlatBuffers_GRPCTest_SRCS})
   add_dependencies(grpctest generated_code)
-  target_link_libraries(grpctest PRIVATE grpc++_unsecure grpc_unsecure gpr pthread dl)
+  target_link_libraries(grpctest PRIVATE gRPC::grpc++_unsecure gRPC::grpc_unsecure gRPC::gpr pthread dl)
   if(FLATBUFFERS_CODE_SANITIZE AND NOT WIN32)
     # GRPC test has problems with alignment and will fail under ASAN/UBSAN.
     # add_fsanitize_to_target(grpctest ${FLATBUFFERS_CODE_SANITIZE})
   endif()
 endif()
 
-include(CMake/Version.cmake)
 
 if(FLATBUFFERS_INSTALL)
   include(GNUInstallDirs)
@@ -589,6 +701,14 @@ if(FLATBUFFERS_INSTALL)
       DESTINATION ${FB_CMAKE_DIR}
     )
   endif()
+
+  if(FLATBUFFERS_BUILD_SHAREDLIB OR FLATBUFFERS_BUILD_FLATLIB)
+      configure_file(CMake/flatbuffers.pc.in flatbuffers.pc @ONLY)
+      install(
+        FILES "${CMAKE_CURRENT_BINARY_DIR}/flatbuffers.pc"
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig
+      )
+  endif()
 endif()
 
 if(FLATBUFFERS_BUILD_TESTS)
@@ -619,9 +739,15 @@ if(UNIX)
     # Use of CPack only supported on Linux systems.
     if(FLATBUFFERS_PACKAGE_DEBIAN)
         include(CMake/PackageDebian.cmake)
+        include(CPack)
     endif()
     if (FLATBUFFERS_PACKAGE_REDHAT)
         include(CMake/PackageRedhat.cmake)
+        include(CPack)
     endif()
-    include(CPack)
 endif()
+
+# Include for running Google Benchmarks.
+if(FLATBUFFERS_BUILD_BENCHMARKS AND CMAKE_VERSION VERSION_GREATER 3.13)
+  add_subdirectory(benchmarks)
+endif()

Formatters.md

@@ -0,0 +1,22 @@
+# Format Guidelines
+
+If you are interesting in contributing to the flatbuffers project, please take a second to read this document. Each language has it's own set of rules, that are defined in their respective formatter/linter documents.
+
+# Notes
+
+- Run the linter on the language you are working on before making a Pull Request.
+- DONT format/lint the generated code.
+
+# Languages
+
+## C++
+
+C++ uses `clang-format` as it's formatter. Run the following script `sh scripts/clang-format-git.sh`, and it should style the C++ code according to [google style guide](https://google.github.io/styleguide/cppguide.html).
+
+## Swift
+
+Swift uses swiftformat as it's formatter. Take a look at [how to install here](https://github.com/nicklockwood/SwiftFormat/blob/master/README.md#how-do-i-install-it). Run the following command `swiftformat --config swift.swiftformat .` in the root directory of the project
+
+## Typescript
+
+Typescript uses eslint as it's linter. Take a look at [how to install here](https://eslint.org/docs/user-guide/getting-started). Run the following command `eslint ts/** --ext .ts` in the root directory of the project

SECURITY.md

@@ -0,0 +1,11 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+To report a security issue, please use http://g.co/vulnz. We use
+http://g.co/vulnz for our intake, and do coordination and disclosure here on
+GitHub (including using GitHub Security Advisory). The Google Security Team will
+respond within 5 working days of your report on g.co/vulnz.
+
+Select the `I want to report a technical security or an abuse risk related bug
+in a Google product (SQLi, XSS, etc.)` option and complete the form.

WORKSPACE

@@ -4,15 +4,43 @@ load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 
 http_archive(
     name = "io_bazel_rules_go",
+    sha256 = "d1ffd055969c8f8d431e2d439813e42326961d0942bdf734d2c95dc30c369566",
     urls = [
-        "https://storage.googleapis.com/bazel-mirror/github.com/bazelbuild/rules_go/releases/download/v0.20.3/rules_go-v0.20.3.tar.gz",
-        "https://github.com/bazelbuild/rules_go/releases/download/v0.20.3/rules_go-v0.20.3.tar.gz",
+        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.24.5/rules_go-v0.24.5.tar.gz",
+        "https://github.com/bazelbuild/rules_go/releases/download/v0.24.5/rules_go-v0.24.5.tar.gz",
     ],
-    sha256 = "e88471aea3a3a4f19ec1310a55ba94772d087e9ce46e41ae38ecebe17935de7b",
 )
 
-load("@io_bazel_rules_go//go:deps.bzl", "go_rules_dependencies", "go_register_toolchains")
+load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_dependencies")
 
 go_rules_dependencies()
 
 go_register_toolchains()
+
+##### Protobuf
+_PROTOBUF_VERSION = "3.15.2"
+
+http_archive(
+    name = "com_google_protobuf",
+    strip_prefix = "protobuf-" + _PROTOBUF_VERSION,
+    urls = [
+        "https://github.com/protocolbuffers/protobuf/archive/v" + _PROTOBUF_VERSION + ".tar.gz",
+    ],
+)
+
+##### GRPC
+_GRPC_VERSION = "1.39.0"
+
+http_archive(
+    name = "com_github_grpc_grpc",
+    strip_prefix = "grpc-" + _GRPC_VERSION,
+    urls = ["https://github.com/grpc/grpc/archive/v" + _GRPC_VERSION + ".tar.gz"],
+)
+
+load("@com_github_grpc_grpc//bazel:grpc_deps.bzl", "grpc_deps")
+
+grpc_deps()
+
+load("@com_github_grpc_grpc//bazel:grpc_extra_deps.bzl", "grpc_extra_deps")
+
+grpc_extra_deps()

android/app/.gitignore

@@ -0,0 +1 @@
+/build

android/app/build.gradle

@@ -0,0 +1,134 @@
+apply plugin: 'com.android.application'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-android-extensions'
+
+android {
+  compileSdkVersion 30
+  buildToolsVersion "30.0.2"
+
+  defaultConfig {
+    applicationId "com.flatbuffers.app"
+    minSdkVersion 16
+    targetSdkVersion 30
+    versionCode 1
+    versionName "1.0"
+
+    compileOptions {
+      sourceCompatibility JavaVersion.VERSION_1_8
+      targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    externalNativeBuild {
+      cmake {
+        arguments "-DFLATBUFFERS_SRC=${rootProject.projectDir}/.."
+      }
+    }
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+      proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+    }
+  }
+
+  ndkVersion "21.3.6528147"
+  externalNativeBuild {
+    cmake {
+      path "src/main/cpp/CMakeLists.txt"
+    }
+  }
+
+  task generateFbsCpp(type: Exec) {
+    def inputDir = file("$projectDir/src/main/fbs")
+    def outputCppDir = file("$projectDir/src/main/cpp/generated/")
+    def fbsFiles = layout.files { file(inputDir).listFiles() }.filter { File f -> f.name.endsWith(".fbs") }.toList()
+    ignoreExitValue(true)
+
+    standardOutput = new ByteArrayOutputStream()
+    errorOutput = new ByteArrayOutputStream()
+    def commandLineArgs = ['flatc', '-o', outputCppDir, '--cpp']
+    fbsFiles.forEach{
+      commandLineArgs.add(it.path)
+    }
+    commandLine commandLineArgs
+
+    doFirst {
+      delete "$outputCppDir/"
+      mkdir "$outputCppDir/"
+    }
+    doLast {
+      if (execResult.getExitValue() != 0) {
+        println(standardOutput.toString())
+        throw new GradleException("flatc command line failed")
+      }
+    }
+  }
+
+  task generateFbsKotlin(type: Exec) {
+    def inputDir = file("$projectDir/src/main/fbs")
+    def outputKotlinDir = file("$projectDir/src/main/java/generated/")
+    def fbsFiles = layout.files { file(inputDir).listFiles() }.filter { File f -> f.name.endsWith(".fbs") }.toList()
+    ignoreExitValue(true)
+
+    standardOutput = new ByteArrayOutputStream()
+    errorOutput = new ByteArrayOutputStream()
+    def commandLineArgs = ['flatc', '-o', outputKotlinDir, '--kotlin']
+    fbsFiles.forEach{
+      commandLineArgs.add(it.path)
+    }
+    commandLine commandLineArgs
+
+    doFirst {
+      delete "$outputKotlinDir/"
+      mkdir "$outputKotlinDir/"
+    }
+    doLast {
+      if (execResult.getExitValue() != 0) {
+        println(standardOutput.toString())
+        throw new GradleException("flatc command line failed")
+      }
+    }
+  }
+
+  afterEvaluate {
+    android.applicationVariants.all { variant ->
+      variant.javaCompiler.dependsOn(generateFbsKotlin)
+      variant.javaCompiler.dependsOn(generateFbsCpp)
+    }
+  }
+
+  flavorDimensions "stl-variant"
+  productFlavors {
+    gnustl {
+      dimension "stl-variant"
+      applicationIdSuffix ".gnustl"
+      versionNameSuffix "-gnustl"
+      externalNativeBuild {
+        ndkBuild {
+          arguments "APP_STL=gnustl_static"
+        }
+      }
+    }
+    libcpp {
+      dimension "stl-variant"
+      applicationIdSuffix ".libcpp"
+      versionNameSuffix "-libcpp"
+      externalNativeBuild {
+        ndkBuild {
+          arguments "APP_STL=c++_static"
+        }
+      }
+    }
+  }
+}
+
+dependencies {
+  implementation fileTree(dir: "libs", include: ["*.jar"])
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation 'androidx.core:core-ktx:1.3.2'
+  implementation 'androidx.appcompat:appcompat:1.2.0'
+  implementation 'com.google.flatbuffers:flatbuffers-java:2.0.0'
+
+}

android/app/proguard-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

android/app/src/main/AndroidManifest.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  package="com.flatbuffers.app">
+
+  <application
+    android:allowBackup="true"
+    android:icon="@mipmap/ic_launcher"
+    android:label="@string/app_name"
+    android:roundIcon="@mipmap/ic_launcher_round"
+    android:supportsRtl="true"
+    android:theme="@style/AppTheme">
+    <activity android:name=".MainActivity">
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN" />
+
+        <category android:name="android.intent.category.LAUNCHER" />
+      </intent-filter>
+    </activity>
+  </application>
+
+</manifest>

android/app/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,54 @@
+# For more information about using CMake with Android Studio, read the
+# documentation: https://d.android.com/studio/projects/add-native-code.html
+
+# Sets the minimum version of CMake required to build the native library.
+
+cmake_minimum_required(VERSION 3.4.1)
+
+# Creates and names a library, sets it as either STATIC
+# or SHARED, and provides the relative paths to its source code.
+# You can define multiple libraries, and CMake builds them for you.
+# Gradle automatically packages shared libraries with your APK.
+
+include_directories(${FLATBUFFERS_SRC}/include)
+
+add_subdirectory(flatbuffers)
+
+FILE(GLOB Generated_SRCS generated/*.h)
+
+add_library( # Sets the name of the library.
+             native-lib
+
+             # Sets the library as a shared library.
+             SHARED
+
+             # Provides a relative path to your source file(s).
+             animals.cpp
+             ${Generated_SRCS}
+
+)
+
+# Searches for a specified prebuilt library and stores the path as a
+# variable. Because CMake includes system libraries in the search path by
+# default, you only need to specify the name of the public NDK library
+# you want to add. CMake verifies that the library exists before
+# completing its build.
+
+find_library( # Sets the name of the path variable.
+              log-lib
+
+              # Specifies the name of the NDK library that
+              # you want CMake to locate.
+              log )
+
+# Specifies libraries CMake should link to your target library. You
+# can link multiple libraries, such as libraries you define in this
+# build script, prebuilt third-party libraries, or system libraries.
+
+target_link_libraries( # Specifies the target library.
+                       native-lib
+                       flatbuffers
+                       flatbuffers_tests
+                       # Links the target library to the log library
+                       # included in the NDK.
+                       ${log-lib} )

android/app/src/main/cpp/animals.cpp

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <jni.h>
+#include <string>
+#include <search.h>
+#include "generated/animal_generated.h"
+
+using namespace com::fbs::app;
+using namespace flatbuffers;
+
+extern "C" JNIEXPORT jbyteArray JNICALL Java_com_flatbuffers_app_MainActivity_createAnimalFromJNI(
+        JNIEnv* env,
+        jobject /* this */) {
+    // create a new animal flatbuffers
+    auto fb = FlatBufferBuilder(1024);
+    auto tiger = CreateAnimalDirect(fb, "Tiger", "Roar", 300);
+    fb.Finish(tiger);
+
+    // copies it to a Java byte array.
+    auto buf = reinterpret_cast<jbyte*>(fb.GetBufferPointer());
+    int size = fb.GetSize();
+    auto ret = env->NewByteArray(size);
+    env->SetByteArrayRegion (ret, 0, fb.GetSize(), buf);
+  return ret;
+}

android/app/src/main/cpp/flatbuffers/CMakeLists.txt

@@ -0,0 +1,73 @@
+# For more information about using CMake with Android Studio, read the
+# documentation: https://d.android.com/studio/projects/add-native-code.html
+
+# Sets the minimum version of CMake required to build the native library.
+
+cmake_minimum_required(VERSION 3.4.1)
+
+include_directories(${FLATBUFFERS_SRC}/include)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++11 -fexceptions -Wall -DFLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE")
+
+# Certain platforms such as ARM do not use signed chars by default
+# which causes issues with certain bounds checks.
+set(CMAKE_CXX_FLAGS
+   "${CMAKE_CXX_FLAGS} -fsigned-char")
+
+set(FlatBuffers_Library_SRCS
+        ${FLATBUFFERS_SRC}/include/flatbuffers/allocator.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/array.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/base.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/bfbs_generator.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/buffer.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/buffer_ref.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/default_allocator.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/detached_buffer.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/flatbuffer_builder.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/flatbuffers.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/flexbuffers.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/hash.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/idl.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/minireflect.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/reflection.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/reflection_generated.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/registry.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/stl_emulation.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/string.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/struct.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/table.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/util.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/vector.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/vector_downward.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/verifier.h
+        ${FLATBUFFERS_SRC}/src/idl_parser.cpp
+        ${FLATBUFFERS_SRC}/src/idl_gen_text.cpp
+        ${FLATBUFFERS_SRC}/src/reflection.cpp
+        ${FLATBUFFERS_SRC}/src/util.cpp
+        ${FLATBUFFERS_SRC}/src/idl_gen_fbs.cpp
+        ${FLATBUFFERS_SRC}/src/code_generators.cpp
+        )
+
+set(FlatBuffers_Test_SRCS
+        ${FLATBUFFERS_SRC}/tests/test.cpp
+        ${FLATBUFFERS_SRC}/tests/test_assert.h
+        ${FLATBUFFERS_SRC}/tests/test_builder.h
+        ${FLATBUFFERS_SRC}/tests/test_assert.cpp
+        ${FLATBUFFERS_SRC}/tests/test_builder.cpp
+        ${FLATBUFFERS_SRC}/tests/native_type_test_impl.h
+        ${FLATBUFFERS_SRC}/tests/native_type_test_impl.cpp
+)
+
+add_library( # Sets the name of the library.
+             flatbuffers
+
+             ${FlatBuffers_Library_SRCS}
+             ${FlatBuffers_Test_SRCS}
+             ${Generated_SRCS}
+)
+
+add_library( # Sets the name of the library.
+             flatbuffers_tests
+
+             ${FlatBuffers_Test_SRCS}
+)

android/app/src/main/cpp/generated/animal_generated.h

@@ -0,0 +1,128 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_ANIMAL_COM_FBS_APP_H_
+#define FLATBUFFERS_GENERATED_ANIMAL_COM_FBS_APP_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+namespace com {
+namespace fbs {
+namespace app {
+
+struct Animal;
+struct AnimalBuilder;
+
+struct Animal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef AnimalBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_NAME = 4,
+    VT_SOUND = 6,
+    VT_WEIGHT = 8
+  };
+  const flatbuffers::String *name() const {
+    return GetPointer<const flatbuffers::String *>(VT_NAME);
+  }
+  const flatbuffers::String *sound() const {
+    return GetPointer<const flatbuffers::String *>(VT_SOUND);
+  }
+  uint16_t weight() const {
+    return GetField<uint16_t>(VT_WEIGHT, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_NAME) &&
+           verifier.VerifyString(name()) &&
+           VerifyOffset(verifier, VT_SOUND) &&
+           verifier.VerifyString(sound()) &&
+           VerifyField<uint16_t>(verifier, VT_WEIGHT) &&
+           verifier.EndTable();
+  }
+};
+
+struct AnimalBuilder {
+  typedef Animal Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
+    fbb_.AddOffset(Animal::VT_NAME, name);
+  }
+  void add_sound(flatbuffers::Offset<flatbuffers::String> sound) {
+    fbb_.AddOffset(Animal::VT_SOUND, sound);
+  }
+  void add_weight(uint16_t weight) {
+    fbb_.AddElement<uint16_t>(Animal::VT_WEIGHT, weight, 0);
+  }
+  explicit AnimalBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  AnimalBuilder &operator=(const AnimalBuilder &);
+  flatbuffers::Offset<Animal> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Animal>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Animal> CreateAnimal(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> name = 0,
+    flatbuffers::Offset<flatbuffers::String> sound = 0,
+    uint16_t weight = 0) {
+  AnimalBuilder builder_(_fbb);
+  builder_.add_sound(sound);
+  builder_.add_name(name);
+  builder_.add_weight(weight);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Animal> CreateAnimalDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *name = nullptr,
+    const char *sound = nullptr,
+    uint16_t weight = 0) {
+  auto name__ = name ? _fbb.CreateString(name) : 0;
+  auto sound__ = sound ? _fbb.CreateString(sound) : 0;
+  return com::fbs::app::CreateAnimal(
+      _fbb,
+      name__,
+      sound__,
+      weight);
+}
+
+inline const com::fbs::app::Animal *GetAnimal(const void *buf) {
+  return flatbuffers::GetRoot<com::fbs::app::Animal>(buf);
+}
+
+inline const com::fbs::app::Animal *GetSizePrefixedAnimal(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<com::fbs::app::Animal>(buf);
+}
+
+inline bool VerifyAnimalBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<com::fbs::app::Animal>(nullptr);
+}
+
+inline bool VerifySizePrefixedAnimalBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<com::fbs::app::Animal>(nullptr);
+}
+
+inline void FinishAnimalBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<com::fbs::app::Animal> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedAnimalBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<com::fbs::app::Animal> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+}  // namespace app
+}  // namespace fbs
+}  // namespace com
+
+#endif  // FLATBUFFERS_GENERATED_ANIMAL_COM_FBS_APP_H_

android/app/src/main/fbs/animal.fbs

@@ -12,11 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-namespace sample;
+namespace com.fbs.app;
 
 table Animal {
   name:string;
   sound:string;
+  weight: uint16;
 }
 
 root_type Animal;

android/app/src/main/java/com/flatbuffers/app/MainActivity.kt

@@ -0,0 +1,51 @@
+package com.flatbuffers.app
+
+import android.annotation.SuppressLint
+import androidx.appcompat.app.AppCompatActivity
+import android.os.Bundle
+import android.widget.TextView
+import com.fbs.app.Animal
+import com.google.flatbuffers.FlatBufferBuilder
+import java.nio.ByteBuffer
+
+@ExperimentalUnsignedTypes
+class MainActivity : AppCompatActivity() {
+
+  @SuppressLint("SetTextI18n")
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    setContentView(R.layout.activity_main)
+
+    val tiger = Animal.getRootAsAnimal(ByteBuffer.wrap(createAnimalFromJNI()))
+    findViewById<TextView>(R.id.tv_animal_one).text = animalInfo(tiger)
+
+    findViewById<TextView>(R.id.tv_animal_two).text = animalInfo(createAnimalFromKotlin())
+  }
+
+  // This function is a sample of communicating FlatBuffers between JNI (native C++) and Java.
+  // Implementation can be found on animals.cpp file.
+  private external fun createAnimalFromJNI(): ByteArray
+
+  // Create a "Cow" Animal flatbuffers from Kotlin
+  private fun createAnimalFromKotlin():Animal {
+    val fb = FlatBufferBuilder(100)
+    val cowOffset = Animal.createAnimal(
+      builder = fb,
+      nameOffset = fb.createString("Cow"),
+      soundOffset = fb.createString("Moo"),
+      weight = 720u
+    )
+    fb.finish(cowOffset)
+    return Animal.getRootAsAnimal(fb.dataBuffer())
+  }
+
+  private fun animalInfo(animal: Animal): String =
+    "The ${animal.name} sound is ${animal.sound} and it weights ${animal.weight}kg."
+
+  companion object {
+    // Used to load the 'native-lib' library on application startup.
+    init {
+      System.loadLibrary("native-lib")
+    }
+  }
+}

android/app/src/main/java/generated/com/fbs/app/Animal.kt

@@ -0,0 +1,64 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package com.fbs.app
+
+import java.nio.*
+import kotlin.math.sign
+import com.google.flatbuffers.*
+
+@Suppress("unused")
+@ExperimentalUnsignedTypes
+class Animal : Table() {
+
+    fun __init(_i: Int, _bb: ByteBuffer)  {
+        __reset(_i, _bb)
+    }
+    fun __assign(_i: Int, _bb: ByteBuffer) : Animal {
+        __init(_i, _bb)
+        return this
+    }
+    val name : String?
+        get() {
+            val o = __offset(4)
+            return if (o != 0) __string(o + bb_pos) else null
+        }
+    val nameAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1)
+    fun nameInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1)
+    val sound : String?
+        get() {
+            val o = __offset(6)
+            return if (o != 0) __string(o + bb_pos) else null
+        }
+    val soundAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1)
+    fun soundInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1)
+    val weight : UShort
+        get() {
+            val o = __offset(8)
+            return if(o != 0) bb.getShort(o + bb_pos).toUShort() else 0u
+        }
+    companion object {
+        fun validateVersion() = Constants.FLATBUFFERS_2_0_0()
+        fun getRootAsAnimal(_bb: ByteBuffer): Animal = getRootAsAnimal(_bb, Animal())
+        fun getRootAsAnimal(_bb: ByteBuffer, obj: Animal): Animal {
+            _bb.order(ByteOrder.LITTLE_ENDIAN)
+            return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
+        }
+        fun createAnimal(builder: FlatBufferBuilder, nameOffset: Int, soundOffset: Int, weight: UShort) : Int {
+            builder.startTable(3)
+            addSound(builder, soundOffset)
+            addName(builder, nameOffset)
+            addWeight(builder, weight)
+            return endAnimal(builder)
+        }
+        fun startAnimal(builder: FlatBufferBuilder) = builder.startTable(3)
+        fun addName(builder: FlatBufferBuilder, name: Int) = builder.addOffset(0, name, 0)
+        fun addSound(builder: FlatBufferBuilder, sound: Int) = builder.addOffset(1, sound, 0)
+        fun addWeight(builder: FlatBufferBuilder, weight: UShort) = builder.addShort(2, weight.toShort(), 0)
+        fun endAnimal(builder: FlatBufferBuilder) : Int {
+            val o = builder.endTable()
+            return o
+        }
+        fun finishAnimalBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finish(offset)
+        fun finishSizePrefixedAnimalBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finishSizePrefixed(offset)
+    }
+}

android/app/src/main/res/drawable-v24/ic_launcher_foreground.xml

@@ -0,0 +1,30 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+    <path android:pathData="M31,63.928c0,0 6.4,-11 12.1,-13.1c7.2,-2.6 26,-1.4 26,-1.4l38.1,38.1L107,108.928l-32,-1L31,63.928z">
+        <aapt:attr name="android:fillColor">
+            <gradient
+                android:endX="85.84757"
+                android:endY="92.4963"
+                android:startX="42.9492"
+                android:startY="49.59793"
+                android:type="linear">
+                <item
+                    android:color="#44000000"
+                    android:offset="0.0" />
+                <item
+                    android:color="#00000000"
+                    android:offset="1.0" />
+            </gradient>
+        </aapt:attr>
+    </path>
+    <path
+        android:fillColor="#FFFFFF"
+        android:fillType="nonZero"
+        android:pathData="M65.3,45.828l3.8,-6.6c0.2,-0.4 0.1,-0.9 -0.3,-1.1c-0.4,-0.2 -0.9,-0.1 -1.1,0.3l-3.9,6.7c-6.3,-2.8 -13.4,-2.8 -19.7,0l-3.9,-6.7c-0.2,-0.4 -0.7,-0.5 -1.1,-0.3C38.8,38.328 38.7,38.828 38.9,39.228l3.8,6.6C36.2,49.428 31.7,56.028 31,63.928h46C76.3,56.028 71.8,49.428 65.3,45.828zM43.4,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2c-0.3,-0.7 -0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C45.3,56.528 44.5,57.328 43.4,57.328L43.4,57.328zM64.6,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2s-0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C66.5,56.528 65.6,57.328 64.6,57.328L64.6,57.328z"
+        android:strokeWidth="1"
+        android:strokeColor="#00000000" />
+</vector>

android/app/src/main/res/drawable/ic_launcher_background.xml

@@ -0,0 +1,170 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+    <path
+        android:fillColor="#3DDC84"
+        android:pathData="M0,0h108v108h-108z" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M9,0L9,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,0L19,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M29,0L29,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M39,0L39,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M49,0L49,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M59,0L59,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M69,0L69,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M79,0L79,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M89,0L89,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M99,0L99,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,9L108,9"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,19L108,19"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,29L108,29"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,39L108,39"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,49L108,49"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,59L108,59"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,69L108,69"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,79L108,79"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,89L108,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,99L108,99"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,29L89,29"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,39L89,39"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,49L89,49"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,59L89,59"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,69L89,69"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,79L89,79"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M29,19L29,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M39,19L39,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M49,19L49,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M59,19L59,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M69,19L69,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M79,19L79,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+</vector>

android/app/src/main/res/layout/activity_main.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:app="http://schemas.android.com/apk/res-auto"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:orientation="vertical"
+  android:gravity="center"
+  tools:context=".MainActivity">
+
+  <TextView
+    android:id="@+id/tv_animal_one"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    tools:text="Text Sample"/>
+
+  <TextView
+    android:id="@+id/tv_animal_two"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    tools:text="Text Sample 2"/>
+
+</LinearLayout>

android/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@drawable/ic_launcher_background" />
+    <foreground android:drawable="@drawable/ic_launcher_foreground" />
+</adaptive-icon>

android/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@drawable/ic_launcher_background" />
+    <foreground android:drawable="@drawable/ic_launcher_foreground" />
+</adaptive-icon>

android/app/src/main/res/values/colors.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="colorPrimary">#6200EE</color>
+    <color name="colorPrimaryDark">#3700B3</color>
+    <color name="colorAccent">#03DAC5</color>
+</resources>

android/app/src/main/res/values/strings.xml

@@ -0,0 +1,3 @@
+<resources>
+  <string name="app_name">FlatbuffersTestApp</string>
+</resources>

android/app/src/main/res/values/styles.xml

@@ -0,0 +1,10 @@
+<resources>
+    <!-- Base application theme. -->
+    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
+        <!-- Customize your theme here. -->
+        <item name="colorPrimary">@color/colorPrimary</item>
+        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
+        <item name="colorAccent">@color/colorAccent</item>
+    </style>
+
+</resources>

android/build.gradle

@@ -1,108 +1,35 @@
-// Copyright (c) 2017 Google, Inc.
-//
-// This software is provided 'as-is', without any express or implied
-// warranty.  In no event will the authors be held liable for any damages
-// arising from the use of this software.
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it
-// freely, subject to the following restrictions:
-// 1. The origin of this software must not be misrepresented; you must not
-// claim that you wrote the original software. If you use this software
-// in a product, an acknowledgment in the product documentation would be
-// appreciated but is not required.
-// 2. Altered source versions must be plainly marked as such, and must not be
-// misrepresented as being the original software.
-// 3. This notice may not be removed or altered from any source distribution.
-
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
 buildscript {
+  ext.kotlin_version = "1.4.10"
   repositories {
+    google()
     jcenter()
   }
   dependencies {
-    classpath 'com.android.tools.build:gradle:2.3.0'
+    classpath 'com.android.tools.build:gradle:4.1.0'
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+
+    // NOTE: Do not place your application dependencies here; they belong
+    // in the individual module build.gradle files
   }
 }
 
 allprojects {
   repositories {
+    google()
     jcenter()
   }
 }
 
-apply plugin: 'com.android.application'
+tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
+  sourceCompatibility = JavaVersion.VERSION_1_8
+  targetCompatibility = JavaVersion.VERSION_1_8
 
-android {
-  compileSdkVersion 25
-  buildToolsVersion '25.0.2'
-
-  sourceSets {
-    main {
-      manifest.srcFile 'AndroidManifest.xml'
-      res.srcDirs = ['res']
-    }
-  }
-
-  externalNativeBuild {
-    ndkBuild {
-      path "jni/Android.mk"
-    }
-  }
-
-  defaultConfig {
-    applicationId 'com.example.FlatBufferTest'
-    // This is the platform API where NativeActivity was introduced.
-    minSdkVersion 9
-    targetSdkVersion 25
-    versionCode 1
-    versionName "1.0"
-
-    buildTypes {
-      release {
-        minifyEnabled false
-      }
-    }
-
-    externalNativeBuild {
-      ndkBuild {
-        targets "FlatBufferTest"
-        arguments "-j" + Runtime.getRuntime().availableProcessors()
-        abiFilters "armeabi-v7a", "arm64-v8a", "x86", "x86_64"
-      }
-    }
-  }
-
-  lintOptions {
-    abortOnError false
-  }
-
-  // Build with each STL variant.
-  productFlavors {
-    stlport {
-      applicationIdSuffix ".stlport"
-      versionNameSuffix "-stlport"
-      externalNativeBuild {
-        ndkBuild {
-          arguments "APP_STL=stlport_static"
-        }
-      }
-    }
-    gnustl {
-      applicationIdSuffix ".gnustl"
-      versionNameSuffix "-gnustl"
-      externalNativeBuild {
-        ndkBuild {
-          arguments "APP_STL=gnustl_static"
-        }
-      }
-    }
-    libcpp {
-      applicationIdSuffix ".libcpp"
-      versionNameSuffix "-libcpp"
-      externalNativeBuild {
-        ndkBuild {
-          arguments "APP_STL=c++_static"
-        }
-      }
-    }
+  compileKotlin {
+    dependsOn flatbuffer
   }
 }
+
+task clean(type: Delete) {
+  delete rootProject.buildDir
+}

android/gradle.properties

@@ -0,0 +1,21 @@
+# Project-wide Gradle settings.
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+org.gradle.jvmargs=-Xmx2048m
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
+# AndroidX package structure to make it clearer which packages are bundled with the
+# Android operating system, and which are packaged with your app"s APK
+# https://developer.android.com/topic/libraries/support-library/androidx-rn
+android.useAndroidX=true
+# Automatically convert third-party libraries to use AndroidX
+android.enableJetifier=true
+# Kotlin code style for this project: "official" or "obsolete":
+kotlin.code.style=official

android/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Mon Jun 19 11:54:59 PDT 2017
+#Thu Oct 29 19:47:23 CET 2020
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.0-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.5-all.zip

android/jni/Android.mk

@@ -1,64 +0,0 @@
-# Copyright (c) 2013 Google, Inc.
-#
-# This software is provided 'as-is', without any express or implied
-# warranty.  In no event will the authors be held liable for any damages
-# arising from the use of this software.
-# Permission is granted to anyone to use this software for any purpose,
-# including commercial applications, and to alter it and redistribute it
-# freely, subject to the following restrictions:
-# 1. The origin of this software must not be misrepresented; you must not
-# claim that you wrote the original software. If you use this software
-# in a product, an acknowledgment in the product documentation would be
-# appreciated but is not required.
-# 2. Altered source versions must be plainly marked as such, and must not be
-# misrepresented as being the original software.
-# 3. This notice may not be removed or altered from any source distribution.
-
-LOCAL_PATH := $(call my-dir)/../..
-
-include $(LOCAL_PATH)/android/jni/include.mk
-LOCAL_PATH := $(call realpath-portable,$(LOCAL_PATH))
-
-# Empty static library so that other projects can include just the basic
-# FlatBuffers headers as a module.
-include $(CLEAR_VARS)
-LOCAL_MODULE := flatbuffers
-LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/include
-LOCAL_EXPORT_CPPFLAGS := -std=c++11 -fexceptions -Wall \
-    -DFLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
-
-include $(BUILD_STATIC_LIBRARY)
-
-# static library that additionally includes text parsing/generation/reflection
-# for projects that want richer functionality.
-include $(CLEAR_VARS)
-LOCAL_MODULE := flatbuffers_extra
-LOCAL_SRC_FILES := src/idl_parser.cpp \
-                   src/idl_gen_text.cpp \
-                   src/reflection.cpp \
-                   src/util.cpp
-LOCAL_STATIC_LIBRARIES := flatbuffers
-LOCAL_ARM_MODE := arm
-include $(BUILD_STATIC_LIBRARY)
-
-# FlatBuffers test
-include $(CLEAR_VARS)
-LOCAL_MODULE := FlatBufferTest
-LOCAL_SRC_FILES := android/jni/main.cpp \
-                   tests/test.cpp \
-                   tests/test_assert.h \
-                   tests/test_builder.h \
-                   tests/test_assert.cpp \
-                   tests/test_builder.cpp \
-                   tests/native_type_test_impl.h \
-                   tests/native_type_test_impl.cpp \
-                   src/idl_gen_fbs.cpp \
-                   src/code_generators.cpp
-LOCAL_LDLIBS := -llog -landroid -latomic
-LOCAL_STATIC_LIBRARIES := android_native_app_glue flatbuffers_extra
-LOCAL_ARM_MODE := arm
-include $(BUILD_SHARED_LIBRARY)
-
-$(call import-module,android/native_app_glue)
-
-$(call import-add-path,$(LOCAL_PATH)/../..)

android/jni/Application.mk

@@ -1,20 +0,0 @@
-# Copyright (c) 2014 Google, Inc.
-#
-# This software is provided 'as-is', without any express or implied
-# warranty.  In no event will the authors be held liable for any damages
-# arising from the use of this software.
-# Permission is granted to anyone to use this software for any purpose,
-# including commercial applications, and to alter it and redistribute it
-# freely, subject to the following restrictions:
-# 1. The origin of this software must not be misrepresented; you must not
-# claim that you wrote the original software. If you use this software
-# in a product, an acknowledgment in the product documentation would be
-# appreciated but is not required.
-# 2. Altered source versions must be plainly marked as such, and must not be
-# misrepresented as being the original software.
-# 3. This notice may not be removed or altered from any source distribution.
-APP_PLATFORM := android-9
-APP_PROJECT_PATH := $(call my-dir)/..
-APP_STL ?= stlport_static
-APP_ABI := armeabi-v7a
-APP_CPPFLAGS += -std=c++11

android/jni/build_flatc.bat

@@ -1,68 +0,0 @@
-@rem Copyright (c) 2013 Google, Inc.
-@rem
-@rem This software is provided 'as-is', without any express or implied
-@rem warranty.  In no event will the authors be held liable for any damages
-@rem arising from the use of this software.
-@rem Permission is granted to anyone to use this software for any purpose,
-@rem including commercial applications, and to alter it and redistribute it
-@rem freely, subject to the following restrictions:
-@rem 1. The origin of this software must not be misrepresented; you must not
-@rem claim that you wrote the original software. If you use this software
-@rem in a product, an acknowledgment in the product documentation would be
-@rem appreciated but is not required.
-@rem 2. Altered source versions must be plainly marked as such, and must not be
-@rem misrepresented as being the original software.
-@rem 3. This notice may not be removed or altered from any source distribution.
-@echo off
-
-setlocal enabledelayedexpansion
-
-set thispath=%~dp0
-
-rem Path to cmake passed in by caller.
-set cmake=%1
-rem Path to cmake project to build.
-set cmake_project_path=%2
-
-rem Newest and oldest version of Visual Studio that it's possible to select.
-set visual_studio_version_max=20
-set visual_studio_version_min=8
-
-rem Determine the newest version of Visual Studio installed on this machine.
-set visual_studio_version=
-for /L %%a in (%visual_studio_version_max%,-1,%visual_studio_version_min%) do (
-  echo Searching for Visual Studio %%a >&2
-  reg query HKLM\SOFTWARE\Microsoft\VisualStudio\%%a.0 /ve 1>NUL 2>NUL
-  if !ERRORLEVEL! EQU 0 (
-    set visual_studio_version=%%a
-    goto found_vs
-  )
-)
-echo Unable to determine whether Visual Studio is installed. >&2
-exit /B 1
-:found_vs
-
-rem Map Visual Studio version to cmake generator name.
-if "%visual_studio_version%"=="8" (
-  set cmake_generator=Visual Studio 8 2005
-)
-if "%visual_studio_version%"=="9" (
-  set cmake_generator=Visual Studio 9 2008
-)
-if %visual_studio_version% GEQ 10 (
-  set cmake_generator=Visual Studio %visual_studio_version%
-)
-rem Set visual studio version variable for msbuild.
-set VisualStudioVersion=%visual_studio_version%.0
-
-rem Generate Visual Studio solution.
-echo Generating solution for %cmake_generator%. >&2
-cd "%cmake_project_path%"
-%cmake% -G"%cmake_generator%"
-if %ERRORLEVEL% NEQ 0 (
-  exit /B %ERRORLEVEL%
-)
-
-rem Build flatc
-python %thispath%\msbuild.py flatc.vcxproj
-if ERRORLEVEL 1 exit /B 1

android/jni/include.mk

@@ -1,237 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# This file contains utility functions for Android projects using Flatbuffers.
-# To use this file, include it in your project's Android.mk by calling near the
-# top of your android makefile like so:
-#
-#     include $(FLATBUFFERS_DIR)/android/jni/include.mk
-#
-# You will also need to import the flatbuffers module using the standard
-# import-module function.
-#
-# The main functionality this file provides are the following functions:
-# flatbuffers_fbs_to_h: Converts flatbuffer schema paths to header paths.
-# flatbuffers_header_build_rule:
-#     Creates a build rule for a schema's generated header. This build rule
-#     has a dependency on the flatc compiler which will be built if necessary.
-# flatbuffers_header_build_rules:
-#     Creates build rules for generated headers for each schema listed and sets
-#     up depenedendies.
-#
-# More information and example usage can be found in the comments preceeding
-# each function.
-
-# Targets to build the Flatbuffers compiler as well as some utility definitions
-ifeq (,$(FLATBUFFERS_INCLUDE_MK_))
-FLATBUFFERS_INCLUDE_MK_ := 1
-
-# Portable version of $(realpath) that omits drive letters on Windows.
-realpath-portable = $(join $(filter %:,$(subst :,: ,$1)),\
-                      $(realpath $(filter-out %:,$(subst :,: ,$1))))
-
-PROJECT_OS := $(OS)
-ifeq (,$(OS))
-PROJECT_OS := $(shell uname -s)
-else
-ifneq ($(findstring Windows,$(PROJECT_OS)),)
-PROJECT_OS := Windows
-endif
-endif
-
-# The following block generates build rules which result in headers being
-# rebuilt from flatbuffers schemas.
-
-FLATBUFFERS_CMAKELISTS_DIR := \
-  $(call realpath-portable,$(dir $(lastword $(MAKEFILE_LIST)))/../..)
-
-# Directory that contains the FlatBuffers compiler.
-ifeq (Windows,$(PROJECT_OS))
-FLATBUFFERS_FLATC_PATH?=$(FLATBUFFERS_CMAKELISTS_DIR)
-FLATBUFFERS_FLATC := $(lastword \
-                       $(wildcard $(FLATBUFFERS_FLATC_PATH)/*/flatc.exe) \
-                       $(wildcard $(FLATBUFFERS_FLATC_PATH)/flatc.exe))
-endif
-ifeq (Linux,$(PROJECT_OS))
-FLATBUFFERS_FLATC_PATH?=$(FLATBUFFERS_CMAKELISTS_DIR)
-FLATBUFFERS_FLATC := $(FLATBUFFERS_FLATC_PATH)/flatc
-endif
-ifeq (Darwin,$(PROJECT_OS))
-FLATBUFFERS_FLATC_PATH?=$(FLATBUFFERS_CMAKELISTS_DIR)
-FLATBUFFERS_FLATC := $(lastword \
-                       $(wildcard $(FLATBUFFERS_FLATC_PATH)/*/flatc) \
-                       $(wildcard $(FLATBUFFERS_FLATC_PATH)/flatc))
-endif
-
-FLATBUFFERS_FLATC_ARGS?=
-
-# Search for cmake.
-CMAKE_ROOT := \
-  $(call realpath-portable,$(LOCAL_PATH)/../../../../../../prebuilts/cmake)
-ifeq (,$(CMAKE))
-ifeq (Linux,$(PROJECT_OS))
-CMAKE := $(wildcard $(CMAKE_ROOT)/linux-x86/current/bin/cmake*)
-endif
-ifeq (Darwin,$(PROJECT_OS))
-CMAKE := \
-  $(wildcard $(CMAKE_ROOT)/darwin-x86_64/current/*.app/Contents/bin/cmake)
-endif
-ifeq (Windows,$(PROJECT_OS))
-CMAKE := $(wildcard $(CMAKE_ROOT)/windows/current/bin/cmake*)
-endif
-endif
-ifeq (,$(CMAKE))
-CMAKE := cmake
-endif
-
-# Windows friendly portable local path.
-# GNU-make doesn't like : in paths, must use relative paths on Windows.
-ifeq (Windows,$(PROJECT_OS))
-PORTABLE_LOCAL_PATH =
-else
-PORTABLE_LOCAL_PATH = $(LOCAL_PATH)/
-endif
-
-# Generate a host build rule for the flatbuffers compiler.
-ifeq (Windows,$(PROJECT_OS))
-define build_flatc_recipe
-	$(FLATBUFFERS_CMAKELISTS_DIR)\android\jni\build_flatc.bat \
-        $(CMAKE) $(FLATBUFFERS_CMAKELISTS_DIR)
-endef
-endif
-ifeq (Linux,$(PROJECT_OS))
-define build_flatc_recipe
-	+cd $(FLATBUFFERS_CMAKELISTS_DIR) && \
-      $(CMAKE) . && \
-      $(MAKE) flatc
-endef
-endif
-ifeq (Darwin,$(PROJECT_OS))
-define build_flatc_recipe
-	cd $(FLATBUFFERS_CMAKELISTS_DIR) && "$(CMAKE)" -GXcode . && \
-        xcodebuild -target flatc
-endef
-endif
-ifeq (,$(build_flatc_recipe))
-ifeq (,$(FLATBUFFERS_FLATC))
-$(error flatc binary not found!)
-endif
-endif
-
-# Generate a build rule for flatc.
-ifeq ($(strip $(FLATBUFFERS_FLATC)),)
-flatc_target := build_flatc
-.PHONY: $(flatc_target)
-FLATBUFFERS_FLATC := \
-  python $(FLATBUFFERS_CMAKELISTS_DIR)/android/jni/run_flatc.py \
-    $(FLATBUFFERS_CMAKELISTS_DIR)
-else
-flatc_target := $(FLATBUFFERS_FLATC)
-endif
-$(flatc_target):
-	$(call build_flatc_recipe)
-
-# $(flatbuffers_fbs_to_h schema_dir,output_dir,path)
-#
-# Convert the specified schema path to a Flatbuffers generated header path.
-# For example:
-#
-# $(call flatbuffers_fbs_to_h,$(MY_PROJ_DIR)/schemas,\
-#   $(MY_PROJ_DIR)/gen/include,$(MY_PROJ_DIR)/schemas/example.fbs)
-#
-# This will convert the file path `$(MY_PROJ_DIR)/schemas/example.fbs)` to
-# `$(MY_PROJ_DIR)/gen/include/example_generated.h`
-define flatbuffers_fbs_to_h
-$(subst $(1),$(2),$(patsubst %.fbs,%_generated.h,$(3)))
-endef
-
-# $(flatbuffers_header_build_rule schema_file,schema_dir,output_dir,\
-#   schema_include_dirs)
-#
-# Generate a build rule that will convert a Flatbuffers schema to a generated
-# header derived from the schema filename using flatbuffers_fbs_to_h. For
-# example:
-#
-# $(call flatbuffers_header_build_rule,$(MY_PROJ_DIR)/schemas/example.fbs,\
-#   $(MY_PROJ_DIR)/schemas,$(MY_PROJ_DIR)/gen/include)
-#
-# The final argument, schema_include_dirs, is optional and is only needed when
-# the schema files depend on other schema files outside their own directory.
-define flatbuffers_header_build_rule
-$(eval \
-  $(call flatbuffers_fbs_to_h,$(2),$(3),$(1)): $(1) $(flatc_target)
-	$(call host-echo-build-step,generic,Generate) \
-      $(subst $(LOCAL_PATH)/,,$(call flatbuffers_fbs_to_h,$(2),$(3),$(1)))
-	$(hide) $$(FLATBUFFERS_FLATC) $(FLATBUFFERS_FLATC_ARGS) \
-      $(foreach include,$(4),-I $(include)) -o $$(dir $$@) -c $$<)
-endef
-
-# TODO: Remove when the LOCAL_PATH expansion bug in the NDK is fixed.
-# Override the default behavior of local-source-file-path to workaround
-# a bug which prevents the build of deeply nested projects when NDK_OUT is
-# set.
-local-source-file-path=\
-$(if $(call host-path-is-absolute,$1),$1,$(call \
-    realpath-portable,$(LOCAL_PATH)/$1))
-
-
-# $(flatbuffers_header_build_rules schema_files,schema_dir,output_dir,\
-#   schema_include_dirs,src_files,[build_target],[dependencies]))
-#
-# $(1) schema_files: Space separated list of flatbuffer schema files.
-# $(2) schema_dir: Directory containing the flatbuffer schemas.
-# $(3) output_dir: Where to place the generated files.
-# $(4) schema_include_dirs: Directories to include when generating schemas.
-# $(5) src_files: Files that should depend upon the headers generated from the
-#   flatbuffer schemas.
-# $(6) build_target: Name of a build target that depends upon all generated
-#   headers.
-# $(7) dependencies: Space seperated list of additional build targets src_files
-#   should depend upon.
-#
-# Use this in your own Android.mk file to generate build rules that will
-# generate header files for your flatbuffer schemas as well as automatically
-# set your source files to be dependent on the generated headers. For example:
-#
-# $(call flatbuffers_header_build_rules,$(MY_PROJ_SCHEMA_FILES),\
-#   $(MY_PROJ_SCHEMA_DIR),$(MY_PROJ_GENERATED_OUTPUT_DIR),
-#   $(MY_PROJ_SCHEMA_INCLUDE_DIRS),$(LOCAL_SRC_FILES))
-#
-# NOTE: Due problesm with path processing in ndk-build when presented with
-# deeply nested projects must redefine LOCAL_PATH after include this makefile
-# using:
-#
-# LOCAL_PATH := $(call realpath-portable,$(LOCAL_PATH))
-#
-define flatbuffers_header_build_rules
-$(foreach schema,$(1),\
-  $(call flatbuffers_header_build_rule,\
-    $(schema),$(strip $(2)),$(strip $(3)),$(strip $(4))))\
-$(foreach src,$(strip $(5)),\
-  $(eval $(call local-source-file-path,$(src)): \
-    $(foreach schema,$(strip $(1)),\
-      $(call flatbuffers_fbs_to_h,$(strip $(2)),$(strip $(3)),$(schema)))))\
-$(if $(6),\
-  $(foreach schema,$(strip $(1)),\
-    $(eval $(6): \
-      $(call flatbuffers_fbs_to_h,$(strip $(2)),$(strip $(3)),$(schema)))),)\
-$(if $(7),\
-  $(foreach src,$(strip $(5)),\
-      $(eval $(call local-source-file-path,$(src)): $(strip $(7)))),)\
-$(if $(7),\
-  $(foreach dependency,$(strip $(7)),\
-      $(eval $(6): $(dependency))),)
-endef
-
-endif  # FLATBUFFERS_INCLUDE_MK_

android/jni/msbuild.py

@@ -1,77 +0,0 @@
-#!/usr/bin/python
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Simple script that locates the newest MSBuild in one of several locations.
-
-This script will find the highest version number of MSBuild and run it,
-passing its arguments through to MSBuild.
-"""
-
-import glob
-import os
-import re
-import string
-import subprocess
-import sys
-
-SYSTEMROOT = os.getenv("SYSTEMROOT", "c:\\windows")
-PROGRAM_FILES = os.getenv("ProgramFiles", "c:\\Program Files")
-PROGRAM_FILES_X86 = os.getenv("ProgramFiles(x86)", "c:\\Program Files (x86)")
-
-SEARCH_FOLDERS = [ PROGRAM_FILES + "\\MSBuild\\*\\Bin\\MSBuild.exe",
-                   PROGRAM_FILES_X86 + "\\MSBuild\\*\\Bin\\MSBuild.exe",
-                   SYSTEMROOT + "\\Microsoft.NET\Framework\\*\\MSBuild.exe" ]
-
-def compare_version(a, b):
-  """Compare two version number strings of the form W.X.Y.Z.
-
-  The numbers are compared most-significant to least-significant.
-  For example, 12.345.67.89 > 2.987.88.99.
-
-  Args:
-    a: First version number string to compare
-    b: Second version number string to compare
-
-  Returns:
-    0 if the numbers are identical, a positive number if 'a' is larger, and
-    a negative number if 'b' is larger.
-  """
-  aa = string.split(a, ".")
-  bb = string.split(b, ".")
-  for i in range(0, 4):
-    if aa[i] != bb[i]:
-      return cmp(int(aa[i]), int(bb[i]))
-  return 0
-
-def main():
-  msbuilds = []
-
-  for folder in SEARCH_FOLDERS:
-    for file in glob.glob(folder):
-      p = subprocess.Popen([file, "/version"], stdout=subprocess.PIPE)
-      out, err = p.communicate()
-      match = re.search("^[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+$", out, re.M)
-      if match:
-        msbuilds.append({ 'ver':match.group(), 'exe':file })
-  msbuilds.sort(lambda x, y: compare_version(x['ver'], y['ver']), reverse=True)
-  if len(msbuilds) == 0:
-    print "Unable to find MSBuild.\n"
-    return -1;
-  cmd = [msbuilds[0]['exe']]
-  cmd.extend(sys.argv[1:])
-  return subprocess.call(cmd)
-
-if __name__ == '__main__':
-  sys.exit(main())

android/jni/run_flatc.py

@@ -1,46 +0,0 @@
-#!/usr/bin/python
-# Copyright 2015 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-import platform
-import subprocess
-import sys
-
-EXECUTABLE_EXTENSION = '.exe' if platform.system() == 'Windows' else ''
-# Paths to search for flatc relative to the current working directory.
-FLATC_SEARCH_PATHS = [os.path.curdir, 'Release', 'Debug']
-
-def main():
-  """Script that finds and runs flatc built from source."""
-  if len(sys.argv) < 2:
-    sys.stderr.write('Usage: run_flatc.py flatbuffers_dir [flatc_args]\n')
-    return 1
-  cwd = os.getcwd()
-  flatc = ''
-  flatbuffers_dir = sys.argv[1]
-  for path in FLATC_SEARCH_PATHS:
-    current = os.path.join(flatbuffers_dir, path,
-                           'flatc' + EXECUTABLE_EXTENSION)
-    if os.path.exists(current):
-      flatc = current
-      break
-  if not flatc:
-    sys.stderr.write('flatc not found\n')
-    return 1
-  command = [flatc] + sys.argv[2:]
-  return subprocess.call(command)
-
-if __name__ == '__main__':
-  sys.exit(main())

android/res/values/strings.xml

@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (c) 2014 Google, Inc.
-
-     This software is provided 'as-is', without any express or implied
-     warranty.  In no event will the authors be held liable for any damages
-     arising from the use of this software.
-     Permission is granted to anyone to use this software for any purpose,
-     including commercial applications, and to alter it and redistribute it
-     freely, subject to the following restrictions:
-     1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-     2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-     3. This notice may not be removed or altered from any source distribution.
- -->
-<resources>
-    <string name="app_name">FlatBufferTest</string>
-</resources>

android/settings.gradle

@@ -0,0 +1,2 @@
+include ':app'
+rootProject.name = "FlatbuffersTest"

appveyor.yml

@@ -3,6 +3,7 @@ branches:
     - master
 
 environment:
+  nodejs_version: "14"
 
   global:
     # Workaround for https://github.com/conda/conda-build/issues/636
@@ -10,29 +11,11 @@ environment:
     CONDA_INSTALL_LOCN: "C:\\Miniconda35-x64"
     CMAKE_OPTIONS: ""
     CPP_TEST_OPTIONS: ""
+    CHECK_GEN_CODE: 1
 
   matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      CMAKE_VS_VERSION: "10 2010"
-      CMAKE_OPTIONS: "-DFLATBUFFERS_BUILD_LEGACY=1"
-      CPP_TEST_OPTIONS: "--std-cpp c++0x"
-      MONSTER_EXTRA: "skip"
-
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      CMAKE_VS_VERSION: "12 2013"
-      MONSTER_EXTRA: "skip"
-
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       CMAKE_VS_VERSION: "14 2015"
-      MONSTER_EXTRA: ""
-
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      CMAKE_VS_VERSION: "15 2017"
-      MONSTER_EXTRA: ""
-
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      CMAKE_VS_VERSION: "16 2019"
-      MONSTER_EXTRA: ""
 
 platform:
   - x86
@@ -43,12 +26,9 @@ configuration:
   - Release
 
 before_build:
-  - set MONSTER_EXTRA=%MONSTER_EXTRA%
   - cmake . -G"Visual Studio %CMAKE_VS_VERSION%" -DFLATBUFFERS_CODE_SANITIZE=1 %CMAKE_OPTIONS%
   # This cuts down on a lot of noise generated by xamarin warnings.
   - if exist "C:\Program Files (x86)\MSBuild\14.0\Microsoft.Common.targets\ImportAfter\Xamarin.Common.targets" del "C:\Program Files (x86)\MSBuild\14.0\Microsoft.Common.targets\ImportAfter\Xamarin.Common.targets"
-  - if exist "C:\Program Files (x86)\MSBuild\15.0\Microsoft.Common.targets\ImportAfter\Xamarin.Common.targets" del "C:\Program Files (x86)\MSBuild\15.0\Microsoft.Common.targets\ImportAfter\Xamarin.Common.targets"
-  - if exist "C:\Program Files (x86)\MSBuild\16.0\Microsoft.Common.targets\ImportAfter\Xamarin.Common.targets" del "C:\Program Files (x86)\MSBuild\16.0\Microsoft.Common.targets\ImportAfter\Xamarin.Common.targets"
 
 build:
   project: ALL_BUILD.vcxproj
@@ -60,63 +40,34 @@ after_build:
 
 install:
   - set PATH=%CONDA_INSTALL_LOCN%;%CONDA_INSTALL_LOCN%\scripts;%PATH%;
-  - curl -sSf -o rustup-init.exe https://win.rustup.rs/
-  - rustup-init.exe -y
-  - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin
-  - rustc -V
-  - cargo -V
+  - ps: Install-Product node $env:nodejs_version
 
 test_script:
-  - call .appveyor\check-generate-code.bat -b %CONFIGURATION%
+  - if [%CHECK_GEN_CODE%]==[1] (call py scripts/check_generate_code.py "%CPP_TEST_OPTIONS%")
   - "cd tests"
-  - rem "Building all code"
-  - generate_code.bat -b %CONFIGURATION% %CPP_TEST_OPTIONS%
   - 7z a GeneratedMyGameCode.zip MyGame\
   - rem "---------------- C++ -----------------"
   - "cd .."
   - "%CONFIGURATION%\\flattests.exe"
-  - "cd tests"
-  - rem "---------------- Java -----------------"
-  - "java -version"
-  - "JavaTest.bat"
-  - rem "---------------- Rust ----------------"
-  - "RustTest.bat"
   - rem "---------------- JS -----------------"
   - "node --version"
-  - "..\\%CONFIGURATION%\\flatc -b -I include_test monster_test.fbs unicode_test.json"
-  - "node JavaScriptTest ./monster_test_generated"
-  - rem "-------------- Python ---------------"
-  - where python
-  - python --version
-  - where pip
-  - pip --version
-  - where conda
-  - conda --version
-  - rem "installing flatbuffers python library"
-  - pip install ../python
-  - rem "testing without installing Numpy"
-  - python py_test.py 0 0 0
-  - rem "testing after installing Numpy - disabled"
-  # FIXME: This has a LOT of unnecessary dependencies and makes the tests fail
-  # with timeouts.
-  # - conda install --yes numpy
-  # - python py_test.py 0 0 0
+  - "npm install"
+  - "npm run compile"
+  - "cd tests"
+  - "TypeScriptTest.bat"
   - rem "---------------- C# -----------------"
   # Have to compile this here rather than in "build" above because AppVeyor only
   # supports building one project??
   - "cd FlatBuffers.Test"
-  - "copy ..\\monsterdata_test.mon Resources\\"
-  - "copy ..\\monsterdata_test.json Resources\\"
   - "dotnet new sln"
   - "dotnet sln add FlatBuffers.Test.csproj"
   - "nuget restore"
-  - "msbuild.exe /property:Configuration=Release;OutputPath=tempcs /verbosity:minimal FlatBuffers.Test.csproj"
-  - "tempcs\\FlatBuffers.Test.exe"
+  - "mkdir .tmp"
+  - "msbuild.exe /property:Configuration=Release;OutputPath=.tmp /verbosity:minimal FlatBuffers.Test.csproj"
+  - ".tmp\\FlatBuffers.Test.exe"
   # Run tests with UNSAFE_BYTEBUFFER
-  - "msbuild.exe /property:Configuration=Release;UnsafeByteBuffer=true;OutputPath=tempcsUnsafe /verbosity:minimal FlatBuffers.Test.csproj"
-  - "tempcsUnsafe\\FlatBuffers.Test.exe"
-  # TODO: add more languages.
-  - "cd ..\\.."
+  - "msbuild.exe /property:Configuration=Release;UnsafeByteBuffer=true;OutputPath=.tmp /verbosity:minimal FlatBuffers.Test.csproj"
+  - ".tmp\\FlatBuffers.Test.exe"
 
 artifacts:
   - path: $(CONFIGURATION)\flatc.exe

benchmarks/CMakeLists.txt

@@ -0,0 +1,81 @@
+# Setup for running Google Benchmarks (https://github.com/google/benchmark) on
+# flatbuffers. This requires both that benchmark library and its depenency gtest
+# to build. Instead of including them here or doing a submodule, this uses
+# FetchContent (https://cmake.org/cmake/help/latest/module/FetchContent.html) to
+# grab the dependencies at config time. This requires CMake 3.14 or higher.
+cmake_minimum_required(VERSION 3.14)
+include(FetchContent)
+
+# No particular reason for the specific GIT_TAGs for the following repos, they
+# were just the latest releases when this was added.
+FetchContent_Declare(
+    googletest
+    GIT_REPOSITORY https://github.com/google/googletest.git
+    GIT_TAG        e2239ee6043f73722e7aa812a459f54a28552929 # release-1.11.0
+)
+FetchContent_Declare(
+    googlebenchmark
+    GIT_REPOSITORY https://github.com/google/benchmark.git
+    GIT_TAG        f91b6b42b1b9854772a90ae9501464a161707d1e # v1.6.0
+)
+
+# For Windows: Prevent overriding the parent project's compiler/linker 
+# settings.
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+FetchContent_MakeAvailable(
+    googletest
+    googlebenchmark
+)
+
+set(CPP_BENCH_DIR cpp)
+set(CPP_FB_BENCH_DIR ${CPP_BENCH_DIR}/flatbuffers)
+set(CPP_RAW_BENCH_DIR ${CPP_BENCH_DIR}/raw)
+set(CPP_BENCH_FBS ${CPP_FB_BENCH_DIR}/bench.fbs)
+set(CPP_BENCH_FB_GEN ${CPP_FB_BENCH_DIR}/bench_generated.h)
+
+set(FlatBenchmark_SRCS
+    ${CPP_BENCH_DIR}/benchmark_main.cpp
+    ${CPP_FB_BENCH_DIR}/fb_bench.cpp
+    ${CPP_RAW_BENCH_DIR}/raw_bench.cpp
+    ${CPP_BENCH_FB_GEN}
+)
+
+# Generate the flatbuffers benchmark code from the flatbuffers schema using
+# flatc itself, thus it depends on flatc. This also depends on the C++ runtime
+# flatbuffers and the schema file itself, so it should auto-generated at the
+# correct times.
+add_custom_command(
+    OUTPUT ${CPP_BENCH_FB_GEN}
+    COMMAND 
+        "${FLATBUFFERS_FLATC_EXECUTABLE}"
+        --cpp
+        -o ${CPP_FB_BENCH_DIR}
+        ${CPP_BENCH_FBS}
+    DEPENDS 
+        flatc
+        flatbuffers
+        ${CPP_BENCH_FBS}
+    COMMENT "Run Flatbuffers Benchmark Codegen: ${CPP_BENCH_FB_GEN}"
+    VERBATIM)
+
+# The main flatbuffers benchmark executable
+add_executable(flatbenchmark ${FlatBenchmark_SRCS})
+
+# Benchmark requires C++11 
+target_compile_features(flatbenchmark PUBLIC
+    cxx_std_11
+)
+
+# Set the output directory to the root binary directory
+set_target_properties(flatbenchmark 
+    PROPERTIES RUNTIME_OUTPUT_DIRECTORY 
+    "${CMAKE_BINARY_DIR}"
+)
+
+# The includes of the benchmark files are fully qualified from flatbuffers root.
+target_include_directories(flatbenchmark PUBLIC ${CMAKE_SOURCE_DIR})
+
+target_link_libraries(flatbenchmark 
+    benchmark::benchmark_main # _main to use their entry point 
+    gtest # Link to gtest so we can also assert in the benchmarks
+)

benchmarks/cpp/bench.h

@@ -0,0 +1,19 @@
+#ifndef BENCHMARKS_CPP_BENCH_H_
+#define BENCHMARKS_CPP_BENCH_H_
+
+#include <cstdint>
+
+struct Bench {
+  virtual ~Bench() {}
+
+  inline void Add(int64_t value) { sum += value; }
+
+  virtual uint8_t *Encode(void *buf, int64_t &len) = 0;
+  virtual void *Decode(void *buf, int64_t len) = 0;
+  virtual int64_t Use(void *decoded) = 0;
+  virtual void Dealloc(void *decoded) = 0;
+
+  int64_t sum = 0;
+};
+
+#endif // BENCHMARKS_CPP_BENCH_H_

benchmarks/cpp/benchmark_main.cpp

@@ -0,0 +1,96 @@
+#include <benchmark/benchmark.h>
+#include <gtest/gtest.h>
+
+#include "benchmarks/cpp/bench.h"
+#include "benchmarks/cpp/flatbuffers/fb_bench.h"
+#include "benchmarks/cpp/raw/raw_bench.h"
+
+static inline void Encode(benchmark::State &state,
+                          std::unique_ptr<Bench> &bench, uint8_t *buffer) {
+  int64_t length;
+  for (auto _ : state) {
+    bench->Encode(buffer, length);
+    benchmark::DoNotOptimize(length);
+  }
+}
+
+static inline void Decode(benchmark::State &state,
+                          std::unique_ptr<Bench> &bench, uint8_t *buffer) {
+  int64_t length;
+  uint8_t *encoded = bench->Encode(buffer, length);
+
+  for (auto _ : state) {
+    void *decoded = bench->Decode(encoded, length);
+    benchmark::DoNotOptimize(decoded);
+  }
+}
+
+static inline void Use(benchmark::State &state, std::unique_ptr<Bench> &bench,
+                       uint8_t *buffer, int64_t check_sum) {
+  int64_t length;
+  uint8_t *encoded = bench->Encode(buffer, length);
+  void *decoded = bench->Decode(encoded, length);
+
+  int64_t sum = 0;
+
+  for (auto _ : state) { sum = bench->Use(decoded); }
+
+  EXPECT_EQ(sum, check_sum);
+}
+
+static void BM_Flatbuffers_Encode(benchmark::State &state) {
+  const int64_t kBufferLength = 1024;
+  uint8_t buffer[kBufferLength];
+
+  StaticAllocator allocator(&buffer[0]);
+  std::unique_ptr<Bench> bench = NewFlatBuffersBench(kBufferLength, &allocator);
+  Encode(state, bench, buffer);
+}
+BENCHMARK(BM_Flatbuffers_Encode);
+
+static void BM_Flatbuffers_Decode(benchmark::State &state) {
+  const int64_t kBufferLength = 1024;
+  uint8_t buffer[kBufferLength];
+
+  StaticAllocator allocator(&buffer[0]);
+  std::unique_ptr<Bench> bench = NewFlatBuffersBench(kBufferLength, &allocator);
+  Decode(state, bench, buffer);
+}
+BENCHMARK(BM_Flatbuffers_Decode);
+
+static void BM_Flatbuffers_Use(benchmark::State &state) {
+  const int64_t kBufferLength = 1024;
+  uint8_t buffer[kBufferLength];
+
+  StaticAllocator allocator(&buffer[0]);
+  std::unique_ptr<Bench> bench = NewFlatBuffersBench(kBufferLength, &allocator);
+  Use(state, bench, buffer, 218812692406581874);
+}
+BENCHMARK(BM_Flatbuffers_Use);
+
+static void BM_Raw_Encode(benchmark::State &state) {
+  const int64_t kBufferLength = 1024;
+  uint8_t buffer[kBufferLength];
+
+  std::unique_ptr<Bench> bench = NewRawBench();
+  Encode(state, bench, buffer);
+}
+BENCHMARK(BM_Raw_Encode);
+
+static void BM_Raw_Decode(benchmark::State &state) {
+  const int64_t kBufferLength = 1024;
+  uint8_t buffer[kBufferLength];
+
+  std::unique_ptr<Bench> bench = NewRawBench();
+  Decode(state, bench, buffer);
+}
+BENCHMARK(BM_Raw_Decode);
+
+static void BM_Raw_Use(benchmark::State &state) {
+  const int64_t kBufferLength = 1024;
+  uint8_t buffer[kBufferLength];
+
+  std::unique_ptr<Bench> bench = NewRawBench();
+  Use(state, bench, buffer, 218812692406581874);
+}
+BENCHMARK(BM_Raw_Use);

benchmarks/cpp/flatbuffers/bench.fbs

@@ -0,0 +1,52 @@
+// Copyright 2021 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+// trying to represent a typical mix of datatypes:
+// 1 array of 3 elements, each element: 1 string, 3 nested objects, 9 scalars
+// root element has the array, additional string and an enum
+
+namespace benchmarks_flatbuffers;
+
+enum Enum : short { Apples, Pears, Bananas}
+
+struct Foo {
+  id:ulong;
+  count:short;
+  prefix:byte;
+  length:uint;
+}
+
+struct Bar {
+  parent:Foo;
+  time:int;
+  ratio:float;
+  size:ushort;
+}
+
+table FooBar {
+  sibling:Bar;
+  name:string;
+  rating:double;
+  postfix:ubyte;
+}
+
+table FooBarContainer {
+  list:[FooBar];  // 3 copies of the above
+  initialized:bool;
+  fruit:Enum;
+  location:string;
+}
+
+root_type FooBarContainer;

benchmarks/cpp/flatbuffers/bench_generated.h

@@ -0,0 +1,347 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_BENCH_BENCHMARKS_FLATBUFFERS_H_
+#define FLATBUFFERS_GENERATED_BENCH_BENCHMARKS_FLATBUFFERS_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+namespace benchmarks_flatbuffers {
+
+struct Foo;
+
+struct Bar;
+
+struct FooBar;
+struct FooBarBuilder;
+
+struct FooBarContainer;
+struct FooBarContainerBuilder;
+
+enum Enum : int16_t {
+  Enum_Apples = 0,
+  Enum_Pears = 1,
+  Enum_Bananas = 2,
+  Enum_MIN = Enum_Apples,
+  Enum_MAX = Enum_Bananas
+};
+
+inline const Enum (&EnumValuesEnum())[3] {
+  static const Enum values[] = {
+    Enum_Apples,
+    Enum_Pears,
+    Enum_Bananas
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesEnum() {
+  static const char * const names[4] = {
+    "Apples",
+    "Pears",
+    "Bananas",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameEnum(Enum e) {
+  if (flatbuffers::IsOutRange(e, Enum_Apples, Enum_Bananas)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesEnum()[index];
+}
+
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Foo FLATBUFFERS_FINAL_CLASS {
+ private:
+  uint64_t id_;
+  int16_t count_;
+  int8_t prefix_;
+  int8_t padding0__;
+  uint32_t length_;
+
+ public:
+  Foo()
+      : id_(0),
+        count_(0),
+        prefix_(0),
+        padding0__(0),
+        length_(0) {
+    (void)padding0__;
+  }
+  Foo(uint64_t _id, int16_t _count, int8_t _prefix, uint32_t _length)
+      : id_(flatbuffers::EndianScalar(_id)),
+        count_(flatbuffers::EndianScalar(_count)),
+        prefix_(flatbuffers::EndianScalar(_prefix)),
+        padding0__(0),
+        length_(flatbuffers::EndianScalar(_length)) {
+    (void)padding0__;
+  }
+  uint64_t id() const {
+    return flatbuffers::EndianScalar(id_);
+  }
+  int16_t count() const {
+    return flatbuffers::EndianScalar(count_);
+  }
+  int8_t prefix() const {
+    return flatbuffers::EndianScalar(prefix_);
+  }
+  uint32_t length() const {
+    return flatbuffers::EndianScalar(length_);
+  }
+};
+FLATBUFFERS_STRUCT_END(Foo, 16);
+
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Bar FLATBUFFERS_FINAL_CLASS {
+ private:
+  benchmarks_flatbuffers::Foo parent_;
+  int32_t time_;
+  float ratio_;
+  uint16_t size_;
+  int16_t padding0__;  int32_t padding1__;
+
+ public:
+  Bar()
+      : parent_(),
+        time_(0),
+        ratio_(0),
+        size_(0),
+        padding0__(0),
+        padding1__(0) {
+    (void)padding0__;
+    (void)padding1__;
+  }
+  Bar(const benchmarks_flatbuffers::Foo &_parent, int32_t _time, float _ratio, uint16_t _size)
+      : parent_(_parent),
+        time_(flatbuffers::EndianScalar(_time)),
+        ratio_(flatbuffers::EndianScalar(_ratio)),
+        size_(flatbuffers::EndianScalar(_size)),
+        padding0__(0),
+        padding1__(0) {
+    (void)padding0__;
+    (void)padding1__;
+  }
+  const benchmarks_flatbuffers::Foo &parent() const {
+    return parent_;
+  }
+  int32_t time() const {
+    return flatbuffers::EndianScalar(time_);
+  }
+  float ratio() const {
+    return flatbuffers::EndianScalar(ratio_);
+  }
+  uint16_t size() const {
+    return flatbuffers::EndianScalar(size_);
+  }
+};
+FLATBUFFERS_STRUCT_END(Bar, 32);
+
+struct FooBar FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef FooBarBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_SIBLING = 4,
+    VT_NAME = 6,
+    VT_RATING = 8,
+    VT_POSTFIX = 10
+  };
+  const benchmarks_flatbuffers::Bar *sibling() const {
+    return GetStruct<const benchmarks_flatbuffers::Bar *>(VT_SIBLING);
+  }
+  const flatbuffers::String *name() const {
+    return GetPointer<const flatbuffers::String *>(VT_NAME);
+  }
+  double rating() const {
+    return GetField<double>(VT_RATING, 0.0);
+  }
+  uint8_t postfix() const {
+    return GetField<uint8_t>(VT_POSTFIX, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<benchmarks_flatbuffers::Bar>(verifier, VT_SIBLING) &&
+           VerifyOffset(verifier, VT_NAME) &&
+           verifier.VerifyString(name()) &&
+           VerifyField<double>(verifier, VT_RATING) &&
+           VerifyField<uint8_t>(verifier, VT_POSTFIX) &&
+           verifier.EndTable();
+  }
+};
+
+struct FooBarBuilder {
+  typedef FooBar Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_sibling(const benchmarks_flatbuffers::Bar *sibling) {
+    fbb_.AddStruct(FooBar::VT_SIBLING, sibling);
+  }
+  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
+    fbb_.AddOffset(FooBar::VT_NAME, name);
+  }
+  void add_rating(double rating) {
+    fbb_.AddElement<double>(FooBar::VT_RATING, rating, 0.0);
+  }
+  void add_postfix(uint8_t postfix) {
+    fbb_.AddElement<uint8_t>(FooBar::VT_POSTFIX, postfix, 0);
+  }
+  explicit FooBarBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  flatbuffers::Offset<FooBar> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<FooBar>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<FooBar> CreateFooBar(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const benchmarks_flatbuffers::Bar *sibling = nullptr,
+    flatbuffers::Offset<flatbuffers::String> name = 0,
+    double rating = 0.0,
+    uint8_t postfix = 0) {
+  FooBarBuilder builder_(_fbb);
+  builder_.add_rating(rating);
+  builder_.add_name(name);
+  builder_.add_sibling(sibling);
+  builder_.add_postfix(postfix);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<FooBar> CreateFooBarDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const benchmarks_flatbuffers::Bar *sibling = nullptr,
+    const char *name = nullptr,
+    double rating = 0.0,
+    uint8_t postfix = 0) {
+  auto name__ = name ? _fbb.CreateString(name) : 0;
+  return benchmarks_flatbuffers::CreateFooBar(
+      _fbb,
+      sibling,
+      name__,
+      rating,
+      postfix);
+}
+
+struct FooBarContainer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef FooBarContainerBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_LIST = 4,
+    VT_INITIALIZED = 6,
+    VT_FRUIT = 8,
+    VT_LOCATION = 10
+  };
+  const flatbuffers::Vector<flatbuffers::Offset<benchmarks_flatbuffers::FooBar>> *list() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<benchmarks_flatbuffers::FooBar>> *>(VT_LIST);
+  }
+  bool initialized() const {
+    return GetField<uint8_t>(VT_INITIALIZED, 0) != 0;
+  }
+  benchmarks_flatbuffers::Enum fruit() const {
+    return static_cast<benchmarks_flatbuffers::Enum>(GetField<int16_t>(VT_FRUIT, 0));
+  }
+  const flatbuffers::String *location() const {
+    return GetPointer<const flatbuffers::String *>(VT_LOCATION);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_LIST) &&
+           verifier.VerifyVector(list()) &&
+           verifier.VerifyVectorOfTables(list()) &&
+           VerifyField<uint8_t>(verifier, VT_INITIALIZED) &&
+           VerifyField<int16_t>(verifier, VT_FRUIT) &&
+           VerifyOffset(verifier, VT_LOCATION) &&
+           verifier.VerifyString(location()) &&
+           verifier.EndTable();
+  }
+};
+
+struct FooBarContainerBuilder {
+  typedef FooBarContainer Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_list(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<benchmarks_flatbuffers::FooBar>>> list) {
+    fbb_.AddOffset(FooBarContainer::VT_LIST, list);
+  }
+  void add_initialized(bool initialized) {
+    fbb_.AddElement<uint8_t>(FooBarContainer::VT_INITIALIZED, static_cast<uint8_t>(initialized), 0);
+  }
+  void add_fruit(benchmarks_flatbuffers::Enum fruit) {
+    fbb_.AddElement<int16_t>(FooBarContainer::VT_FRUIT, static_cast<int16_t>(fruit), 0);
+  }
+  void add_location(flatbuffers::Offset<flatbuffers::String> location) {
+    fbb_.AddOffset(FooBarContainer::VT_LOCATION, location);
+  }
+  explicit FooBarContainerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  flatbuffers::Offset<FooBarContainer> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<FooBarContainer>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<FooBarContainer> CreateFooBarContainer(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<benchmarks_flatbuffers::FooBar>>> list = 0,
+    bool initialized = false,
+    benchmarks_flatbuffers::Enum fruit = benchmarks_flatbuffers::Enum_Apples,
+    flatbuffers::Offset<flatbuffers::String> location = 0) {
+  FooBarContainerBuilder builder_(_fbb);
+  builder_.add_location(location);
+  builder_.add_list(list);
+  builder_.add_fruit(fruit);
+  builder_.add_initialized(initialized);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<FooBarContainer> CreateFooBarContainerDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<flatbuffers::Offset<benchmarks_flatbuffers::FooBar>> *list = nullptr,
+    bool initialized = false,
+    benchmarks_flatbuffers::Enum fruit = benchmarks_flatbuffers::Enum_Apples,
+    const char *location = nullptr) {
+  auto list__ = list ? _fbb.CreateVector<flatbuffers::Offset<benchmarks_flatbuffers::FooBar>>(*list) : 0;
+  auto location__ = location ? _fbb.CreateString(location) : 0;
+  return benchmarks_flatbuffers::CreateFooBarContainer(
+      _fbb,
+      list__,
+      initialized,
+      fruit,
+      location__);
+}
+
+inline const benchmarks_flatbuffers::FooBarContainer *GetFooBarContainer(const void *buf) {
+  return flatbuffers::GetRoot<benchmarks_flatbuffers::FooBarContainer>(buf);
+}
+
+inline const benchmarks_flatbuffers::FooBarContainer *GetSizePrefixedFooBarContainer(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<benchmarks_flatbuffers::FooBarContainer>(buf);
+}
+
+inline bool VerifyFooBarContainerBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<benchmarks_flatbuffers::FooBarContainer>(nullptr);
+}
+
+inline bool VerifySizePrefixedFooBarContainerBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<benchmarks_flatbuffers::FooBarContainer>(nullptr);
+}
+
+inline void FinishFooBarContainerBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<benchmarks_flatbuffers::FooBarContainer> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedFooBarContainerBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<benchmarks_flatbuffers::FooBarContainer> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+}  // namespace benchmarks_flatbuffers
+
+#endif  // FLATBUFFERS_GENERATED_BENCH_BENCHMARKS_FLATBUFFERS_H_

benchmarks/cpp/flatbuffers/fb_bench.cpp

@@ -0,0 +1,80 @@
+#include "benchmarks/cpp/flatbuffers/fb_bench.h"
+
+#include <cstdint>
+#include <memory>
+
+#include "benchmarks/cpp/bench.h"
+#include "benchmarks/cpp/flatbuffers/bench_generated.h"
+#include "flatbuffers/flatbuffers.h"
+
+using namespace flatbuffers;
+using namespace benchmarks_flatbuffers;
+
+namespace {
+
+struct FlatBufferBench : Bench {
+  explicit FlatBufferBench(int64_t initial_size, Allocator *allocator)
+      : fbb(initial_size, allocator, false) {}
+
+  uint8_t *Encode(void *, int64_t &len) {
+    fbb.Clear();
+
+    const int kVectorLength = 3;
+    Offset<FooBar> vec[kVectorLength];
+
+    for (int i = 0; i < kVectorLength; ++i) {
+      Foo foo(0xABADCAFEABADCAFE + i, 10000 + i, '@' + i, 1000000 + i);
+      Bar bar(foo, 123456 + i, 3.14159f + i, 10000 + i);
+      auto name = fbb.CreateString("Hello, World!");
+      auto foobar =
+          CreateFooBar(fbb, &bar, name, 3.1415432432445543543 + i, '!' + i);
+      vec[i] = foobar;
+    }
+    auto location = fbb.CreateString("http://google.com/flatbuffers/");
+    auto foobarvec = fbb.CreateVector(vec, kVectorLength);
+    auto foobarcontainer =
+        CreateFooBarContainer(fbb, foobarvec, true, Enum_Bananas, location);
+    fbb.Finish(foobarcontainer);
+
+    len = fbb.GetSize();
+    return fbb.GetBufferPointer();
+  }
+
+  int64_t Use(void *decoded) {
+    sum = 0;
+    auto foobarcontainer = GetFooBarContainer(decoded);
+    sum = 0;
+    Add(foobarcontainer->initialized());
+    Add(foobarcontainer->location()->Length());
+    Add(foobarcontainer->fruit());
+    for (unsigned int i = 0; i < foobarcontainer->list()->Length(); i++) {
+      auto foobar = foobarcontainer->list()->Get(i);
+      Add(foobar->name()->Length());
+      Add(foobar->postfix());
+      Add(static_cast<int64_t>(foobar->rating()));
+      auto bar = foobar->sibling();
+      Add(static_cast<int64_t>(bar->ratio()));
+      Add(bar->size());
+      Add(bar->time());
+      auto &foo = bar->parent();
+      Add(foo.count());
+      Add(foo.id());
+      Add(foo.length());
+      Add(foo.prefix());
+    }
+    return sum;
+  }
+
+  void *Decode(void *buffer, int64_t) { return buffer; }
+  void Dealloc(void *) override{};
+
+  FlatBufferBuilder fbb;
+};
+
+}  // namespace
+
+std::unique_ptr<Bench> NewFlatBuffersBench(int64_t initial_size,
+                                           Allocator *allocator) {
+  return std::unique_ptr<FlatBufferBench>(
+      new FlatBufferBench(initial_size, allocator));
+}

benchmarks/cpp/flatbuffers/fb_bench.h

@@ -0,0 +1,23 @@
+#ifndef BENCHMARKS_CPP_FLATBUFFERS_FB_BENCH_H_
+#define BENCHMARKS_CPP_FLATBUFFERS_FB_BENCH_H_
+
+#include <cstdint>
+#include <memory>
+
+#include "benchmarks/cpp/bench.h"
+#include "include/flatbuffers/flatbuffers.h"
+
+struct StaticAllocator : public flatbuffers::Allocator {
+  explicit StaticAllocator(uint8_t *buffer) : buffer_(buffer) {}
+
+  uint8_t *allocate(size_t) override { return buffer_; }
+
+  void deallocate(uint8_t *, size_t) override {}
+
+  uint8_t *buffer_;
+};
+
+std::unique_ptr<Bench> NewFlatBuffersBench(
+    int64_t initial_size = 1024, flatbuffers::Allocator *allocator = nullptr);
+
+#endif  // BENCHMARKS_CPP_FLATBUFFERS_FB_BENCH_H_

benchmarks/cpp/raw/raw_bench.cpp

@@ -0,0 +1,109 @@
+#include "benchmarks/cpp/raw/raw_bench.h"
+
+#include <cstdint>
+#include <cstring>
+#include <memory>
+
+#include "benchmarks/cpp/bench.h"
+
+namespace {
+const int64_t kStringLength = 32;
+const int64_t kVectorLength = 3;
+
+enum Enum { Apples, Pears, Bananas };
+
+struct Foo {
+  int64_t id;
+  short count;
+  char prefix;
+  int length;
+};
+
+struct Bar {
+  Foo parent;
+  int time;
+  float ratio;
+  unsigned short size;
+};
+
+struct FooBar {
+  Bar sibling;
+  // We have to stick this in, otherwise strlen() will make it slower than
+  // FlatBuffers:
+  int name_len;
+  char name[kStringLength];
+  double rating;
+  unsigned char postfix;
+};
+
+struct FooBarContainer {
+  FooBar list[kVectorLength];  // 3 copies of the above
+  bool initialized;
+  Enum fruit;
+  int location_len;
+  char location[kStringLength];
+};
+
+struct RawBench : Bench {
+  uint8_t *Encode(void *buf, int64_t &len) {
+    FooBarContainer *fbc = new (buf) FooBarContainer;
+    strcpy(fbc->location, "http://google.com/flatbuffers/");  // Unsafe eek!
+    fbc->location_len = (int)strlen(fbc->location);
+    fbc->fruit = Bananas;
+    fbc->initialized = true;
+    for (int i = 0; i < kVectorLength; i++) {
+      // We add + i to not make these identical copies for a more realistic
+      // compression test.
+      auto &foobar = fbc->list[i];
+      foobar.rating = 3.1415432432445543543 + i;
+      foobar.postfix = '!' + i;
+      strcpy(foobar.name, "Hello, World!");
+      foobar.name_len = (int)strlen(foobar.name);
+      auto &bar = foobar.sibling;
+      bar.ratio = 3.14159f + i;
+      bar.size = 10000 + i;
+      bar.time = 123456 + i;
+      auto &foo = bar.parent;
+      foo.id = 0xABADCAFEABADCAFE + i;
+      foo.count = 10000 + i;
+      foo.length = 1000000 + i;
+      foo.prefix = '@' + i;
+    }
+
+    len = sizeof(FooBarContainer);
+    return reinterpret_cast<uint8_t *>(fbc);
+  };
+
+  int64_t Use(void *decoded) {
+    auto foobarcontainer = reinterpret_cast<FooBarContainer *>(decoded);
+    sum = 0;
+    Add(foobarcontainer->initialized);
+    Add(foobarcontainer->location_len);
+    Add(foobarcontainer->fruit);
+    for (unsigned int i = 0; i < kVectorLength; i++) {
+      auto foobar = &foobarcontainer->list[i];
+      Add(foobar->name_len);
+      Add(foobar->postfix);
+      Add(static_cast<int64_t>(foobar->rating));
+      auto bar = &foobar->sibling;
+      Add(static_cast<int64_t>(bar->ratio));
+      Add(bar->size);
+      Add(bar->time);
+      auto &foo = bar->parent;
+      Add(foo.count);
+      Add(foo.id);
+      Add(foo.length);
+      Add(foo.prefix);
+    }
+    return sum;
+  }
+
+  void *Decode(void *buf, int64_t) { return buf; }
+  void Dealloc(void *) override{};
+};
+
+}  // namespace
+
+std::unique_ptr<Bench> NewRawBench() {
+  return std::unique_ptr<RawBench>(new RawBench());
+}

benchmarks/cpp/raw/raw_bench.h

@@ -0,0 +1,10 @@
+#ifndef BENCHMARKS_CPP_RAW_RAW_BENCH_H_
+#define BENCHMARKS_CPP_RAW_RAW_BENCH_H_
+
+#include <memory>
+
+#include "benchmarks/cpp/bench.h"
+
+std::unique_ptr<Bench> NewRawBench();
+
+#endif  // BENCHMARKS_CPP_RAW_RAW_BENCH_H_

build_defs.bzl

@@ -209,7 +209,7 @@ def flatbuffer_cc_library(
         Happy dependent Flatbuffering!
     '''
     output_headers = [
-        (out_prefix + "%s_generated.h") % (s.replace(".fbs", "").split("/")[-1])
+        (out_prefix + "%s_generated.h") % (s.replace(".fbs", "").split("/")[-1].split(":")[-1])
         for s in srcs
     ]
     reflection_name = "%s_reflection" % name if gen_reflections else ""

dart/CHANGELOG.md

@@ -1,4 +1,22 @@
-# CHANGELOG
+## 2.0.0
+
+- switch to null safety (#6696)
+- add Object APIs (pack/unpack) (#6682, #6723, #6846)
+- add custom builder buffer allocator support (#6711)
+- add `Builder.size()` - finished buffer size (#6403)
+- make `writeString()` argument non-nullable (#6737)
+- make tables fixed size (expect the number of fields when creating) (#6735)
+- make table deduplication optional (param `deduplicateTables`) (#6734)
+- change `Builder.reset()` to reuse an existing buffer (#6661)
+- change table building to assert() instead of exceptions (#6754)
+- optimize `writeString()` for ASCII (param `asciiOptimization`) (#6736)
+- change `StringReader` to make ASCII optimization optional (param `asciiOptimization`) (#6758)
+- change `[byte]` and `[ubyte]` representation to `dart:typed_data` `Int8List` and `Uint8List` (#6839)
+- rename `lowFinish()` to `buffer` getter (#6712)
+- fix `Builder._writeString()` - always write trailing zero byte (#6390)
+- fix `Builder.reset()` - clear vTables (#6386)
+- make sure added padding is zeroed, same as in C++ (#6716)
+- many performance improvements (#6755)
 
 ## 1.9.2
 
@@ -11,4 +29,4 @@
 
 ## 1.9.0
 
-- Initial release, supports Dart 1.x and many dev versions of Dart 2.x
+- Initial release, supports Dart 1.x and many dev versions of Dart 2.x

dart/README.md

@@ -1,13 +1,17 @@
 # FlatBuffers for Dart
 
-This package is used to read and write FlatBuffer files in Dart.
+This package is used to read and write [FlatBuffers](https://google.github.io/flatbuffers/).
 
-Most consumers will want to use the [`flatc`](https://github.com/google/flatbuffers)
-compiler to generate Dart code from a FlatBuffers IDL schema.  For example, the
-`monster_my_game.sample_generated.dart` was generated with `flatc` from
-`monster.fbs` in the example folder. The generated classes can be used to read
-or write binary files that are interoperable with other languages and platforms
-supported by FlatBuffers, as illustrated in the `example.dart` in the
+Most consumers will want to use the [`flatc` - FlatBuffer compiler](https://github.com/google/flatbuffers) binary for your platform:
+* [Linux](https://github.com/google/flatbuffers/suites/4363603985/artifacts/114682272)
+* [macOS](https://github.com/google/flatbuffers/suites/4363603985/artifacts/114682273)
+* [Windows](https://github.com/google/flatbuffers/suites/4363603985/artifacts/114682274)
+
+The FlatBuffer compiler `flatc` reads a FlatBuffers IDL schema and generates Dart code.
+The generated classes can be used to read or write binary data/files that are interoperable with
+other languages and platforms supported by FlatBuffers, as illustrated in the `example.dart` in the
 examples folder.
 
-Additional documentation and examples are available [at the FlatBuffers site](https://google.github.io/flatbuffers/index.html)
+For more details and documentation, head over to the official site and read the
+[Tutorial](https://google.github.io/flatbuffers/flatbuffers_guide_tutorial.html) and how to
+[use FlatBuffers in Dart](https://google.github.io/flatbuffers/flatbuffers_guide_use_dart.html).

dart/analysis_options.yaml

@@ -0,0 +1 @@
+include: package:lints/recommended.yaml

dart/example/example.dart

@@ -15,7 +15,7 @@
  */
 
 import 'package:flat_buffers/flat_buffers.dart' as fb;
-import './monster_my_game.sample_generated.dart' as myGame;
+import './monster_my_game.sample_generated.dart' as my_game;
 
 // Example how to use FlatBuffers to create and read binary buffers.
 
@@ -25,27 +25,27 @@ void main() {
 }
 
 void builderTest() {
-  final builder = new fb.Builder(initialSize: 1024);
-  final int weaponOneName = builder.writeString("Sword");
+  final builder = fb.Builder(initialSize: 1024);
+  final int? weaponOneName = builder.writeString("Sword");
   final int weaponOneDamage = 3;
 
-  final int weaponTwoName = builder.writeString("Axe");
+  final int? weaponTwoName = builder.writeString("Axe");
   final int weaponTwoDamage = 5;
 
-  final swordBuilder = new myGame.WeaponBuilder(builder)
+  final swordBuilder = my_game.WeaponBuilder(builder)
     ..begin()
     ..addNameOffset(weaponOneName)
     ..addDamage(weaponOneDamage);
   final int sword = swordBuilder.finish();
 
-  final axeBuilder = new myGame.WeaponBuilder(builder)
+  final axeBuilder = my_game.WeaponBuilder(builder)
     ..begin()
     ..addNameOffset(weaponTwoName)
     ..addDamage(weaponTwoDamage);
   final int axe = axeBuilder.finish();
 
   // Serialize a name for our monster, called "Orc".
-  final int name = builder.writeString('Orc');
+  final int? name = builder.writeString('Orc');
 
   // Create a list representing the inventory of the Orc. Each number
   // could correspond to an item that can be claimed after he is slain.
@@ -54,7 +54,7 @@ void builderTest() {
   final weapons = builder.writeList([sword, axe]);
 
   // Struct builders are very easy to reuse.
-  final vec3Builder = new myGame.Vec3Builder(builder);
+  final vec3Builder = my_game.Vec3Builder(builder);
 
   vec3Builder.finish(4.0, 5.0, 6.0);
   vec3Builder.finish(1.0, 2.0, 3.0);
@@ -62,21 +62,21 @@ void builderTest() {
   final int hp = 300;
   final int mana = 150;
 
-  final monster = new myGame.MonsterBuilder(builder)
+  final monster = my_game.MonsterBuilder(builder)
     ..begin()
     ..addNameOffset(name)
     ..addInventoryOffset(inventory)
     ..addWeaponsOffset(weapons)
-    ..addEquippedType(myGame.EquipmentTypeId.Weapon)
+    ..addEquippedType(my_game.EquipmentTypeId.Weapon)
     ..addEquippedOffset(axe)
     ..addHp(hp)
     ..addMana(mana)
     ..addPos(vec3Builder.finish(1.0, 2.0, 3.0))
-    ..addColor(myGame.Color.Red);
+    ..addColor(my_game.Color.Red);
 
   final int monsteroff = monster.finish();
-  final buffer = builder.finish(monsteroff);
-  if (verify(buffer)) {
+  builder.finish(monsteroff);
+  if (verify(builder.buffer)) {
     print(
         "The FlatBuffer was successfully created with a builder and verified!");
   }
@@ -85,17 +85,17 @@ void builderTest() {
 void objectBuilderTest() {
   // Create the builder here so we can use it for both weapons and equipped
   // the actual data will only be written to the buffer once.
-  var axe = new myGame.WeaponObjectBuilder(name: 'Axe', damage: 5);
+  var axe = my_game.WeaponObjectBuilder(name: 'Axe', damage: 5);
 
-  var monsterBuilder = new myGame.MonsterObjectBuilder(
-    pos: new myGame.Vec3ObjectBuilder(x: 1.0, y: 2.0, z: 3.0),
+  var monsterBuilder = my_game.MonsterObjectBuilder(
+    pos: my_game.Vec3ObjectBuilder(x: 1.0, y: 2.0, z: 3.0),
     mana: 150,
     hp: 300,
     name: 'Orc',
     inventory: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
-    color: myGame.Color.Red,
-    weapons: [new myGame.WeaponObjectBuilder(name: 'Sword', damage: 3), axe],
-    equippedType: myGame.EquipmentTypeId.Weapon,
+    color: my_game.Color.Red,
+    weapons: [my_game.WeaponObjectBuilder(name: 'Sword', damage: 3), axe],
+    equippedType: my_game.EquipmentTypeId.Weapon,
     equipped: axe,
   );
 
@@ -114,7 +114,7 @@ void objectBuilderTest() {
 
 bool verify(List<int> buffer) {
   // Get access to the root:
-  var monster = new myGame.Monster(buffer);
+  var monster = my_game.Monster(buffer);
 
   // Get and test some scalar types from the FlatBuffer.
   assert(monster.hp == 80);
@@ -122,31 +122,29 @@ bool verify(List<int> buffer) {
   assert(monster.name == "MyMonster");
 
   // Get and test a field of the FlatBuffer's `struct`.
-  var pos = monster.pos;
-  assert(pos != null);
+  var pos = monster.pos!;
   assert(pos.z == 3.0);
 
   // Get a test an element from the `inventory` FlatBuffer's `vector`.
-  var inv = monster.inventory;
-  assert(inv != null);
+  var inv = monster.inventory!;
   assert(inv.length == 10);
   assert(inv[9] == 9);
 
   // Get and test the `weapons` FlatBuffers's `vector`.
-  var expected_weapon_names = ["Sword", "Axe"];
-  var expected_weapon_damages = [3, 5];
-  var weps = monster.weapons;
+  var expectedWeaponNames = ["Sword", "Axe"];
+  var expectedWeaponDamages = [3, 5];
+  var weps = monster.weapons!;
   for (int i = 0; i < weps.length; i++) {
-    assert(weps[i].name == expected_weapon_names[i]);
-    assert(weps[i].damage == expected_weapon_damages[i]);
+    assert(weps[i].name == expectedWeaponNames[i]);
+    assert(weps[i].damage == expectedWeaponDamages[i]);
   }
 
   // Get and test the `Equipment` union (`equipped` field).
-  assert(monster.equippedType.value == myGame.EquipmentTypeId.Weapon.value);
-  assert(monster.equippedType == myGame.EquipmentTypeId.Weapon);
+  assert(monster.equippedType!.value == my_game.EquipmentTypeId.Weapon.value);
+  assert(monster.equippedType == my_game.EquipmentTypeId.Weapon);
 
-  assert(monster.equipped is myGame.Weapon);
-  var equipped = monster.equipped as myGame.Weapon;
+  assert(monster.equipped is my_game.Weapon);
+  var equipped = monster.equipped as my_game.Weapon;
   assert(equipped.name == "Axe");
   assert(equipped.damage == 5);
 

dart/example/monster_my_game.sample_generated.dart

@@ -1,5 +1,5 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-// ignore_for_file: unused_import, non_constant_identifier_names
+// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable
 
 library my_game.sample;
 
@@ -12,23 +12,29 @@ class Color {
   const Color._(this.value);
 
   factory Color.fromValue(int value) {
-    if (value == null) return null;
-    if (!values.containsKey(value)) {
-      throw new StateError('Invalid value $value for bit flag enum Color');
+    final result = values[value];
+    if (result == null) {
+      throw StateError('Invalid value $value for bit flag enum Color');
     }
-    return values[value];
+    return result;
   }
 
+  static Color? _createOrNull(int? value) => 
+      value == null ? null : Color.fromValue(value);
+
   static const int minValue = 0;
   static const int maxValue = 2;
   static bool containsValue(int value) => values.containsKey(value);
 
-  static const Color Red = const Color._(0);
-  static const Color Green = const Color._(1);
-  static const Color Blue = const Color._(2);
-  static get values => {0: Red,1: Green,2: Blue,};
+  static const Color Red = Color._(0);
+  static const Color Green = Color._(1);
+  static const Color Blue = Color._(2);
+  static const Map<int, Color> values = {
+    0: Red,
+    1: Green,
+    2: Blue};
 
-  static const fb.Reader<Color> reader = const _ColorReader();
+  static const fb.Reader<Color> reader = _ColorReader();
 
   @override
   String toString() {
@@ -44,7 +50,7 @@ class _ColorReader extends fb.Reader<Color> {
 
   @override
   Color read(fb.BufferContext bc, int offset) =>
-      new Color.fromValue(const fb.Int8Reader().read(bc, offset));
+      Color.fromValue(const fb.Int8Reader().read(bc, offset));
 }
 
 class EquipmentTypeId {
@@ -52,22 +58,27 @@ class EquipmentTypeId {
   const EquipmentTypeId._(this.value);
 
   factory EquipmentTypeId.fromValue(int value) {
-    if (value == null) return null;
-    if (!values.containsKey(value)) {
-      throw new StateError('Invalid value $value for bit flag enum EquipmentTypeId');
+    final result = values[value];
+    if (result == null) {
+      throw StateError('Invalid value $value for bit flag enum EquipmentTypeId');
     }
-    return values[value];
+    return result;
   }
 
+  static EquipmentTypeId? _createOrNull(int? value) => 
+      value == null ? null : EquipmentTypeId.fromValue(value);
+
   static const int minValue = 0;
   static const int maxValue = 1;
   static bool containsValue(int value) => values.containsKey(value);
 
-  static const EquipmentTypeId NONE = const EquipmentTypeId._(0);
-  static const EquipmentTypeId Weapon = const EquipmentTypeId._(1);
-  static get values => {0: NONE,1: Weapon,};
+  static const EquipmentTypeId NONE = EquipmentTypeId._(0);
+  static const EquipmentTypeId Weapon = EquipmentTypeId._(1);
+  static const Map<int, EquipmentTypeId> values = {
+    0: NONE,
+    1: Weapon};
 
-  static const fb.Reader<EquipmentTypeId> reader = const _EquipmentTypeIdReader();
+  static const fb.Reader<EquipmentTypeId> reader = _EquipmentTypeIdReader();
 
   @override
   String toString() {
@@ -83,13 +94,13 @@ class _EquipmentTypeIdReader extends fb.Reader<EquipmentTypeId> {
 
   @override
   EquipmentTypeId read(fb.BufferContext bc, int offset) =>
-      new EquipmentTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
+      EquipmentTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
 }
 
 class Vec3 {
   Vec3._(this._bc, this._bcOffset);
 
-  static const fb.Reader<Vec3> reader = const _Vec3Reader();
+  static const fb.Reader<Vec3> reader = _Vec3Reader();
 
   final fb.BufferContext _bc;
   final int _bcOffset;
@@ -112,13 +123,11 @@ class _Vec3Reader extends fb.StructReader<Vec3> {
 
   @override
   Vec3 createObject(fb.BufferContext bc, int offset) => 
-    new Vec3._(bc, offset);
+    Vec3._(bc, offset);
 }
 
 class Vec3Builder {
-  Vec3Builder(this.fbBuilder) {
-    assert(fbBuilder != null);
-  }
+  Vec3Builder(this.fbBuilder);
 
   final fb.Builder fbBuilder;
 
@@ -137,9 +146,9 @@ class Vec3ObjectBuilder extends fb.ObjectBuilder {
   final double _z;
 
   Vec3ObjectBuilder({
-    double x,
-    double y,
-    double z,
+    required double x,
+    required double y,
+    required double z,
   })
       : _x = x,
         _y = y,
@@ -147,10 +156,7 @@ class Vec3ObjectBuilder extends fb.ObjectBuilder {
 
   /// Finish building, and store into the [fbBuilder].
   @override
-  int finish(
-    fb.Builder fbBuilder) {
-    assert(fbBuilder != null);
-
+  int finish(fb.Builder fbBuilder) {
     fbBuilder.putFloat32(_z);
     fbBuilder.putFloat32(_y);
     fbBuilder.putFloat32(_x);
@@ -159,39 +165,39 @@ class Vec3ObjectBuilder extends fb.ObjectBuilder {
 
   /// Convenience method to serialize to byte list.
   @override
-  Uint8List toBytes([String fileIdentifier]) {
-    fb.Builder fbBuilder = new fb.Builder();
-    int offset = finish(fbBuilder);
-    return fbBuilder.finish(offset, fileIdentifier);
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
   }
 }
 class Monster {
   Monster._(this._bc, this._bcOffset);
   factory Monster(List<int> bytes) {
-    fb.BufferContext rootRef = new fb.BufferContext.fromBytes(bytes);
+    final rootRef = fb.BufferContext.fromBytes(bytes);
     return reader.read(rootRef, 0);
   }
 
-  static const fb.Reader<Monster> reader = const _MonsterReader();
+  static const fb.Reader<Monster> reader = _MonsterReader();
 
   final fb.BufferContext _bc;
   final int _bcOffset;
 
-  Vec3 get pos => Vec3.reader.vTableGet(_bc, _bcOffset, 4, null);
+  Vec3? get pos => Vec3.reader.vTableGetNullable(_bc, _bcOffset, 4);
   int get mana => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 6, 150);
   int get hp => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 8, 100);
-  String get name => const fb.StringReader().vTableGet(_bc, _bcOffset, 10, null);
-  List<int> get inventory => const fb.ListReader<int>(const fb.Uint8Reader()).vTableGet(_bc, _bcOffset, 14, null);
-  Color get color => new Color.fromValue(const fb.Int8Reader().vTableGet(_bc, _bcOffset, 16, 2));
-  List<Weapon> get weapons => const fb.ListReader<Weapon>(Weapon.reader).vTableGet(_bc, _bcOffset, 18, null);
-  EquipmentTypeId get equippedType => new EquipmentTypeId.fromValue(const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 20, null));
+  String? get name => const fb.StringReader().vTableGetNullable(_bc, _bcOffset, 10);
+  List<int>? get inventory => const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 14);
+  Color get color => Color.fromValue(const fb.Int8Reader().vTableGet(_bc, _bcOffset, 16, 2));
+  List<Weapon>? get weapons => const fb.ListReader<Weapon>(Weapon.reader).vTableGetNullable(_bc, _bcOffset, 18);
+  EquipmentTypeId? get equippedType => EquipmentTypeId._createOrNull(const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 20));
   dynamic get equipped {
     switch (equippedType?.value) {
-      case 1: return Weapon.reader.vTableGet(_bc, _bcOffset, 22, null);
+      case 1: return Weapon.reader.vTableGetNullable(_bc, _bcOffset, 22);
       default: return null;
     }
   }
-  List<Vec3> get path => const fb.ListReader<Vec3>(Vec3.reader).vTableGet(_bc, _bcOffset, 24, null);
+  List<Vec3>? get path => const fb.ListReader<Vec3>(Vec3.reader).vTableGetNullable(_bc, _bcOffset, 24);
 
   @override
   String toString() {
@@ -204,57 +210,55 @@ class _MonsterReader extends fb.TableReader<Monster> {
 
   @override
   Monster createObject(fb.BufferContext bc, int offset) => 
-    new Monster._(bc, offset);
+    Monster._(bc, offset);
 }
 
 class MonsterBuilder {
-  MonsterBuilder(this.fbBuilder) {
-    assert(fbBuilder != null);
-  }
+  MonsterBuilder(this.fbBuilder);
 
   final fb.Builder fbBuilder;
 
   void begin() {
-    fbBuilder.startTable();
+    fbBuilder.startTable(10);
   }
 
   int addPos(int offset) {
     fbBuilder.addStruct(0, offset);
     return fbBuilder.offset;
   }
-  int addMana(int mana) {
+  int addMana(int? mana) {
     fbBuilder.addInt16(1, mana);
     return fbBuilder.offset;
   }
-  int addHp(int hp) {
+  int addHp(int? hp) {
     fbBuilder.addInt16(2, hp);
     return fbBuilder.offset;
   }
-  int addNameOffset(int offset) {
+  int addNameOffset(int? offset) {
     fbBuilder.addOffset(3, offset);
     return fbBuilder.offset;
   }
-  int addInventoryOffset(int offset) {
+  int addInventoryOffset(int? offset) {
     fbBuilder.addOffset(5, offset);
     return fbBuilder.offset;
   }
-  int addColor(Color color) {
+  int addColor(Color? color) {
     fbBuilder.addInt8(6, color?.value);
     return fbBuilder.offset;
   }
-  int addWeaponsOffset(int offset) {
+  int addWeaponsOffset(int? offset) {
     fbBuilder.addOffset(7, offset);
     return fbBuilder.offset;
   }
-  int addEquippedType(EquipmentTypeId equippedType) {
+  int addEquippedType(EquipmentTypeId? equippedType) {
     fbBuilder.addUint8(8, equippedType?.value);
     return fbBuilder.offset;
   }
-  int addEquippedOffset(int offset) {
+  int addEquippedOffset(int? offset) {
     fbBuilder.addOffset(9, offset);
     return fbBuilder.offset;
   }
-  int addPathOffset(int offset) {
+  int addPathOffset(int? offset) {
     fbBuilder.addOffset(10, offset);
     return fbBuilder.offset;
   }
@@ -265,28 +269,28 @@ class MonsterBuilder {
 }
 
 class MonsterObjectBuilder extends fb.ObjectBuilder {
-  final Vec3ObjectBuilder _pos;
-  final int _mana;
-  final int _hp;
-  final String _name;
-  final List<int> _inventory;
-  final Color _color;
-  final List<WeaponObjectBuilder> _weapons;
-  final EquipmentTypeId _equippedType;
+  final Vec3ObjectBuilder? _pos;
+  final int? _mana;
+  final int? _hp;
+  final String? _name;
+  final List<int>? _inventory;
+  final Color? _color;
+  final List<WeaponObjectBuilder>? _weapons;
+  final EquipmentTypeId? _equippedType;
   final dynamic _equipped;
-  final List<Vec3ObjectBuilder> _path;
+  final List<Vec3ObjectBuilder>? _path;
 
   MonsterObjectBuilder({
-    Vec3ObjectBuilder pos,
-    int mana,
-    int hp,
-    String name,
-    List<int> inventory,
-    Color color,
-    List<WeaponObjectBuilder> weapons,
-    EquipmentTypeId equippedType,
+    Vec3ObjectBuilder? pos,
+    int? mana,
+    int? hp,
+    String? name,
+    List<int>? inventory,
+    Color? color,
+    List<WeaponObjectBuilder>? weapons,
+    EquipmentTypeId? equippedType,
     dynamic equipped,
-    List<Vec3ObjectBuilder> path,
+    List<Vec3ObjectBuilder>? path,
   })
       : _pos = pos,
         _mana = mana,
@@ -301,69 +305,54 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
 
   /// Finish building, and store into the [fbBuilder].
   @override
-  int finish(
-    fb.Builder fbBuilder) {
-    assert(fbBuilder != null);
-    final int nameOffset = fbBuilder.writeString(_name);
-    final int inventoryOffset = _inventory?.isNotEmpty == true
-        ? fbBuilder.writeListUint8(_inventory)
-        : null;
-    final int weaponsOffset = _weapons?.isNotEmpty == true
-        ? fbBuilder.writeList(_weapons.map((b) => b.getOrCreateOffset(fbBuilder)).toList())
-        : null;
-    final int equippedOffset = _equipped?.getOrCreateOffset(fbBuilder);
-    final int pathOffset = _path?.isNotEmpty == true
-        ? fbBuilder.writeListOfStructs(_path)
-        : null;
-
-    fbBuilder.startTable();
+  int finish(fb.Builder fbBuilder) {
+    final int? nameOffset = _name == null ? null
+        : fbBuilder.writeString(_name!);
+    final int? inventoryOffset = _inventory == null ? null
+        : fbBuilder.writeListUint8(_inventory!);
+    final int? weaponsOffset = _weapons == null ? null
+        : fbBuilder.writeList(_weapons!.map((b) => b.getOrCreateOffset(fbBuilder)).toList());
+    final int? equippedOffset = _equipped?.getOrCreateOffset(fbBuilder);
+    final int? pathOffset = _path == null ? null
+        : fbBuilder.writeListOfStructs(_path!);
+    fbBuilder.startTable(10);
     if (_pos != null) {
-      fbBuilder.addStruct(0, _pos.finish(fbBuilder));
+      fbBuilder.addStruct(0, _pos!.finish(fbBuilder));
     }
     fbBuilder.addInt16(1, _mana);
     fbBuilder.addInt16(2, _hp);
-    if (nameOffset != null) {
-      fbBuilder.addOffset(3, nameOffset);
-    }
-    if (inventoryOffset != null) {
-      fbBuilder.addOffset(5, inventoryOffset);
-    }
+    fbBuilder.addOffset(3, nameOffset);
+    fbBuilder.addOffset(5, inventoryOffset);
     fbBuilder.addInt8(6, _color?.value);
-    if (weaponsOffset != null) {
-      fbBuilder.addOffset(7, weaponsOffset);
-    }
+    fbBuilder.addOffset(7, weaponsOffset);
     fbBuilder.addUint8(8, _equippedType?.value);
-    if (equippedOffset != null) {
-      fbBuilder.addOffset(9, equippedOffset);
-    }
-    if (pathOffset != null) {
-      fbBuilder.addOffset(10, pathOffset);
-    }
+    fbBuilder.addOffset(9, equippedOffset);
+    fbBuilder.addOffset(10, pathOffset);
     return fbBuilder.endTable();
   }
 
   /// Convenience method to serialize to byte list.
   @override
-  Uint8List toBytes([String fileIdentifier]) {
-    fb.Builder fbBuilder = new fb.Builder();
-    int offset = finish(fbBuilder);
-    return fbBuilder.finish(offset, fileIdentifier);
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
   }
 }
 class Weapon {
   Weapon._(this._bc, this._bcOffset);
   factory Weapon(List<int> bytes) {
-    fb.BufferContext rootRef = new fb.BufferContext.fromBytes(bytes);
+    final rootRef = fb.BufferContext.fromBytes(bytes);
     return reader.read(rootRef, 0);
   }
 
-  static const fb.Reader<Weapon> reader = const _WeaponReader();
+  static const fb.Reader<Weapon> reader = _WeaponReader();
 
   final fb.BufferContext _bc;
   final int _bcOffset;
 
-  String get name => const fb.StringReader().vTableGet(_bc, _bcOffset, 4, null);
-  int get damage => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 6, null);
+  String? get name => const fb.StringReader().vTableGetNullable(_bc, _bcOffset, 4);
+  int get damage => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 6, 0);
 
   @override
   String toString() {
@@ -376,25 +365,23 @@ class _WeaponReader extends fb.TableReader<Weapon> {
 
   @override
   Weapon createObject(fb.BufferContext bc, int offset) => 
-    new Weapon._(bc, offset);
+    Weapon._(bc, offset);
 }
 
 class WeaponBuilder {
-  WeaponBuilder(this.fbBuilder) {
-    assert(fbBuilder != null);
-  }
+  WeaponBuilder(this.fbBuilder);
 
   final fb.Builder fbBuilder;
 
   void begin() {
-    fbBuilder.startTable();
+    fbBuilder.startTable(2);
   }
 
-  int addNameOffset(int offset) {
+  int addNameOffset(int? offset) {
     fbBuilder.addOffset(0, offset);
     return fbBuilder.offset;
   }
-  int addDamage(int damage) {
+  int addDamage(int? damage) {
     fbBuilder.addInt16(1, damage);
     return fbBuilder.offset;
   }
@@ -405,36 +392,32 @@ class WeaponBuilder {
 }
 
 class WeaponObjectBuilder extends fb.ObjectBuilder {
-  final String _name;
-  final int _damage;
+  final String? _name;
+  final int? _damage;
 
   WeaponObjectBuilder({
-    String name,
-    int damage,
+    String? name,
+    int? damage,
   })
       : _name = name,
         _damage = damage;
 
   /// Finish building, and store into the [fbBuilder].
   @override
-  int finish(
-    fb.Builder fbBuilder) {
-    assert(fbBuilder != null);
-    final int nameOffset = fbBuilder.writeString(_name);
-
-    fbBuilder.startTable();
-    if (nameOffset != null) {
-      fbBuilder.addOffset(0, nameOffset);
-    }
+  int finish(fb.Builder fbBuilder) {
+    final int? nameOffset = _name == null ? null
+        : fbBuilder.writeString(_name!);
+    fbBuilder.startTable(2);
+    fbBuilder.addOffset(0, nameOffset);
     fbBuilder.addInt16(1, _damage);
     return fbBuilder.endTable();
   }
 
   /// Convenience method to serialize to byte list.
   @override
-  Uint8List toBytes([String fileIdentifier]) {
-    fb.Builder fbBuilder = new fb.Builder();
-    int offset = finish(fbBuilder);
-    return fbBuilder.finish(offset, fileIdentifier);
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
   }
 }

dart/lib/flex_buffers.dart

@@ -0,0 +1,2 @@
+export 'src/builder.dart';
+export 'src/reference.dart';

dart/lib/src/builder.dart

@@ -0,0 +1,676 @@
+import 'dart:convert';
+import 'dart:typed_data';
+
+import 'types.dart';
+
+/// The main builder class for creation of a FlexBuffer.
+class Builder {
+  final ByteData _buffer;
+  List<_StackValue> _stack = [];
+  List<_StackPointer> _stackPointers = [];
+  int _offset = 0;
+  bool _finished = false;
+  final Map<String, _StackValue> _stringCache = {};
+  final Map<String, _StackValue> _keyCache = {};
+  final Map<_KeysHash, _StackValue> _keyVectorCache = {};
+  final Map<int, _StackValue> _indirectIntCache = {};
+  final Map<double, _StackValue> _indirectDoubleCache = {};
+
+  /// Instantiate the builder if you intent to gradually build up the buffer by calling
+  /// add... methods and calling [finish] to receive the the resulting byte array.
+  ///
+  /// The default size of internal buffer is set to 2048. Provide a different value in order to avoid buffer copies.
+  Builder({int size = 2048}) : _buffer = ByteData(size);
+
+  /// Use this method in order to turn an object into a FlexBuffer directly.
+  ///
+  /// Use the manual instantiation of the [Builder] and gradual addition of values, if performance is more important than convenience.
+  static ByteBuffer buildFromObject(Object? value) {
+    final builder = Builder();
+    builder._add(value);
+    final buffer = builder.finish();
+    final byteData = ByteData(buffer.lengthInBytes);
+    byteData.buffer.asUint8List().setAll(0, buffer);
+    return byteData.buffer;
+  }
+
+  void _add(Object? value) {
+    if (value == null) {
+      addNull();
+    } else if (value is bool) {
+      addBool(value);
+    } else if (value is int) {
+      addInt(value);
+    } else if (value is double) {
+      addDouble(value);
+    } else if (value is ByteBuffer) {
+      addBlob(value);
+    } else if (value is String) {
+      addString(value);
+    } else if (value is List<dynamic>) {
+      startVector();
+      for (var i = 0; i < value.length; i++) {
+        _add(value[i]);
+      }
+      end();
+    } else if (value is Map<String, dynamic>) {
+      startMap();
+      value.forEach((key, value) {
+        addKey(key);
+        _add(value);
+      });
+      end();
+    } else {
+      throw UnsupportedError('Value of unexpected type: $value');
+    }
+  }
+
+  /// Use this method if you want to store a null value.
+  ///
+  /// Specifically useful when building up a vector where values can be null.
+  void addNull() {
+    _integrityCheckOnValueAddition();
+    _stack.add(_StackValue.withNull());
+  }
+
+  /// Adds a string value.
+  void addInt(int value) {
+    _integrityCheckOnValueAddition();
+    _stack.add(_StackValue.withInt(value));
+  }
+
+  /// Adds a bool value.
+  void addBool(bool value) {
+    _integrityCheckOnValueAddition();
+    _stack.add(_StackValue.withBool(value));
+  }
+
+  /// Adds a double value.
+  void addDouble(double value) {
+    _integrityCheckOnValueAddition();
+    _stack.add(_StackValue.withDouble(value));
+  }
+
+  /// Adds a string value.
+  void addString(String value) {
+    _integrityCheckOnValueAddition();
+    if (_stringCache.containsKey(value)) {
+      _stack.add(_stringCache[value]!);
+      return;
+    }
+    final utf8String = utf8.encode(value);
+    final length = utf8String.length;
+    final bitWidth = BitWidthUtil.uwidth(length);
+    final byteWidth = _align(bitWidth);
+    _writeUInt(length, byteWidth);
+    final stringOffset = _offset;
+    final newOffset = _newOffset(length + 1);
+    _pushBuffer(utf8String);
+    _offset = newOffset;
+    final stackValue =
+        _StackValue.withOffset(stringOffset, ValueType.String, bitWidth);
+    _stack.add(stackValue);
+    _stringCache[value] = stackValue;
+  }
+
+  /// This methods adds a key to a map and should be followed by an add... value call.
+  ///
+  /// It also implies that you call this method only after you called [startMap].
+  void addKey(String value) {
+    _integrityCheckOnKeyAddition();
+    if (_keyCache.containsKey(value)) {
+      _stack.add(_keyCache[value]!);
+      return;
+    }
+    final utf8String = utf8.encode(value);
+    final length = utf8String.length;
+    final keyOffset = _offset;
+    final newOffset = _newOffset(length + 1);
+    _pushBuffer(utf8String);
+    _offset = newOffset;
+    final stackValue =
+        _StackValue.withOffset(keyOffset, ValueType.Key, BitWidth.width8);
+    _stack.add(stackValue);
+    _keyCache[value] = stackValue;
+  }
+
+  /// Adds a byte array.
+  ///
+  /// This method can be used to store any generic BLOB.
+  void addBlob(ByteBuffer value) {
+    _integrityCheckOnValueAddition();
+    final length = value.lengthInBytes;
+    final bitWidth = BitWidthUtil.uwidth(length);
+    final byteWidth = _align(bitWidth);
+    _writeUInt(length, byteWidth);
+    final blobOffset = _offset;
+    final newOffset = _newOffset(length);
+    _pushBuffer(value.asUint8List());
+    _offset = newOffset;
+    final stackValue =
+        _StackValue.withOffset(blobOffset, ValueType.Blob, bitWidth);
+    _stack.add(stackValue);
+  }
+
+  /// Stores int value indirectly in the buffer.
+  ///
+  /// Adding large integer values indirectly might be beneficial if those values suppose to be store in a vector together with small integer values.
+  /// This is due to the fact that FlexBuffers will add padding to small integer values, if they are stored together with large integer values.
+  /// When we add integer indirectly the vector of ints will contain not the value itself, but only the relative offset to the value.
+  /// By setting the [cache] parameter to true, you make sure that the builder tracks added int value and performs deduplication.
+  void addIntIndirectly(int value, {bool cache = false}) {
+    _integrityCheckOnValueAddition();
+    if (_indirectIntCache.containsKey(value)) {
+      _stack.add(_indirectIntCache[value]!);
+      return;
+    }
+    final stackValue = _StackValue.withInt(value);
+    final byteWidth = _align(stackValue.width);
+    final newOffset = _newOffset(byteWidth);
+    final valueOffset = _offset;
+    _pushBuffer(stackValue.asU8List(stackValue.width));
+    final stackOffset = _StackValue.withOffset(
+        valueOffset, ValueType.IndirectInt, stackValue.width);
+    _stack.add(stackOffset);
+    _offset = newOffset;
+    if (cache) {
+      _indirectIntCache[value] = stackOffset;
+    }
+  }
+
+  /// Stores double value indirectly in the buffer.
+  ///
+  /// Double are stored as 8 or 4 byte values in FlexBuffers. If they are stored in a mixed vector, values which are smaller than 4 / 8 bytes will be padded.
+  /// When we add double indirectly, the vector will contain not the value itself, but only the relative offset to the value. Which could occupy only 1 or 2 bytes, reducing the odds for unnecessary padding.
+  /// By setting the [cache] parameter to true, you make sure that the builder tracks already added double value and performs deduplication.
+  void addDoubleIndirectly(double value, {bool cache = false}) {
+    _integrityCheckOnValueAddition();
+    if (cache && _indirectDoubleCache.containsKey(value)) {
+      _stack.add(_indirectDoubleCache[value]!);
+      return;
+    }
+    final stackValue = _StackValue.withDouble(value);
+    final byteWidth = _align(stackValue.width);
+    final newOffset = _newOffset(byteWidth);
+    final valueOffset = _offset;
+    _pushBuffer(stackValue.asU8List(stackValue.width));
+    final stackOffset = _StackValue.withOffset(
+        valueOffset, ValueType.IndirectFloat, stackValue.width);
+    _stack.add(stackOffset);
+    _offset = newOffset;
+    if (cache) {
+      _indirectDoubleCache[value] = stackOffset;
+    }
+  }
+
+  /// This method starts a vector definition and needs to be followed by 0 to n add... value calls.
+  ///
+  /// The vector definition needs to be finished with an [end] call.
+  /// It is also possible to add nested vector or map by calling [startVector] / [startMap].
+  void startVector() {
+    _integrityCheckOnValueAddition();
+    _stackPointers.add(_StackPointer(_stack.length, true));
+  }
+
+  /// This method starts a map definition.
+  ///
+  /// This method call needs to be followed by 0 to n [addKey] +  add... value calls.
+  /// The map definition needs to be finished with an [end] call.
+  /// It is also possible to add nested vector or map by calling [startVector] / [startMap] after calling [addKey].
+  void startMap() {
+    _integrityCheckOnValueAddition();
+    _stackPointers.add(_StackPointer(_stack.length, false));
+  }
+
+  /// Marks that the addition of values to the last vector, or map have ended.
+  void end() {
+    final pointer = _stackPointers.removeLast();
+    if (pointer.isVector) {
+      _endVector(pointer);
+    } else {
+      _sortKeysAndEndMap(pointer);
+    }
+  }
+
+  /// Finish building the FlatBuffer and return array of bytes.
+  ///
+  /// Can be called multiple times, to get the array of bytes.
+  /// After the first call, adding values, or starting vectors / maps will result in an exception.
+  Uint8List finish() {
+    if (_finished == false) {
+      _finish();
+    }
+    return _buffer.buffer.asUint8List(0, _offset);
+  }
+
+  /// Builds a FlatBuffer with current state without finishing the builder.
+  ///
+  /// Creates an internal temporary copy of current builder and finishes the copy.
+  /// Use this method, when the state of a long lasting builder need to be persisted periodically.
+  ByteBuffer snapshot() {
+    final tmp = Builder(size: _offset + 200);
+    tmp._offset = _offset;
+    tmp._stack = List.from(_stack);
+    tmp._stackPointers = List.from(_stackPointers);
+    tmp._buffer.buffer
+        .asUint8List()
+        .setAll(0, _buffer.buffer.asUint8List(0, _offset));
+    for (var i = 0; i < tmp._stackPointers.length; i++) {
+      tmp.end();
+    }
+    final buffer = tmp.finish();
+    final bd = ByteData(buffer.lengthInBytes);
+    bd.buffer.asUint8List().setAll(0, buffer);
+    return bd.buffer;
+  }
+
+  void _integrityCheckOnValueAddition() {
+    if (_finished) {
+      throw StateError('Adding values after finish is prohibited');
+    }
+    if (_stackPointers.isNotEmpty && _stackPointers.last.isVector == false) {
+      if (_stack.last.type != ValueType.Key) {
+        throw StateError(
+            'Adding value to a map before adding a key is prohibited');
+      }
+    }
+  }
+
+  void _integrityCheckOnKeyAddition() {
+    if (_finished) {
+      throw StateError('Adding values after finish is prohibited');
+    }
+    if (_stackPointers.isEmpty || _stackPointers.last.isVector) {
+      throw StateError('Adding key before staring a map is prohibited');
+    }
+  }
+
+  void _finish() {
+    if (_stack.length != 1) {
+      throw StateError(
+          'Stack has to be exactly 1, but is ${_stack.length}. You have to end all started vectors and maps, before calling [finish]');
+    }
+    final value = _stack[0];
+    final byteWidth = _align(value.elementWidth(_offset, 0));
+    _writeStackValue(value, byteWidth);
+    _writeUInt(value.storedPackedType(), 1);
+    _writeUInt(byteWidth, 1);
+    _finished = true;
+  }
+
+  _StackValue _createVector(int start, int vecLength, int step,
+      [_StackValue? keys]) {
+    var bitWidth = BitWidthUtil.uwidth(vecLength);
+    var prefixElements = 1;
+    if (keys != null) {
+      var elemWidth = keys.elementWidth(_offset, 0);
+      if (elemWidth.index > bitWidth.index) {
+        bitWidth = elemWidth;
+      }
+      prefixElements += 2;
+    }
+    var vectorType = ValueType.Key;
+    var typed = keys == null;
+    for (var i = start; i < _stack.length; i += step) {
+      final elemWidth = _stack[i].elementWidth(_offset, i + prefixElements);
+      if (elemWidth.index > bitWidth.index) {
+        bitWidth = elemWidth;
+      }
+      if (i == start) {
+        vectorType = _stack[i].type;
+        typed &= ValueTypeUtils.isTypedVectorElement(vectorType);
+      } else {
+        if (vectorType != _stack[i].type) {
+          typed = false;
+        }
+      }
+    }
+    final byteWidth = _align(bitWidth);
+    final fix = typed & ValueTypeUtils.isNumber(vectorType) &&
+        vecLength >= 2 &&
+        vecLength <= 4;
+    if (keys != null) {
+      _writeStackValue(keys, byteWidth);
+      _writeUInt(1 << keys.width.index, byteWidth);
+    }
+    if (fix == false) {
+      _writeUInt(vecLength, byteWidth);
+    }
+    final vecOffset = _offset;
+    for (var i = start; i < _stack.length; i += step) {
+      _writeStackValue(_stack[i], byteWidth);
+    }
+    if (typed == false) {
+      for (var i = start; i < _stack.length; i += step) {
+        _writeUInt(_stack[i].storedPackedType(), 1);
+      }
+    }
+    if (keys != null) {
+      return _StackValue.withOffset(vecOffset, ValueType.Map, bitWidth);
+    }
+    if (typed) {
+      final vType =
+          ValueTypeUtils.toTypedVector(vectorType, fix ? vecLength : 0);
+      return _StackValue.withOffset(vecOffset, vType, bitWidth);
+    }
+    return _StackValue.withOffset(vecOffset, ValueType.Vector, bitWidth);
+  }
+
+  void _endVector(_StackPointer pointer) {
+    final vecLength = _stack.length - pointer.stackPosition;
+    final vec = _createVector(pointer.stackPosition, vecLength, 1);
+    _stack.removeRange(pointer.stackPosition, _stack.length);
+    _stack.add(vec);
+  }
+
+  void _sortKeysAndEndMap(_StackPointer pointer) {
+    if (((_stack.length - pointer.stackPosition) & 1) == 1) {
+      throw StateError(
+          'The stack needs to hold key value pairs (even number of elements). Check if you combined [addKey] with add... method calls properly.');
+    }
+
+    var sorted = true;
+    for (var i = pointer.stackPosition; i < _stack.length - 2; i += 2) {
+      if (_shouldFlip(_stack[i], _stack[i + 2])) {
+        sorted = false;
+        break;
+      }
+    }
+
+    if (sorted == false) {
+      for (var i = pointer.stackPosition; i < _stack.length; i += 2) {
+        var flipIndex = i;
+        for (var j = i + 2; j < _stack.length; j += 2) {
+          if (_shouldFlip(_stack[flipIndex], _stack[j])) {
+            flipIndex = j;
+          }
+        }
+        if (flipIndex != i) {
+          var k = _stack[flipIndex];
+          var v = _stack[flipIndex + 1];
+          _stack[flipIndex] = _stack[i];
+          _stack[flipIndex + 1] = _stack[i + 1];
+          _stack[i] = k;
+          _stack[i + 1] = v;
+        }
+      }
+    }
+    _endMap(pointer);
+  }
+
+  void _endMap(_StackPointer pointer) {
+    final vecLength = (_stack.length - pointer.stackPosition) >> 1;
+    final offsets = <int>[];
+    for (var i = pointer.stackPosition; i < _stack.length; i += 2) {
+      offsets.add(_stack[i].offset!);
+    }
+    final keysHash = _KeysHash(offsets);
+    _StackValue? keysStackValue;
+    if (_keyVectorCache.containsKey(keysHash)) {
+      keysStackValue = _keyVectorCache[keysHash];
+    } else {
+      keysStackValue = _createVector(pointer.stackPosition, vecLength, 2);
+      _keyVectorCache[keysHash] = keysStackValue;
+    }
+    final vec =
+        _createVector(pointer.stackPosition + 1, vecLength, 2, keysStackValue);
+    _stack.removeRange(pointer.stackPosition, _stack.length);
+    _stack.add(vec);
+  }
+
+  bool _shouldFlip(_StackValue v1, _StackValue v2) {
+    if (v1.type != ValueType.Key || v2.type != ValueType.Key) {
+      throw StateError(
+          'Stack values are not keys $v1 | $v2. Check if you combined [addKey] with add... method calls properly.');
+    }
+
+    late int c1, c2;
+    var index = 0;
+    do {
+      c1 = _buffer.getUint8(v1.offset! + index);
+      c2 = _buffer.getUint8(v2.offset! + index);
+      if (c2 < c1) return true;
+      if (c1 < c2) return false;
+      index += 1;
+    } while (c1 != 0 && c2 != 0);
+    return false;
+  }
+
+  int _align(BitWidth width) {
+    final byteWidth = BitWidthUtil.toByteWidth(width);
+    _offset += BitWidthUtil.paddingSize(_offset, byteWidth);
+    return byteWidth;
+  }
+
+  void _writeStackValue(_StackValue value, int byteWidth) {
+    final newOffset = _newOffset(byteWidth);
+    if (value.isOffset) {
+      final relativeOffset = _offset - value.offset!;
+      if (byteWidth == 8 || relativeOffset < (1 << (byteWidth * 8))) {
+        _writeUInt(relativeOffset, byteWidth);
+      } else {
+        throw StateError(
+            'Unexpected size $byteWidth. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new');
+      }
+    } else {
+      _pushBuffer(value.asU8List(BitWidthUtil.fromByteWidth(byteWidth)));
+    }
+    _offset = newOffset;
+  }
+
+  void _writeUInt(int value, int byteWidth) {
+    final newOffset = _newOffset(byteWidth);
+    _pushUInt(value, BitWidthUtil.fromByteWidth(byteWidth));
+    _offset = newOffset;
+  }
+
+  int _newOffset(int newValueSize) {
+    final newOffset = _offset + newValueSize;
+    var size = _buffer.lengthInBytes;
+    final prevSize = size;
+    while (size < newOffset) {
+      size <<= 1;
+    }
+    if (prevSize < size) {
+      final newBuf = ByteData(size);
+      newBuf.buffer.asUint8List().setAll(0, _buffer.buffer.asUint8List());
+    }
+    return newOffset;
+  }
+
+  void _pushInt(int value, BitWidth width) {
+    switch (width) {
+      case BitWidth.width8:
+        _buffer.setInt8(_offset, value);
+        break;
+      case BitWidth.width16:
+        _buffer.setInt16(_offset, value, Endian.little);
+        break;
+      case BitWidth.width32:
+        _buffer.setInt32(_offset, value, Endian.little);
+        break;
+      case BitWidth.width64:
+        _buffer.setInt64(_offset, value, Endian.little);
+        break;
+    }
+  }
+
+  void _pushUInt(int value, BitWidth width) {
+    switch (width) {
+      case BitWidth.width8:
+        _buffer.setUint8(_offset, value);
+        break;
+      case BitWidth.width16:
+        _buffer.setUint16(_offset, value, Endian.little);
+        break;
+      case BitWidth.width32:
+        _buffer.setUint32(_offset, value, Endian.little);
+        break;
+      case BitWidth.width64:
+        _buffer.setUint64(_offset, value, Endian.little);
+        break;
+    }
+  }
+
+  void _pushBuffer(List<int> value) {
+    _buffer.buffer.asUint8List().setAll(_offset, value);
+  }
+}
+
+class _StackValue {
+  late Object _value;
+  int? _offset;
+  final ValueType _type;
+  final BitWidth _width;
+
+  _StackValue.withNull()
+      : _type = ValueType.Null,
+        _width = BitWidth.width8;
+
+  _StackValue.withInt(int value)
+      : _type = ValueType.Int,
+        _width = BitWidthUtil.width(value),
+        _value = value;
+
+  _StackValue.withBool(bool value)
+      : _type = ValueType.Bool,
+        _width = BitWidth.width8,
+        _value = value;
+
+  _StackValue.withDouble(double value)
+      : _type = ValueType.Float,
+        _width = BitWidthUtil.width(value),
+        _value = value;
+
+  _StackValue.withOffset(int value, ValueType type, BitWidth width)
+      : _offset = value,
+        _type = type,
+        _width = width;
+
+  BitWidth storedWidth({BitWidth width = BitWidth.width8}) {
+    return ValueTypeUtils.isInline(_type)
+        ? BitWidthUtil.max(_width, width)
+        : _width;
+  }
+
+  int storedPackedType({BitWidth width = BitWidth.width8}) {
+    return ValueTypeUtils.packedType(_type, storedWidth(width: width));
+  }
+
+  BitWidth elementWidth(int size, int index) {
+    if (ValueTypeUtils.isInline(_type)) return _width;
+    final offset = _offset!;
+    for (var i = 0; i < 4; i++) {
+      final width = 1 << i;
+      final bitWidth = BitWidthUtil.uwidth(size +
+          BitWidthUtil.paddingSize(size, width) +
+          index * width -
+          offset);
+      if (1 << bitWidth.index == width) {
+        return bitWidth;
+      }
+    }
+    throw StateError(
+        'Element is of unknown. Size: $size at index: $index. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new');
+  }
+
+  List<int> asU8List(BitWidth width) {
+    if (ValueTypeUtils.isNumber(_type)) {
+      if (_type == ValueType.Float) {
+        if (width == BitWidth.width32) {
+          final result = ByteData(4);
+          result.setFloat32(0, _value as double, Endian.little);
+          return result.buffer.asUint8List();
+        } else {
+          final result = ByteData(8);
+          result.setFloat64(0, _value as double, Endian.little);
+          return result.buffer.asUint8List();
+        }
+      } else {
+        switch (width) {
+          case BitWidth.width8:
+            final result = ByteData(1);
+            result.setInt8(0, _value as int);
+            return result.buffer.asUint8List();
+          case BitWidth.width16:
+            final result = ByteData(2);
+            result.setInt16(0, _value as int, Endian.little);
+            return result.buffer.asUint8List();
+          case BitWidth.width32:
+            final result = ByteData(4);
+            result.setInt32(0, _value as int, Endian.little);
+            return result.buffer.asUint8List();
+          case BitWidth.width64:
+            final result = ByteData(8);
+            result.setInt64(0, _value as int, Endian.little);
+            return result.buffer.asUint8List();
+        }
+      }
+    }
+    if (_type == ValueType.Null) {
+      final result = ByteData(1);
+      result.setInt8(0, 0);
+      return result.buffer.asUint8List();
+    }
+    if (_type == ValueType.Bool) {
+      final result = ByteData(1);
+      result.setInt8(0, _value as bool ? 1 : 0);
+      return result.buffer.asUint8List();
+    }
+
+    throw StateError(
+        'Unexpected type: $_type. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new');
+  }
+
+  ValueType get type {
+    return _type;
+  }
+
+  BitWidth get width {
+    return _width;
+  }
+
+  bool get isOffset {
+    return !ValueTypeUtils.isInline(_type);
+  }
+
+  int? get offset => _offset;
+
+  bool get isFloat32 {
+    return _type == ValueType.Float && _width == BitWidth.width32;
+  }
+}
+
+class _StackPointer {
+  int stackPosition;
+  bool isVector;
+
+  _StackPointer(this.stackPosition, this.isVector);
+}
+
+class _KeysHash {
+  final List<int> keys;
+
+  const _KeysHash(this.keys);
+
+  @override
+  bool operator ==(Object other) {
+    if (other is _KeysHash) {
+      if (keys.length != other.keys.length) return false;
+      for (var i = 0; i < keys.length; i++) {
+        if (keys[i] != other.keys[i]) return false;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    var result = 17;
+    for (var i = 0; i < keys.length; i++) {
+      result = result * 23 + keys[i];
+    }
+    return result;
+  }
+}

dart/lib/src/reference.dart

@@ -0,0 +1,481 @@
+import 'dart:collection';
+import 'dart:convert';
+import 'dart:typed_data';
+import 'types.dart';
+
+/// Main class to read a value out of a FlexBuffer.
+///
+/// This class let you access values stored in the buffer in a lazy fashion.
+class Reference {
+  final ByteData _buffer;
+  final int _offset;
+  final BitWidth _parentWidth;
+  final String _path;
+  final int _byteWidth;
+  final ValueType _valueType;
+  int? _length;
+
+  Reference._(
+      this._buffer, this._offset, this._parentWidth, int packedType, this._path,
+      [int? byteWidth, ValueType? valueType])
+      : _byteWidth = byteWidth ?? 1 << (packedType & 3),
+        _valueType = valueType ?? ValueTypeUtils.fromInt(packedType >> 2);
+
+  /// Use this method to access the root value of a FlexBuffer.
+  static Reference fromBuffer(ByteBuffer buffer) {
+    final len = buffer.lengthInBytes;
+    if (len < 3) {
+      throw UnsupportedError('Buffer needs to be bigger than 3');
+    }
+    final byteData = ByteData.view(buffer);
+    final byteWidth = byteData.getUint8(len - 1);
+    final packedType = byteData.getUint8(len - 2);
+    final offset = len - byteWidth - 2;
+    return Reference._(ByteData.view(buffer), offset,
+        BitWidthUtil.fromByteWidth(byteWidth), packedType, "/");
+  }
+
+  /// Returns true if the underlying value is null.
+  bool get isNull => _valueType == ValueType.Null;
+
+  /// Returns true if the underlying value can be represented as [num].
+  bool get isNum =>
+      ValueTypeUtils.isNumber(_valueType) ||
+      ValueTypeUtils.isIndirectNumber(_valueType);
+
+  /// Returns true if the underlying value was encoded as a float (direct or indirect).
+  bool get isDouble =>
+      _valueType == ValueType.Float || _valueType == ValueType.IndirectFloat;
+
+  /// Returns true if the underlying value was encoded as an int or uint (direct or indirect).
+  bool get isInt => isNum && !isDouble;
+
+  /// Returns true if the underlying value was encoded as a string or a key.
+  bool get isString =>
+      _valueType == ValueType.String || _valueType == ValueType.Key;
+
+  /// Returns true if the underlying value was encoded as a bool.
+  bool get isBool => _valueType == ValueType.Bool;
+
+  /// Returns true if the underlying value was encoded as a blob.
+  bool get isBlob => _valueType == ValueType.Blob;
+
+  /// Returns true if the underlying value points to a vector.
+  bool get isVector => ValueTypeUtils.isAVector(_valueType);
+
+  /// Returns true if the underlying value points to a map.
+  bool get isMap => _valueType == ValueType.Map;
+
+  /// If this [isBool], returns the bool value. Otherwise, returns null.
+  bool? get boolValue {
+    if (_valueType == ValueType.Bool) {
+      return _readInt(_offset, _parentWidth) != 0;
+    }
+    return null;
+  }
+
+  /// Returns an [int], if the underlying value can be represented as an int.
+  ///
+  /// Otherwise returns [null].
+  int? get intValue {
+    if (_valueType == ValueType.Int) {
+      return _readInt(_offset, _parentWidth);
+    }
+    if (_valueType == ValueType.UInt) {
+      return _readUInt(_offset, _parentWidth);
+    }
+    if (_valueType == ValueType.IndirectInt) {
+      return _readInt(_indirect, BitWidthUtil.fromByteWidth(_byteWidth));
+    }
+    if (_valueType == ValueType.IndirectUInt) {
+      return _readUInt(_indirect, BitWidthUtil.fromByteWidth(_byteWidth));
+    }
+    return null;
+  }
+
+  /// Returns [double], if the underlying value [isDouble].
+  ///
+  /// Otherwise returns [null].
+  double? get doubleValue {
+    if (_valueType == ValueType.Float) {
+      return _readFloat(_offset, _parentWidth);
+    }
+    if (_valueType == ValueType.IndirectFloat) {
+      return _readFloat(_indirect, BitWidthUtil.fromByteWidth(_byteWidth));
+    }
+    return null;
+  }
+
+  /// Returns [num], if the underlying value is numeric, be it int uint, or float (direct or indirect).
+  ///
+  /// Otherwise returns [null].
+  num? get numValue => doubleValue ?? intValue;
+
+  /// Returns [String] value or null otherwise.
+  ///
+  /// This method performers a utf8 decoding, as FlexBuffers format stores strings in utf8 encoding.
+  String? get stringValue {
+    if (_valueType == ValueType.String || _valueType == ValueType.Key) {
+      return utf8.decode(_buffer.buffer.asUint8List(_indirect, length));
+    }
+    return null;
+  }
+
+  /// Returns [Uint8List] value or null otherwise.
+  Uint8List? get blobValue {
+    if (_valueType == ValueType.Blob) {
+      return _buffer.buffer.asUint8List(_indirect, length);
+    }
+    return null;
+  }
+
+  /// Can be used with an [int] or a [String] value for key.
+  /// If the underlying value in FlexBuffer is a vector, then use [int] for access.
+  /// If the underlying value in FlexBuffer is a map, then use [String] for access.
+  /// Returns [Reference] value. Throws an exception when [key] is not applicable.
+  Reference operator [](Object key) {
+    if (key is int && ValueTypeUtils.isAVector(_valueType)) {
+      final index = key;
+      if (index >= length || index < 0) {
+        throw ArgumentError(
+            'Key: [$key] is not applicable on: $_path of: $_valueType length: $length');
+      }
+      final elementOffset = _indirect + index * _byteWidth;
+      int packedType = 0;
+      int? byteWidth;
+      ValueType? valueType;
+      if (ValueTypeUtils.isTypedVector(_valueType)) {
+        byteWidth = 1;
+        valueType = ValueTypeUtils.typedVectorElementType(_valueType);
+      } else if (ValueTypeUtils.isFixedTypedVector(_valueType)) {
+        byteWidth = 1;
+        valueType = ValueTypeUtils.fixedTypedVectorElementType(_valueType);
+      } else {
+        packedType = _buffer.getUint8(_indirect + length * _byteWidth + index);
+      }
+      return Reference._(
+          _buffer,
+          elementOffset,
+          BitWidthUtil.fromByteWidth(_byteWidth),
+          packedType,
+          "$_path[$index]",
+          byteWidth,
+          valueType);
+    }
+    if (key is String && _valueType == ValueType.Map) {
+      final index = _keyIndex(key);
+      if (index != null) {
+        return _valueForIndexWithKey(index, key);
+      }
+    }
+    throw ArgumentError(
+        'Key: [$key] is not applicable on: $_path of: $_valueType');
+  }
+
+  /// Get an iterable if the underlying flexBuffer value is a vector.
+  /// Otherwise throws an exception.
+  Iterable<Reference> get vectorIterable {
+    if (isVector == false) {
+      throw UnsupportedError('Value is not a vector. It is: $_valueType');
+    }
+    return _VectorIterator(this);
+  }
+
+  /// Get an iterable for keys if the underlying flexBuffer value is a map.
+  /// Otherwise throws an exception.
+  Iterable<String> get mapKeyIterable {
+    if (isMap == false) {
+      throw UnsupportedError('Value is not a map. It is: $_valueType');
+    }
+    return _MapKeyIterator(this);
+  }
+
+  /// Get an iterable for values if the underlying flexBuffer value is a map.
+  /// Otherwise throws an exception.
+  Iterable<Reference> get mapValueIterable {
+    if (isMap == false) {
+      throw UnsupportedError('Value is not a map. It is: $_valueType');
+    }
+    return _MapValueIterator(this);
+  }
+
+  /// Returns the length of the the underlying FlexBuffer value.
+  /// If the underlying value is [null] the length is 0.
+  /// If the underlying value is a number, or a bool, the length is 1.
+  /// If the underlying value is a vector, or map, the length reflects number of elements / element pairs.
+  /// If the values is a string or a blob, the length reflects a number of bytes the value occupies (strings are encoded in utf8 format).
+  int get length {
+    if (_length == null) {
+      // needs to be checked before more generic isAVector
+      if (ValueTypeUtils.isFixedTypedVector(_valueType)) {
+        _length = ValueTypeUtils.fixedTypedVectorElementSize(_valueType);
+      } else if (_valueType == ValueType.Blob ||
+          ValueTypeUtils.isAVector(_valueType) ||
+          _valueType == ValueType.Map) {
+        _length = _readUInt(
+            _indirect - _byteWidth, BitWidthUtil.fromByteWidth(_byteWidth));
+      } else if (_valueType == ValueType.Null) {
+        _length = 0;
+      } else if (_valueType == ValueType.String) {
+        final indirect = _indirect;
+        var sizeByteWidth = _byteWidth;
+        var size = _readUInt(indirect - sizeByteWidth,
+            BitWidthUtil.fromByteWidth(sizeByteWidth));
+        while (_buffer.getInt8(indirect + size) != 0) {
+          sizeByteWidth <<= 1;
+          size = _readUInt(indirect - sizeByteWidth,
+              BitWidthUtil.fromByteWidth(sizeByteWidth));
+        }
+        _length = size;
+      } else if (_valueType == ValueType.Key) {
+        final indirect = _indirect;
+        var size = 1;
+        while (_buffer.getInt8(indirect + size) != 0) {
+          size += 1;
+        }
+        _length = size;
+      } else {
+        _length = 1;
+      }
+    }
+    return _length!;
+  }
+
+  /// Returns a minified JSON representation of the underlying FlexBuffer value.
+  ///
+  /// This method involves materializing the entire object tree, which may be
+  /// expensive. It is more efficient to work with [Reference] and access only the needed data.
+  /// Blob values are represented as base64 encoded string.
+  String get json {
+    if (_valueType == ValueType.Bool) {
+      return boolValue! ? 'true' : 'false';
+    }
+    if (_valueType == ValueType.Null) {
+      return 'null';
+    }
+    if (ValueTypeUtils.isNumber(_valueType)) {
+      return jsonEncode(numValue);
+    }
+    if (_valueType == ValueType.String) {
+      return jsonEncode(stringValue);
+    }
+    if (_valueType == ValueType.Blob) {
+      return jsonEncode(base64Encode(blobValue!));
+    }
+    if (ValueTypeUtils.isAVector(_valueType)) {
+      final result = StringBuffer();
+      result.write('[');
+      for (var i = 0; i < length; i++) {
+        result.write(this[i].json);
+        if (i < length - 1) {
+          result.write(',');
+        }
+      }
+      result.write(']');
+      return result.toString();
+    }
+    if (_valueType == ValueType.Map) {
+      final result = StringBuffer();
+      result.write('{');
+      for (var i = 0; i < length; i++) {
+        result.write(jsonEncode(_keyForIndex(i)));
+        result.write(':');
+        result.write(_valueForIndex(i).json);
+        if (i < length - 1) {
+          result.write(',');
+        }
+      }
+      result.write('}');
+      return result.toString();
+    }
+    throw UnsupportedError(
+        'Type: $_valueType is not supported for JSON conversion');
+  }
+
+  /// Computes the indirect offset of the value.
+  ///
+  /// To optimize for the more common case of being called only once, this
+  /// value is not cached. Callers that need to use it more than once should
+  /// cache the return value in a local variable.
+  int get _indirect {
+    final step = _readUInt(_offset, _parentWidth);
+    return _offset - step;
+  }
+
+  int _readInt(int offset, BitWidth width) {
+    _validateOffset(offset, width);
+    if (width == BitWidth.width8) {
+      return _buffer.getInt8(offset);
+    }
+    if (width == BitWidth.width16) {
+      return _buffer.getInt16(offset, Endian.little);
+    }
+    if (width == BitWidth.width32) {
+      return _buffer.getInt32(offset, Endian.little);
+    }
+    return _buffer.getInt64(offset, Endian.little);
+  }
+
+  int _readUInt(int offset, BitWidth width) {
+    _validateOffset(offset, width);
+    if (width == BitWidth.width8) {
+      return _buffer.getUint8(offset);
+    }
+    if (width == BitWidth.width16) {
+      return _buffer.getUint16(offset, Endian.little);
+    }
+    if (width == BitWidth.width32) {
+      return _buffer.getUint32(offset, Endian.little);
+    }
+    return _buffer.getUint64(offset, Endian.little);
+  }
+
+  double _readFloat(int offset, BitWidth width) {
+    _validateOffset(offset, width);
+    if (width.index < BitWidth.width32.index) {
+      throw StateError('Bad width: $width');
+    }
+
+    if (width == BitWidth.width32) {
+      return _buffer.getFloat32(offset, Endian.little);
+    }
+
+    return _buffer.getFloat64(offset, Endian.little);
+  }
+
+  void _validateOffset(int offset, BitWidth width) {
+    if (_offset < 0 ||
+        _buffer.lengthInBytes <= offset + width.index ||
+        offset & (BitWidthUtil.toByteWidth(width) - 1) != 0) {
+      throw StateError('Bad offset: $offset, width: $width');
+    }
+  }
+
+  int? _keyIndex(String key) {
+    final input = utf8.encode(key);
+    final keysVectorOffset = _indirect - _byteWidth * 3;
+    final indirectOffset = keysVectorOffset -
+        _readUInt(keysVectorOffset, BitWidthUtil.fromByteWidth(_byteWidth));
+    final byteWidth = _readUInt(
+        keysVectorOffset + _byteWidth, BitWidthUtil.fromByteWidth(_byteWidth));
+    var low = 0;
+    var high = length - 1;
+    while (low <= high) {
+      final mid = (high + low) >> 1;
+      final dif = _diffKeys(input, mid, indirectOffset, byteWidth);
+      if (dif == 0) return mid;
+      if (dif < 0) {
+        high = mid - 1;
+      } else {
+        low = mid + 1;
+      }
+    }
+    return null;
+  }
+
+  int _diffKeys(List<int> input, int index, int indirectOffset, int byteWidth) {
+    final keyOffset = indirectOffset + index * byteWidth;
+    final keyIndirectOffset =
+        keyOffset - _readUInt(keyOffset, BitWidthUtil.fromByteWidth(byteWidth));
+    for (var i = 0; i < input.length; i++) {
+      final dif = input[i] - _buffer.getUint8(keyIndirectOffset + i);
+      if (dif != 0) {
+        return dif;
+      }
+    }
+    return (_buffer.getUint8(keyIndirectOffset + input.length) == 0) ? 0 : -1;
+  }
+
+  Reference _valueForIndexWithKey(int index, String key) {
+    final indirect = _indirect;
+    final elementOffset = indirect + index * _byteWidth;
+    final packedType = _buffer.getUint8(indirect + length * _byteWidth + index);
+    return Reference._(_buffer, elementOffset,
+        BitWidthUtil.fromByteWidth(_byteWidth), packedType, "$_path/$key");
+  }
+
+  Reference _valueForIndex(int index) {
+    final indirect = _indirect;
+    final elementOffset = indirect + index * _byteWidth;
+    final packedType = _buffer.getUint8(indirect + length * _byteWidth + index);
+    return Reference._(_buffer, elementOffset,
+        BitWidthUtil.fromByteWidth(_byteWidth), packedType, "$_path/[$index]");
+  }
+
+  String _keyForIndex(int index) {
+    final keysVectorOffset = _indirect - _byteWidth * 3;
+    final indirectOffset = keysVectorOffset -
+        _readUInt(keysVectorOffset, BitWidthUtil.fromByteWidth(_byteWidth));
+    final byteWidth = _readUInt(
+        keysVectorOffset + _byteWidth, BitWidthUtil.fromByteWidth(_byteWidth));
+    final keyOffset = indirectOffset + index * byteWidth;
+    final keyIndirectOffset =
+        keyOffset - _readUInt(keyOffset, BitWidthUtil.fromByteWidth(byteWidth));
+    var length = 0;
+    while (_buffer.getUint8(keyIndirectOffset + length) != 0) {
+      length += 1;
+    }
+    return utf8.decode(_buffer.buffer.asUint8List(keyIndirectOffset, length));
+  }
+}
+
+class _VectorIterator
+    with IterableMixin<Reference>
+    implements Iterator<Reference> {
+  final Reference _vector;
+  int index = -1;
+
+  _VectorIterator(this._vector);
+
+  @override
+  Reference get current => _vector[index];
+
+  @override
+  bool moveNext() {
+    index++;
+    return index < _vector.length;
+  }
+
+  @override
+  Iterator<Reference> get iterator => this;
+}
+
+class _MapKeyIterator with IterableMixin<String> implements Iterator<String> {
+  final Reference _map;
+  int index = -1;
+
+  _MapKeyIterator(this._map);
+
+  @override
+  String get current => _map._keyForIndex(index);
+
+  @override
+  bool moveNext() {
+    index++;
+    return index < _map.length;
+  }
+
+  @override
+  Iterator<String> get iterator => this;
+}
+
+class _MapValueIterator
+    with IterableMixin<Reference>
+    implements Iterator<Reference> {
+  final Reference _map;
+  int index = -1;
+
+  _MapValueIterator(this._map);
+
+  @override
+  Reference get current => _map._valueForIndex(index);
+
+  @override
+  bool moveNext() {
+    index++;
+    return index < _map.length;
+  }
+
+  @override
+  Iterator<Reference> get iterator => this;
+}

dart/lib/src/types.dart

@@ -0,0 +1,190 @@
+import 'dart:typed_data';
+
+/// Represents the number of bits a value occupies.
+enum BitWidth { width8, width16, width32, width64 }
+
+class BitWidthUtil {
+  static int toByteWidth(BitWidth self) {
+    return 1 << self.index;
+  }
+
+  static BitWidth width(num value) {
+    if (value.toInt() == value) {
+      var v = value.toInt().abs();
+      if (v >> 7 == 0) return BitWidth.width8;
+      if (v >> 15 == 0) return BitWidth.width16;
+      if (v >> 31 == 0) return BitWidth.width32;
+      return BitWidth.width64;
+    }
+    return value == _toF32(value as double)
+        ? BitWidth.width32
+        : BitWidth.width64;
+  }
+
+  static BitWidth uwidth(num value) {
+    if (value.toInt() == value) {
+      var v = value.toInt().abs();
+      if (v >> 8 == 0) return BitWidth.width8;
+      if (v >> 16 == 0) return BitWidth.width16;
+      if (v >> 32 == 0) return BitWidth.width32;
+      return BitWidth.width64;
+    }
+    return value == _toF32(value as double)
+        ? BitWidth.width32
+        : BitWidth.width64;
+  }
+
+  static BitWidth fromByteWidth(int value) {
+    if (value == 1) {
+      return BitWidth.width8;
+    }
+    if (value == 2) {
+      return BitWidth.width16;
+    }
+    if (value == 4) {
+      return BitWidth.width32;
+    }
+    if (value == 8) {
+      return BitWidth.width64;
+    }
+    throw Exception('Unexpected value $value');
+  }
+
+  static int paddingSize(int bufSize, int scalarSize) {
+    return (~bufSize + 1) & (scalarSize - 1);
+  }
+
+  static double _toF32(double value) {
+    var bdata = ByteData(4);
+    bdata.setFloat32(0, value);
+    return bdata.getFloat32(0);
+  }
+
+  static BitWidth max(BitWidth self, BitWidth other) {
+    if (self.index < other.index) {
+      return other;
+    }
+    return self;
+  }
+}
+
+/// Represents all internal FlexBuffer types.
+enum ValueType {
+  Null,
+  Int,
+  UInt,
+  Float,
+  Key,
+  String,
+  IndirectInt,
+  IndirectUInt,
+  IndirectFloat,
+  Map,
+  Vector,
+  VectorInt,
+  VectorUInt,
+  VectorFloat,
+  VectorKey,
+  @Deprecated(
+      'VectorString is deprecated due to a flaw in the binary format (https://github.com/google/flatbuffers/issues/5627)')
+  VectorString,
+  VectorInt2,
+  VectorUInt2,
+  VectorFloat2,
+  VectorInt3,
+  VectorUInt3,
+  VectorFloat3,
+  VectorInt4,
+  VectorUInt4,
+  VectorFloat4,
+  Blob,
+  Bool,
+  VectorBool
+}
+
+class ValueTypeUtils {
+  static int toInt(ValueType self) {
+    if (self == ValueType.VectorBool) return 36;
+    return self.index;
+  }
+
+  static ValueType fromInt(int value) {
+    if (value == 36) return ValueType.VectorBool;
+    return ValueType.values[value];
+  }
+
+  static bool isInline(ValueType self) {
+    return self == ValueType.Bool || toInt(self) <= toInt(ValueType.Float);
+  }
+
+  static bool isNumber(ValueType self) {
+    return toInt(self) >= toInt(ValueType.Int) &&
+        toInt(self) <= toInt(ValueType.Float);
+  }
+
+  static bool isIndirectNumber(ValueType self) {
+    return toInt(self) >= toInt(ValueType.IndirectInt) &&
+        toInt(self) <= toInt(ValueType.IndirectFloat);
+  }
+
+  static bool isTypedVectorElement(ValueType self) {
+    return self == ValueType.Bool ||
+        (toInt(self) >= toInt(ValueType.Int) &&
+            toInt(self) <= toInt(ValueType.String));
+  }
+
+  static bool isTypedVector(ValueType self) {
+    return self == ValueType.VectorBool ||
+        (toInt(self) >= toInt(ValueType.VectorInt) &&
+            toInt(self) <= toInt(ValueType.VectorString));
+  }
+
+  static bool isFixedTypedVector(ValueType self) {
+    return (toInt(self) >= toInt(ValueType.VectorInt2) &&
+        toInt(self) <= toInt(ValueType.VectorFloat4));
+  }
+
+  static bool isAVector(ValueType self) {
+    return (isTypedVector(self) ||
+        isFixedTypedVector(self) ||
+        self == ValueType.Vector);
+  }
+
+  static ValueType toTypedVector(ValueType self, int length) {
+    if (length == 0) {
+      return ValueTypeUtils.fromInt(
+          toInt(self) - toInt(ValueType.Int) + toInt(ValueType.VectorInt));
+    }
+    if (length == 2) {
+      return ValueTypeUtils.fromInt(
+          toInt(self) - toInt(ValueType.Int) + toInt(ValueType.VectorInt2));
+    }
+    if (length == 3) {
+      return ValueTypeUtils.fromInt(
+          toInt(self) - toInt(ValueType.Int) + toInt(ValueType.VectorInt3));
+    }
+    if (length == 4) {
+      return ValueTypeUtils.fromInt(
+          toInt(self) - toInt(ValueType.Int) + toInt(ValueType.VectorInt4));
+    }
+    throw Exception('unexpected length ' + length.toString());
+  }
+
+  static ValueType typedVectorElementType(ValueType self) {
+    return ValueTypeUtils.fromInt(
+        toInt(self) - toInt(ValueType.VectorInt) + toInt(ValueType.Int));
+  }
+
+  static ValueType fixedTypedVectorElementType(ValueType self) {
+    return ValueTypeUtils.fromInt(
+        (toInt(self) - toInt(ValueType.VectorInt2)) % 3 + toInt(ValueType.Int));
+  }
+
+  static int fixedTypedVectorElementSize(ValueType self) {
+    return (toInt(self) - toInt(ValueType.VectorInt2)) ~/ 3 + 2;
+  }
+
+  static int packedType(ValueType self, BitWidth bitWidth) {
+    return bitWidth.index | (toInt(self) << 2);
+  }
+}

dart/publish.sh

@@ -17,12 +17,20 @@
 # Note to pub consumers: this file is used to assist with publishing the
 # pub package from the flatbuffers repository and is not meant for general use.
 # As pub does not currently provide a way to exclude files, it is included here.
+set -e
 
-command -v pub >/dev/null 2>&1 || { echo >&2 "Require `pub` but it's not installed.  Aborting."; exit 1; }
+command -v dart >/dev/null 2>&1 || { echo >&2 "Require `dart` but it's not installed.  Aborting."; exit 1; }
 
-cp ../samples/monster.fbs example/
-cp ../tests/monster_test.fbs test/
-pub publish
+pushd ../tests
+./DartTest.sh
+popd
+
+pushd ../samples
+./dart_sample.sh
+popd
+
+dart pub publish
 
 rm example/monster.fbs
-rm test/monster_test.fbs
+rm test/*.fbs
+rm -rf test/sub

dart/pubspec.yaml

@@ -1,20 +1,15 @@
 name: flat_buffers
-version: 1.12.0
-description: >
-  FlatBuffers reading and writing library for Dart.  Use the flatc compiler to
-  generate Dart classes for a FlatBuffers schema, and this library to assist with
-  reading and writing the binary format.
-
-  Based on original work by Konstantin Scheglov and Paul Berry of the Dart SDK team.
-authors:
-- Dan Field <dfield@gmail.com>
-- Konstantin Scheglov
-- Paul Berry
+version: 2.0.0
+description: FlatBuffers reading and writing library for Dart. Based on original work by Konstantin Scheglov and Paul Berry of the Dart SDK team.
 homepage: https://github.com/google/flatbuffers
 documentation: https://google.github.io/flatbuffers/index.html
-dev_dependencies:
-  test: ^1.3.0
-  test_reflective_loader: ^0.1.4
-  path: ^1.5.1
+
 environment:
-  sdk: '>=2.0.0-dev.28.0 <3.0.0'
+  sdk: '>=2.12.0 <3.0.0'
+
+dev_dependencies:
+  test: ^1.17.7
+  test_reflective_loader: ^0.2.0
+  path: ^1.8.0
+  lints: ^1.0.1
+

dart/test/flat_buffers_test.dart

@@ -12,11 +12,14 @@ import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import './monster_test_my_game.example_generated.dart' as example;
+import './monster_test_my_game.example2_generated.dart' as example2;
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(BuilderTest);
+    defineReflectiveTests(ObjectAPITest);
     defineReflectiveTests(CheckOtherLangaugesData);
+    defineReflectiveTests(GeneratorTest);
   });
 }
 
@@ -27,50 +30,137 @@ int indexToField(int index) {
 @reflectiveTest
 class CheckOtherLangaugesData {
   test_cppData() async {
-    List<int> data = await new io.File(path.join(
-      path.dirname(io.Platform.script.path),
+    List<int> data = await io.File(path.join(
+      path.context.current,
+      'test',
       'monsterdata_test.mon',
-    ))
-        .readAsBytes();
-    example.Monster mon = new example.Monster(data);
+    )).readAsBytes();
+    example.Monster mon = example.Monster(data);
     expect(mon.hp, 80);
     expect(mon.mana, 150);
     expect(mon.name, 'MyMonster');
-    expect(mon.pos.x, 1.0);
-    expect(mon.pos.y, 2.0);
-    expect(mon.pos.z, 3.0);
-    expect(mon.pos.test1, 3.0);
-    expect(mon.pos.test2.value, 2.0);
-    expect(mon.pos.test3.a, 5);
-    expect(mon.pos.test3.b, 6);
-    expect(mon.testType.value, example.AnyTypeId.Monster.value);
+    expect(mon.pos!.x, 1.0);
+    expect(mon.pos!.y, 2.0);
+    expect(mon.pos!.z, 3.0);
+    expect(mon.pos!.test1, 3.0);
+    expect(mon.pos!.test2.value, 2.0);
+    expect(mon.pos!.test3.a, 5);
+    expect(mon.pos!.test3.b, 6);
+    expect(mon.testType!.value, example.AnyTypeId.Monster.value);
     expect(mon.test is example.Monster, true);
     final monster2 = mon.test as example.Monster;
     expect(monster2.name, "Fred");
 
-    expect(mon.inventory.length, 5);
-    expect(mon.inventory.reduce((cur, next) => cur + next), 10);
-    expect(mon.test4.length, 2);
-    expect(
-        mon.test4[0].a + mon.test4[0].b + mon.test4[1].a + mon.test4[1].b, 100);
-    expect(mon.testarrayofstring.length, 2);
-    expect(mon.testarrayofstring[0], "test1");
-    expect(mon.testarrayofstring[1], "test2");
+    expect(mon.inventory!.length, 5);
+    expect(mon.inventory!.reduce((cur, next) => cur + next), 10);
+    final test4 = mon.test4!;
+    expect(test4.length, 2);
+    expect(test4[0].a + test4[0].b + test4[1].a + test4[1].b, 100);
+    expect(mon.testarrayofstring!.length, 2);
+    expect(mon.testarrayofstring![0], "test1");
+    expect(mon.testarrayofstring![1], "test2");
 
     // this will fail if accessing any field fails.
-    expect(mon.toString(),
-        'Monster{pos: Vec3{x: 1.0, y: 2.0, z: 3.0, test1: 3.0, test2: Color{value: 2}, test3: Test{a: 5, b: 6}}, mana: 150, hp: 80, name: MyMonster, inventory: [0, 1, 2, 3, 4], color: Color{value: 8}, testType: AnyTypeId{value: 1}, test: Monster{pos: null, mana: 150, hp: 100, name: Fred, inventory: null, color: Color{value: 8}, testType: AnyTypeId{value: 0}, test: null, test4: null, testarrayofstring: null, testarrayoftables: null, enemy: null, testnestedflatbuffer: null, testempty: null, testbool: false, testhashs32Fnv1: 0, testhashu32Fnv1: 0, testhashs64Fnv1: 0, testhashu64Fnv1: 0, testhashs32Fnv1a: 0, testhashu32Fnv1a: 0, testhashs64Fnv1a: 0, testhashu64Fnv1a: 0, testarrayofbools: null, testf: 3.14159, testf2: 3.0, testf3: 0.0, testarrayofstring2: null, testarrayofsortedstruct: null, flex: null, test5: null, vectorOfLongs: null, vectorOfDoubles: null, parentNamespaceTest: null, vectorOfReferrables: null, singleWeakReference: 0, vectorOfWeakReferences: null, vectorOfStrongReferrables: null, coOwningReference: 0, vectorOfCoOwningReferences: null, nonOwningReference: 0, vectorOfNonOwningReferences: null}, test4: [Test{a: 10, b: 20}, Test{a: 30, b: 40}], testarrayofstring: [test1, test2], testarrayoftables: null, enemy: Monster{pos: null, mana: 150, hp: 100, name: Fred, inventory: null, color: Color{value: 8}, testType: AnyTypeId{value: 0}, test: null, test4: null, testarrayofstring: null, testarrayoftables: null, enemy: null, testnestedflatbuffer: null, testempty: null, testbool: false, testhashs32Fnv1: 0, testhashu32Fnv1: 0, testhashs64Fnv1: 0, testhashu64Fnv1: 0, testhashs32Fnv1a: 0, testhashu32Fnv1a: 0, testhashs64Fnv1a: 0, testhashu64Fnv1a: 0, testarrayofbools: null, testf: 3.14159, testf2: 3.0, testf3: 0.0, testarrayofstring2: null, testarrayofsortedstruct: null, flex: null, test5: null, vectorOfLongs: null, vectorOfDoubles: null, parentNamespaceTest: null, vectorOfReferrables: null, singleWeakReference: 0, vectorOfWeakReferences: null, vectorOfStrongReferrables: null, coOwningReference: 0, vectorOfCoOwningReferences: null, nonOwningReference: 0, vectorOfNonOwningReferences: null}, testnestedflatbuffer: null, testempty: null, testbool: false, testhashs32Fnv1: -579221183, testhashu32Fnv1: 3715746113, testhashs64Fnv1: 7930699090847568257, testhashu64Fnv1: 7930699090847568257, testhashs32Fnv1a: -1904106383, testhashu32Fnv1a: 2390860913, testhashs64Fnv1a: 4898026182817603057, testhashu64Fnv1a: 4898026182817603057, testarrayofbools: [true, false, true], testf: 3.14159, testf2: 3.0, testf3: 0.0, testarrayofstring2: null, testarrayofsortedstruct: null, flex: null, test5: [Test{a: 10, b: 20}, Test{a: 30, b: 40}], vectorOfLongs: [1, 100, 10000, 1000000, 100000000], vectorOfDoubles: [-1.7976931348623157e+308, 0.0, 1.7976931348623157e+308], parentNamespaceTest: null, vectorOfReferrables: null, singleWeakReference: 0, vectorOfWeakReferences: null, vectorOfStrongReferrables: null, coOwningReference: 0, vectorOfCoOwningReferences: null, nonOwningReference: 0, vectorOfNonOwningReferences: null}');
+    expect(
+      mon.toString(),
+      'Monster{'
+      'pos: Vec3{x: 1.0, y: 2.0, z: 3.0, test1: 3.0, test2: Color{value: 2}, test3: Test{a: 5, b: 6}}, '
+      'mana: 150, hp: 80, name: MyMonster, inventory: [0, 1, 2, 3, 4], '
+      'color: Color{value: 8}, testType: AnyTypeId{value: 1}, '
+      'test: Monster{pos: null, mana: 150, hp: 100, name: Fred, '
+      'inventory: null, color: Color{value: 8}, testType: null, '
+      'test: null, test4: null, testarrayofstring: null, '
+      'testarrayoftables: null, enemy: null, testnestedflatbuffer: null, '
+      'testempty: null, testbool: false, testhashs32Fnv1: 0, '
+      'testhashu32Fnv1: 0, testhashs64Fnv1: 0, testhashu64Fnv1: 0, '
+      'testhashs32Fnv1a: 0, testhashu32Fnv1a: 0, testhashs64Fnv1a: 0, '
+      'testhashu64Fnv1a: 0, testarrayofbools: null, testf: 3.14159, '
+      'testf2: 3.0, testf3: 0.0, testarrayofstring2: null, '
+      'testarrayofsortedstruct: null, flex: null, test5: null, '
+      'vectorOfLongs: null, vectorOfDoubles: null, parentNamespaceTest: null, '
+      'vectorOfReferrables: null, singleWeakReference: 0, '
+      'vectorOfWeakReferences: null, vectorOfStrongReferrables: null, '
+      'coOwningReference: 0, vectorOfCoOwningReferences: null, '
+      'nonOwningReference: 0, vectorOfNonOwningReferences: null, '
+      'anyUniqueType: null, anyUnique: null, anyAmbiguousType: null, '
+      'anyAmbiguous: null, vectorOfEnums: null, signedEnum: Race{value: -1}, '
+      'testrequirednestedflatbuffer: null, scalarKeySortedTables: null}, '
+      'test4: [Test{a: 10, b: 20}, Test{a: 30, b: 40}], '
+      'testarrayofstring: [test1, test2], testarrayoftables: null, '
+      'enemy: Monster{pos: null, mana: 150, hp: 100, name: Fred, '
+      'inventory: null, color: Color{value: 8}, testType: null, '
+      'test: null, test4: null, testarrayofstring: null, '
+      'testarrayoftables: null, enemy: null, testnestedflatbuffer: null, '
+      'testempty: null, testbool: false, testhashs32Fnv1: 0, '
+      'testhashu32Fnv1: 0, testhashs64Fnv1: 0, testhashu64Fnv1: 0, '
+      'testhashs32Fnv1a: 0, testhashu32Fnv1a: 0, testhashs64Fnv1a: 0, '
+      'testhashu64Fnv1a: 0, testarrayofbools: null, testf: 3.14159, '
+      'testf2: 3.0, testf3: 0.0, testarrayofstring2: null, '
+      'testarrayofsortedstruct: null, flex: null, test5: null, '
+      'vectorOfLongs: null, vectorOfDoubles: null, parentNamespaceTest: null, '
+      'vectorOfReferrables: null, singleWeakReference: 0, '
+      'vectorOfWeakReferences: null, vectorOfStrongReferrables: null, '
+      'coOwningReference: 0, vectorOfCoOwningReferences: null, '
+      'nonOwningReference: 0, vectorOfNonOwningReferences: null, '
+      'anyUniqueType: null, anyUnique: null, anyAmbiguousType: null, '
+      'anyAmbiguous: null, vectorOfEnums: null, signedEnum: Race{value: -1}, '
+      'testrequirednestedflatbuffer: null, scalarKeySortedTables: null}, '
+      'testnestedflatbuffer: null, testempty: null, testbool: true, '
+      'testhashs32Fnv1: -579221183, testhashu32Fnv1: 3715746113, '
+      'testhashs64Fnv1: 7930699090847568257, '
+      'testhashu64Fnv1: 7930699090847568257, '
+      'testhashs32Fnv1a: -1904106383, testhashu32Fnv1a: 2390860913, '
+      'testhashs64Fnv1a: 4898026182817603057, '
+      'testhashu64Fnv1a: 4898026182817603057, '
+      'testarrayofbools: [true, false, true], testf: 3.14159, testf2: 3.0, '
+      'testf3: 0.0, testarrayofstring2: null, testarrayofsortedstruct: ['
+      'Ability{id: 0, distance: 45}, Ability{id: 1, distance: 21}, '
+      'Ability{id: 5, distance: 12}], '
+      'flex: null, test5: [Test{a: 10, b: 20}, Test{a: 30, b: 40}], '
+      'vectorOfLongs: [1, 100, 10000, 1000000, 100000000], '
+      'vectorOfDoubles: [-1.7976931348623157e+308, 0.0, 1.7976931348623157e+308], '
+      'parentNamespaceTest: null, vectorOfReferrables: null, '
+      'singleWeakReference: 0, vectorOfWeakReferences: null, '
+      'vectorOfStrongReferrables: null, coOwningReference: 0, '
+      'vectorOfCoOwningReferences: null, nonOwningReference: 0, '
+      'vectorOfNonOwningReferences: null, '
+      'anyUniqueType: null, anyUnique: null, '
+      'anyAmbiguousType: null, '
+      'anyAmbiguous: null, vectorOfEnums: null, signedEnum: Race{value: -1}, '
+      'testrequirednestedflatbuffer: null, scalarKeySortedTables: [Stat{id: '
+      'miss, val: 0, count: 0}, Stat{id: hit, val: 10, count: 1}]}',
+    );
   }
 }
 
+/// Test a custom, fixed-memory allocator (no actual allocations performed)
+class CustomAllocator extends Allocator {
+  final _memory = ByteData(10 * 1024);
+  int _used = 0;
+
+  Uint8List buffer(int size) => _memory.buffer.asUint8List(_used - size, size);
+
+  @override
+  ByteData allocate(int size) {
+    if (size > _memory.lengthInBytes) {
+      throw UnsupportedError('Trying to allocate too much');
+    }
+    _used = size;
+    return ByteData.sublistView(_memory, 0, size);
+  }
+
+  @override
+  void deallocate(ByteData _) {}
+}
+
 @reflectiveTest
 class BuilderTest {
-  void test_monsterBuilder() {
-    final fbBuilder = new Builder();
+  void test_monsterBuilder([Builder? builder]) {
+    final fbBuilder = builder ?? Builder();
     final str = fbBuilder.writeString('MyMonster');
 
     fbBuilder.writeString('test1');
-    fbBuilder.writeString('test2');
+    fbBuilder.writeString('test2', asciiOptimization: true);
     final testArrayOfString = fbBuilder.endStructVector(2);
 
     final fred = fbBuilder.writeString('Fred');
@@ -78,21 +168,20 @@ class BuilderTest {
     final List<int> treasure = [0, 1, 2, 3, 4];
     final inventory = fbBuilder.writeListUint8(treasure);
 
-    final monBuilder = new example.MonsterBuilder(fbBuilder)
+    final monBuilder = example.MonsterBuilder(fbBuilder)
       ..begin()
       ..addNameOffset(fred);
     final mon2 = monBuilder.finish();
 
-    final testBuilder = new example.TestBuilder(fbBuilder);
+    final testBuilder = example.TestBuilder(fbBuilder);
     testBuilder.finish(10, 20);
     testBuilder.finish(30, 40);
     final test4 = fbBuilder.endStructVector(2);
 
-
     monBuilder
       ..begin()
       ..addPos(
-        new example.Vec3Builder(fbBuilder).finish(
+        example.Vec3Builder(fbBuilder).finish(
           1.0,
           2.0,
           3.0,
@@ -112,50 +201,51 @@ class BuilderTest {
     fbBuilder.finish(mon);
   }
 
-  void test_error_addInt32_withoutStartTable() {
-    Builder builder = new Builder();
+  void test_error_addInt32_withoutStartTable([Builder? builder]) {
+    builder ??= Builder();
     expect(() {
-      builder.addInt32(0, 0);
-    }, throwsStateError);
+      builder!.addInt32(0, 0);
+    }, throwsA(isA<AssertionError>()));
   }
 
   void test_error_addOffset_withoutStartTable() {
-    Builder builder = new Builder();
+    Builder builder = Builder();
     expect(() {
       builder.addOffset(0, 0);
-    }, throwsStateError);
+    }, throwsA(isA<AssertionError>()));
   }
 
   void test_error_endTable_withoutStartTable() {
-    Builder builder = new Builder();
+    Builder builder = Builder();
     expect(() {
       builder.endTable();
-    }, throwsStateError);
+    }, throwsA(isA<AssertionError>()));
   }
 
   void test_error_startTable_duringTable() {
-    Builder builder = new Builder();
-    builder.startTable();
+    Builder builder = Builder();
+    builder.startTable(0);
     expect(() {
-      builder.startTable();
-    }, throwsStateError);
+      builder.startTable(0);
+    }, throwsA(isA<AssertionError>()));
   }
 
   void test_error_writeString_duringTable() {
-    Builder builder = new Builder();
-    builder.startTable();
+    Builder builder = Builder();
+    builder.startTable(1);
     expect(() {
       builder.writeString('12345');
-    }, throwsStateError);
+    }, throwsA(isA<AssertionError>()));
   }
 
   void test_file_identifier() {
     Uint8List byteList;
     {
-      Builder builder = new Builder(initialSize: 0);
-      builder.startTable();
+      Builder builder = Builder(initialSize: 0);
+      builder.startTable(0);
       int offset = builder.endTable();
-      byteList = builder.finish(offset, 'Az~ÿ');
+      builder.finish(offset, 'Az~ÿ');
+      byteList = builder.buffer;
     }
     // Convert byteList to a ByteData so that we can read data from it.
     ByteData byteData = byteList.buffer.asByteData(byteList.offsetInBytes);
@@ -167,8 +257,8 @@ class BuilderTest {
     expect(byteData.getUint8(6), 126); // '~'
     expect(byteData.getUint8(7), 255); // 'ÿ'
     // First 4 bytes of the table data are a backwards offset to the vtable.
-    int vTableLoc = tableDataLoc -
-        byteData.getInt32(tableDataLoc, Endian.little);
+    int vTableLoc =
+        tableDataLoc - byteData.getInt32(tableDataLoc, Endian.little);
     // First 2 bytes of the vtable are the size of the vtable in bytes, which
     // should be 4.
     expect(byteData.getUint16(vTableLoc, Endian.little), 4);
@@ -178,31 +268,46 @@ class BuilderTest {
   }
 
   void test_low() {
-    Builder builder = new Builder(initialSize: 0);
-    expect((builder..putUint8(1)).lowFinish(), [1]);
-    expect((builder..putUint32(2)).lowFinish(), [2, 0, 0, 0, 0, 0, 0, 1]);
-    expect((builder..putUint8(3)).lowFinish(),
-        [0, 0, 0, 3, 2, 0, 0, 0, 0, 0, 0, 1]);
-    expect((builder..putUint8(4)).lowFinish(),
-        [0, 0, 4, 3, 2, 0, 0, 0, 0, 0, 0, 1]);
-    expect((builder..putUint8(5)).lowFinish(),
-        [0, 5, 4, 3, 2, 0, 0, 0, 0, 0, 0, 1]);
-    expect((builder..putUint32(6)).lowFinish(),
+    final allocator = CustomAllocator();
+    final builder = Builder(initialSize: 0, allocator: allocator);
+
+    builder.putUint8(1);
+    expect(allocator.buffer(builder.size()), [1]);
+
+    builder.putUint32(2);
+    expect(allocator.buffer(builder.size()), [2, 0, 0, 0, 0, 0, 0, 1]);
+
+    builder.putUint8(3);
+    expect(
+        allocator.buffer(builder.size()), [0, 0, 0, 3, 2, 0, 0, 0, 0, 0, 0, 1]);
+
+    builder.putUint8(4);
+    expect(
+        allocator.buffer(builder.size()), [0, 0, 4, 3, 2, 0, 0, 0, 0, 0, 0, 1]);
+
+    builder.putUint8(5);
+    expect(
+        allocator.buffer(builder.size()), [0, 5, 4, 3, 2, 0, 0, 0, 0, 0, 0, 1]);
+
+    builder.putUint32(6);
+    expect(allocator.buffer(builder.size()),
         [6, 0, 0, 0, 0, 5, 4, 3, 2, 0, 0, 0, 0, 0, 0, 1]);
   }
 
   void test_table_default() {
     List<int> byteList;
     {
-      Builder builder = new Builder(initialSize: 0);
-      builder.startTable();
+      final builder = Builder(initialSize: 0, allocator: CustomAllocator());
+      builder.startTable(2);
       builder.addInt32(0, 10, 10);
       builder.addInt32(1, 20, 10);
       int offset = builder.endTable();
-      byteList = builder.finish(offset);
+      builder.finish(offset);
+      byteList = builder.buffer;
+      expect(builder.size(), byteList.length);
     }
     // read and verify
-    BufferContext buffer = new BufferContext.fromBytes(byteList);
+    BufferContext buffer = BufferContext.fromBytes(byteList);
     int objectOffset = buffer.derefObject(0);
     // was not written, so uses the new default value
     expect(
@@ -216,23 +321,24 @@ class BuilderTest {
         20);
   }
 
-  void test_table_format() {
+  void test_table_format([Builder? builder]) {
     Uint8List byteList;
     {
-      Builder builder = new Builder(initialSize: 0);
-      builder.startTable();
+      builder ??= Builder(initialSize: 0);
+      builder.startTable(3);
       builder.addInt32(0, 10);
       builder.addInt32(1, 20);
       builder.addInt32(2, 30);
-      byteList = builder.finish(builder.endTable());
+      builder.finish(builder.endTable());
+      byteList = builder.buffer;
     }
     // Convert byteList to a ByteData so that we can read data from it.
     ByteData byteData = byteList.buffer.asByteData(byteList.offsetInBytes);
     // First 4 bytes are an offset to the table data.
     int tableDataLoc = byteData.getUint32(0, Endian.little);
     // First 4 bytes of the table data are a backwards offset to the vtable.
-    int vTableLoc = tableDataLoc -
-        byteData.getInt32(tableDataLoc, Endian.little);
+    int vTableLoc =
+        tableDataLoc - byteData.getInt32(tableDataLoc, Endian.little);
     // First 2 bytes of the vtable are the size of the vtable in bytes, which
     // should be 10.
     expect(byteData.getUint16(vTableLoc, Endian.little), 10);
@@ -242,10 +348,9 @@ class BuilderTest {
     // Remaining 6 bytes are the offsets within the object where the ints are
     // located.
     for (int i = 0; i < 3; i++) {
-      int offset =
-          byteData.getUint16(vTableLoc + 4 + 2 * i, Endian.little);
-      expect(byteData.getInt32(tableDataLoc + offset, Endian.little),
-          10 + 10 * i);
+      int offset = byteData.getUint16(vTableLoc + 4 + 2 * i, Endian.little);
+      expect(
+          byteData.getInt32(tableDataLoc + offset, Endian.little), 10 + 10 * i);
     }
   }
 
@@ -254,30 +359,37 @@ class BuilderTest {
     String unicodeString = 'Проба пера';
     List<int> byteList;
     {
-      Builder builder = new Builder(initialSize: 0);
-      int latinStringOffset = builder.writeString(latinString);
-      int unicodeStringOffset = builder.writeString(unicodeString);
-      builder.startTable();
+      Builder builder = Builder(initialSize: 0);
+      int? latinStringOffset =
+          builder.writeString(latinString, asciiOptimization: true);
+      int? unicodeStringOffset =
+          builder.writeString(unicodeString, asciiOptimization: true);
+      builder.startTable(2);
       builder.addOffset(0, latinStringOffset);
       builder.addOffset(1, unicodeStringOffset);
       int offset = builder.endTable();
-      byteList = builder.finish(offset);
+      builder.finish(offset);
+      byteList = builder.buffer;
     }
     // read and verify
-    BufferContext buf = new BufferContext.fromBytes(byteList);
+    BufferContext buf = BufferContext.fromBytes(byteList);
     int objectOffset = buf.derefObject(0);
-    expect(const StringReader().vTableGet(buf, objectOffset, indexToField(0)),
+    expect(
+        const StringReader()
+            .vTableGetNullable(buf, objectOffset, indexToField(0)),
         latinString);
-    expect(const StringReader().vTableGet(buf, objectOffset, indexToField(1)),
+    expect(
+        const StringReader(asciiOptimization: true)
+            .vTableGetNullable(buf, objectOffset, indexToField(1)),
         unicodeString);
   }
 
-  void test_table_types() {
+  void test_table_types([Builder? builder]) {
     List<int> byteList;
     {
-      Builder builder = new Builder(initialSize: 0);
-      int stringOffset = builder.writeString('12345');
-      builder.startTable();
+      builder ??= Builder(initialSize: 0);
+      int? stringOffset = builder.writeString('12345');
+      builder.startTable(7);
       builder.addBool(0, true);
       builder.addInt8(1, 10);
       builder.addInt32(2, 20);
@@ -286,24 +398,39 @@ class BuilderTest {
       builder.addUint32(5, 0x9ABCDEF0);
       builder.addUint8(6, 0x9A);
       int offset = builder.endTable();
-      byteList = builder.finish(offset);
+      builder.finish(offset);
+      byteList = builder.buffer;
     }
     // read and verify
-    BufferContext buf = new BufferContext.fromBytes(byteList);
+    BufferContext buf = BufferContext.fromBytes(byteList);
     int objectOffset = buf.derefObject(0);
     expect(
-        const BoolReader().vTableGet(buf, objectOffset, indexToField(0)), true);
+        const BoolReader()
+            .vTableGetNullable(buf, objectOffset, indexToField(0)),
+        true);
     expect(
-        const Int8Reader().vTableGet(buf, objectOffset, indexToField(1)), 10);
+        const Int8Reader()
+            .vTableGetNullable(buf, objectOffset, indexToField(1)),
+        10);
     expect(
-        const Int32Reader().vTableGet(buf, objectOffset, indexToField(2)), 20);
-    expect(const StringReader().vTableGet(buf, objectOffset, indexToField(3)),
+        const Int32Reader()
+            .vTableGetNullable(buf, objectOffset, indexToField(2)),
+        20);
+    expect(
+        const StringReader()
+            .vTableGetNullable(buf, objectOffset, indexToField(3)),
         '12345');
     expect(
-        const Int32Reader().vTableGet(buf, objectOffset, indexToField(4)), 40);
-    expect(const Uint32Reader().vTableGet(buf, objectOffset, indexToField(5)),
+        const Int32Reader()
+            .vTableGetNullable(buf, objectOffset, indexToField(4)),
+        40);
+    expect(
+        const Uint32Reader()
+            .vTableGetNullable(buf, objectOffset, indexToField(5)),
         0x9ABCDEF0);
-    expect(const Uint8Reader().vTableGet(buf, objectOffset, indexToField(6)),
+    expect(
+        const Uint8Reader()
+            .vTableGetNullable(buf, objectOffset, indexToField(6)),
         0x9A);
   }
 
@@ -312,12 +439,13 @@ class BuilderTest {
     // write
     List<int> byteList;
     {
-      Builder builder = new Builder(initialSize: 0);
+      Builder builder = Builder(initialSize: 0);
       int offset = builder.writeListUint32(values);
-      byteList = builder.finish(offset);
+      builder.finish(offset);
+      byteList = builder.buffer;
     }
     // read and verify
-    BufferContext buf = new BufferContext.fromBytes(byteList);
+    BufferContext buf = BufferContext.fromBytes(byteList);
     List<int> items = const Uint32ListReader().read(buf, 0);
     expect(items, hasLength(4));
     expect(items, orderedEquals(values));
@@ -328,16 +456,17 @@ class BuilderTest {
       // write
       List<int> byteList;
       {
-        Builder builder = new Builder(initialSize: 0);
-        List<bool> values = new List<bool>.filled(len, false);
+        Builder builder = Builder(initialSize: 0);
+        List<bool> values = List<bool>.filled(len, false);
         for (int bit in trueBits) {
           values[bit] = true;
         }
         int offset = builder.writeListBool(values);
-        byteList = builder.finish(offset);
+        builder.finish(offset);
+        byteList = builder.buffer;
       }
       // read and verify
-      BufferContext buf = new BufferContext.fromBytes(byteList);
+      BufferContext buf = BufferContext.fromBytes(byteList);
       List<bool> items = const BoolListReader().read(buf, 0);
       expect(items, hasLength(len));
       for (int i = 0; i < items.length; i++) {
@@ -356,25 +485,26 @@ class BuilderTest {
     verifyListBooleans(33, <int>[1, 2, 24, 25, 31, 32]);
     verifyListBooleans(63, <int>[]);
     verifyListBooleans(63, <int>[0, 1, 2, 61, 62]);
-    verifyListBooleans(63, new List<int>.generate(63, (i) => i));
+    verifyListBooleans(63, List<int>.generate(63, (i) => i));
     verifyListBooleans(64, <int>[]);
     verifyListBooleans(64, <int>[0, 1, 2, 61, 62, 63]);
     verifyListBooleans(64, <int>[1, 2, 62]);
     verifyListBooleans(64, <int>[0, 1, 2, 63]);
-    verifyListBooleans(64, new List<int>.generate(64, (i) => i));
+    verifyListBooleans(64, List<int>.generate(64, (i) => i));
     verifyListBooleans(100, <int>[0, 3, 30, 60, 90, 99]);
   }
 
   void test_writeList_ofInt32() {
     List<int> byteList;
     {
-      Builder builder = new Builder(initialSize: 0);
+      Builder builder = Builder(initialSize: 0);
       int offset = builder.writeListInt32(<int>[1, 2, 3, 4, 5]);
-      byteList = builder.finish(offset);
+      builder.finish(offset);
+      byteList = builder.buffer;
     }
     // read and verify
-    BufferContext buf = new BufferContext.fromBytes(byteList);
-    List<int> items = const ListReader<int>(const Int32Reader()).read(buf, 0);
+    BufferContext buf = BufferContext.fromBytes(byteList);
+    List<int> items = const ListReader<int>(Int32Reader()).read(buf, 0);
     expect(items, hasLength(5));
     expect(items, orderedEquals(<int>[1, 2, 3, 4, 5]));
   }
@@ -384,13 +514,14 @@ class BuilderTest {
     // write
     List<int> byteList;
     {
-      Builder builder = new Builder(initialSize: 0);
+      Builder builder = Builder(initialSize: 0);
       int offset = builder.writeListFloat64(values);
-      byteList = builder.finish(offset);
+      builder.finish(offset);
+      byteList = builder.buffer;
     }
 
     // read and verify
-    BufferContext buf = new BufferContext.fromBytes(byteList);
+    BufferContext buf = BufferContext.fromBytes(byteList);
     List<double> items = const Float64ListReader().read(buf, 0);
 
     expect(items, hasLength(values.length));
@@ -404,12 +535,13 @@ class BuilderTest {
     // write
     List<int> byteList;
     {
-      Builder builder = new Builder(initialSize: 0);
+      Builder builder = Builder(initialSize: 0);
       int offset = builder.writeListFloat32(values);
-      byteList = builder.finish(offset);
+      builder.finish(offset);
+      byteList = builder.buffer;
     }
     // read and verify
-    BufferContext buf = new BufferContext.fromBytes(byteList);
+    BufferContext buf = BufferContext.fromBytes(byteList);
     List<double> items = const Float32ListReader().read(buf, 0);
     expect(items, hasLength(5));
     for (int i = 0; i < values.length; i++) {
@@ -417,14 +549,14 @@ class BuilderTest {
     }
   }
 
-  void test_writeList_ofObjects() {
+  void test_writeList_ofObjects([Builder? builder]) {
     List<int> byteList;
     {
-      Builder builder = new Builder(initialSize: 0);
+      builder ??= Builder(initialSize: 0);
       // write the object #1
       int object1;
       {
-        builder.startTable();
+        builder.startTable(2);
         builder.addInt32(0, 10);
         builder.addInt32(1, 20);
         object1 = builder.endTable();
@@ -432,19 +564,20 @@ class BuilderTest {
       // write the object #1
       int object2;
       {
-        builder.startTable();
+        builder.startTable(2);
         builder.addInt32(0, 100);
         builder.addInt32(1, 200);
         object2 = builder.endTable();
       }
       // write the list
       int offset = builder.writeList([object1, object2]);
-      byteList = builder.finish(offset);
+      builder.finish(offset);
+      byteList = builder.buffer;
     }
     // read and verify
-    BufferContext buf = new BufferContext.fromBytes(byteList);
+    BufferContext buf = BufferContext.fromBytes(byteList);
     List<TestPointImpl> items =
-        const ListReader<TestPointImpl>(const TestPointReader()).read(buf, 0);
+        const ListReader<TestPointImpl>(TestPointReader()).read(buf, 0);
     expect(items, hasLength(2));
     expect(items[0].x, 10);
     expect(items[0].y, 20);
@@ -455,36 +588,37 @@ class BuilderTest {
   void test_writeList_ofStrings_asRoot() {
     List<int> byteList;
     {
-      Builder builder = new Builder(initialSize: 0);
-      int str1 = builder.writeString('12345');
-      int str2 = builder.writeString('ABC');
+      Builder builder = Builder(initialSize: 0);
+      int? str1 = builder.writeString('12345');
+      int? str2 = builder.writeString('ABC');
       int offset = builder.writeList([str1, str2]);
-      byteList = builder.finish(offset);
+      builder.finish(offset);
+      byteList = builder.buffer;
     }
     // read and verify
-    BufferContext buf = new BufferContext.fromBytes(byteList);
-    List<String> items =
-        const ListReader<String>(const StringReader()).read(buf, 0);
+    BufferContext buf = BufferContext.fromBytes(byteList);
+    List<String> items = const ListReader<String>(StringReader()).read(buf, 0);
     expect(items, hasLength(2));
     expect(items, contains('12345'));
     expect(items, contains('ABC'));
   }
 
-  void test_writeList_ofStrings_inObject() {
+  void test_writeList_ofStrings_inObject([Builder? builder]) {
     List<int> byteList;
     {
-      Builder builder = new Builder(initialSize: 0);
+      builder ??= Builder(initialSize: 0);
       int listOffset = builder.writeList(
           [builder.writeString('12345'), builder.writeString('ABC')]);
-      builder.startTable();
+      builder.startTable(1);
       builder.addOffset(0, listOffset);
       int offset = builder.endTable();
-      byteList = builder.finish(offset);
+      builder.finish(offset);
+      byteList = builder.buffer;
     }
     // read and verify
-    BufferContext buf = new BufferContext.fromBytes(byteList);
-    StringListWrapperImpl reader = new StringListWrapperReader().read(buf, 0);
-    List<String> items = reader.items;
+    BufferContext buf = BufferContext.fromBytes(byteList);
+    StringListWrapperImpl reader = StringListWrapperReader().read(buf, 0);
+    List<String>? items = reader.items;
     expect(items, hasLength(2));
     expect(items, contains('12345'));
     expect(items, contains('ABC'));
@@ -493,12 +627,13 @@ class BuilderTest {
   void test_writeList_ofUint32() {
     List<int> byteList;
     {
-      Builder builder = new Builder(initialSize: 0);
+      Builder builder = Builder(initialSize: 0);
       int offset = builder.writeListUint32(<int>[1, 2, 0x9ABCDEF0]);
-      byteList = builder.finish(offset);
+      builder.finish(offset);
+      byteList = builder.buffer;
     }
     // read and verify
-    BufferContext buf = new BufferContext.fromBytes(byteList);
+    BufferContext buf = BufferContext.fromBytes(byteList);
     List<int> items = const Uint32ListReader().read(buf, 0);
     expect(items, hasLength(3));
     expect(items, orderedEquals(<int>[1, 2, 0x9ABCDEF0]));
@@ -507,12 +642,13 @@ class BuilderTest {
   void test_writeList_ofUint16() {
     List<int> byteList;
     {
-      Builder builder = new Builder(initialSize: 0);
+      Builder builder = Builder(initialSize: 0);
       int offset = builder.writeListUint16(<int>[1, 2, 60000]);
-      byteList = builder.finish(offset);
+      builder.finish(offset);
+      byteList = builder.buffer;
     }
     // read and verify
-    BufferContext buf = new BufferContext.fromBytes(byteList);
+    BufferContext buf = BufferContext.fromBytes(byteList);
     List<int> items = const Uint16ListReader().read(buf, 0);
     expect(items, hasLength(3));
     expect(items, orderedEquals(<int>[1, 2, 60000]));
@@ -521,15 +657,188 @@ class BuilderTest {
   void test_writeList_ofUint8() {
     List<int> byteList;
     {
-      Builder builder = new Builder(initialSize: 0);
-      int offset = builder.writeListUint8(<int>[1, 2, 3, 4, 0x9A]);
-      byteList = builder.finish(offset);
+      Builder builder = Builder(initialSize: 0);
+      int offset = builder.writeListUint8(<int>[1, 2, 3, 4, 0x9A, 0xFA]);
+      builder.finish(offset);
+      byteList = builder.buffer;
     }
     // read and verify
-    BufferContext buf = new BufferContext.fromBytes(byteList);
-    List<int> items = const Uint8ListReader().read(buf, 0);
-    expect(items, hasLength(5));
-    expect(items, orderedEquals(<int>[1, 2, 3, 4, 0x9A]));
+    BufferContext buf = BufferContext.fromBytes(byteList);
+    const buffOffset = 8; // 32-bit offset to the list, + 32-bit length
+    for (final lazy in [true, false]) {
+      List<int> items = Uint8ListReader(lazy: lazy).read(buf, 0);
+      expect(items, hasLength(6));
+      expect(items, orderedEquals(<int>[1, 2, 3, 4, 0x9A, 0xFA]));
+
+      // overwrite the buffer to verify the laziness
+      buf.buffer.setUint8(buffOffset + 1, 99);
+      expect(items, orderedEquals(<int>[1, lazy ? 99 : 2, 3, 4, 0x9A, 0xFA]));
+
+      // restore the previous value for the next loop
+      buf.buffer.setUint8(buffOffset + 1, 2);
+    }
+  }
+
+  void test_reset() {
+    // We'll run a selection of tests , reusing the builder between them.
+    final testCases = <void Function(Builder?)>[
+      test_monsterBuilder,
+      test_error_addInt32_withoutStartTable,
+      test_table_format,
+      test_table_types,
+      test_writeList_ofObjects,
+      test_writeList_ofStrings_inObject
+    ];
+
+    // Execute all test cases in all permutations of their order.
+    // To do that, we generate permutations of test case indexes.
+    final testCasesPermutations =
+        _permutationsOf(List.generate(testCases.length, (index) => index));
+    expect(testCasesPermutations.length, _factorial(testCases.length));
+
+    for (var indexes in testCasesPermutations) {
+      // print the order so failures are reproducible
+      printOnFailure('Running reset() test cases in order: $indexes');
+
+      Builder? builder;
+      for (var index in indexes) {
+        if (builder == null) {
+          // Initial size small enough so at least one test case increases it.
+          // On the other hand, it's large enough so that some test cases don't.
+          builder = Builder(initialSize: 32);
+        } else {
+          builder.reset();
+        }
+        testCases[index](builder);
+      }
+    }
+  }
+
+  // Generate permutations of the given list
+  List<List<T>> _permutationsOf<T>(List<T> source) {
+    final result = <List<T>>[];
+
+    void permutate(List<T> items, int startAt) {
+      for (var i = startAt; i < items.length; i++) {
+        List<T> permutation = items.toList(growable: false);
+        permutation[i] = items[startAt];
+        permutation[startAt] = items[i];
+
+        // add the current list upon reaching the end
+        if (startAt == items.length - 1) {
+          result.add(items);
+        } else {
+          permutate(permutation, startAt + 1);
+        }
+      }
+    }
+
+    permutate(source, 0);
+    return result;
+  }
+
+  // a very simple implementation of n!
+  int _factorial(int n) {
+    var result = 1;
+    for (var i = 2; i <= n; i++) {
+      result *= i;
+    }
+    return result;
+  }
+}
+
+@reflectiveTest
+class ObjectAPITest {
+  void test_tableStat() {
+    final object1 = example.StatT(count: 3, id: "foo", val: 4);
+    expect(object1 is Packable, isTrue);
+    final fbb = Builder();
+    fbb.finish(object1.pack(fbb));
+    final object2 = example.Stat(fbb.buffer).unpack();
+    expect(object2.count, object1.count);
+    expect(object2.id, object1.id);
+    expect(object2.val, object1.val);
+    expect(object2.toString(), object1.toString());
+  }
+
+  void test_tableMonster() {
+    final monster = example.MonsterT()
+      ..pos = example.Vec3T(
+          x: 1,
+          y: 2,
+          z: 3,
+          test1: 4.0,
+          test2: example.Color.Red,
+          test3: example.TestT(a: 1, b: 2))
+      ..mana = 2
+      ..name = 'Monstrous'
+      ..inventory = [24, 42]
+      ..color = example.Color.Green
+      // TODO be smarter for unions and automatically set the `type` field?
+      ..testType = example.AnyTypeId.MyGame_Example2_Monster
+      ..test = example2.MonsterT()
+      ..test4 = [example.TestT(a: 3, b: 4), example.TestT(a: 5, b: 6)]
+      ..testarrayofstring = ["foo", "bar"]
+      ..testarrayoftables = [example.MonsterT(name: 'Oof')]
+      ..enemy = example.MonsterT(name: 'Enemy')
+      ..testarrayofbools = [false, true, false]
+      ..testf = 42.24
+      ..testarrayofsortedstruct = [
+        example.AbilityT(id: 1, distance: 5),
+        example.AbilityT(id: 3, distance: 7)
+      ]
+      ..vectorOfLongs = [5, 6, 7]
+      ..vectorOfDoubles = [8.9, 9.0, 10.1, 11.2]
+      ..anyAmbiguousType = example.AnyAmbiguousAliasesTypeId.M2
+      ..anyAmbiguous = null
+      ..vectorOfEnums = [example.Color.Blue, example.Color.Green]
+      ..signedEnum = example.Race.None;
+
+    final fbBuilder = Builder();
+    final offset = monster.pack(fbBuilder);
+    expect(offset, isNonZero);
+    fbBuilder.finish(offset);
+    final data = fbBuilder.buffer;
+
+    // TODO currently broken because of struct builder issue, see #6688
+    // final monster2 = example.Monster(data); // Monster (reader)
+    // expect(
+    //     // map Monster => MonsterT, Vec3 => Vec3T, ...
+    //     monster2.toString().replaceAllMapped(
+    //         RegExp('([a-zA-z0-9]+){'), (match) => match.group(1) + 'T{'),
+    //     monster.toString());
+    //
+    // final monster3 = monster2.unpack(); // MonsterT
+    // expect(monster3.toString(), monster.toString());
+  }
+
+  void test_Lists() {
+    // Ensure unpack() reads lists eagerly by reusing the same builder and
+    // overwriting data. Why: because standard reader reads lists lazily...
+    final fbb = Builder();
+
+    final object1 = example.TypeAliasesT(v8: [1, 2, 3], vf64: [5, 6]);
+    fbb.finish(object1.pack(fbb));
+    final object1Read = example.TypeAliases(fbb.buffer).unpack();
+
+    // overwrite the original buffer by writing to the same builder
+    fbb.reset();
+    final object2 = example.TypeAliasesT(v8: [7, 8, 9], vf64: [10, 11]);
+    fbb.finish(object2.pack(fbb));
+    final object2Read = example.TypeAliases(fbb.buffer).unpack();
+
+    // this is fine even with lazy lists:
+    expect(object2.toString(), object2Read.toString());
+
+    // this fails with lazy lists:
+    expect(object1.toString(), object1Read.toString());
+
+    // empty list must be serialized as such (were stored NULL before v2.0)
+    fbb.reset();
+    final object3 = example.TypeAliasesT(v8: [], vf64: null);
+    fbb.finish(object3.pack(fbb));
+    final object3Read = example.TypeAliases(fbb.buffer).unpack();
+    expect(object3.toString(), object3Read.toString());
   }
 }
 
@@ -539,8 +848,8 @@ class StringListWrapperImpl {
 
   StringListWrapperImpl(this.bp, this.offset);
 
-  List<String> get items => const ListReader<String>(const StringReader())
-      .vTableGet(bp, offset, indexToField(0));
+  List<String>? get items => const ListReader<String>(StringReader())
+      .vTableGetNullable(bp, offset, indexToField(0));
 }
 
 class StringListWrapperReader extends TableReader<StringListWrapperImpl> {
@@ -548,7 +857,7 @@ class StringListWrapperReader extends TableReader<StringListWrapperImpl> {
 
   @override
   StringListWrapperImpl createObject(BufferContext object, int offset) {
-    return new StringListWrapperImpl(object, offset);
+    return StringListWrapperImpl(object, offset);
   }
 }
 
@@ -568,6 +877,19 @@ class TestPointReader extends TableReader<TestPointImpl> {
 
   @override
   TestPointImpl createObject(BufferContext object, int offset) {
-    return new TestPointImpl(object, offset);
+    return TestPointImpl(object, offset);
+  }
+}
+
+@reflectiveTest
+class GeneratorTest {
+  void test_constantEnumValues() async {
+    expect(example.Color.values, same(example.Color.values));
+    expect(example.Race.values, same(example.Race.values));
+    expect(example.AnyTypeId.values, same(example.AnyTypeId.values));
+    expect(example.AnyUniqueAliasesTypeId.values,
+        same(example.AnyUniqueAliasesTypeId.values));
+    expect(example.AnyAmbiguousAliasesTypeId.values,
+        same(example.AnyAmbiguousAliasesTypeId.values));
   }
 }

dart/test/flex_builder_test.dart

@@ -0,0 +1,593 @@
+import 'dart:typed_data';
+
+import 'package:flat_buffers/flex_buffers.dart' show Builder;
+import 'package:test/test.dart';
+
+void main() {
+  test('build with single value', () {
+    {
+      var flx = Builder();
+      flx.addNull();
+      expect(flx.finish(), [0, 0, 1]);
+    }
+    {
+      var flx = Builder();
+      flx.addBool(true);
+      expect(flx.finish(), [1, 104, 1]);
+    }
+    {
+      var flx = Builder();
+      flx.addBool(false);
+      expect(flx.finish(), [0, 104, 1]);
+    }
+    {
+      var flx = Builder();
+      flx.addInt(1);
+      expect(flx.finish(), [1, 4, 1]);
+    }
+    {
+      var flx = Builder();
+      flx.addInt(230);
+      expect(flx.finish(), [230, 0, 5, 2]);
+    }
+    {
+      var flx = Builder();
+      flx.addInt(1025);
+      expect(flx.finish(), [1, 4, 5, 2]);
+    }
+    {
+      var flx = Builder();
+      flx.addInt(-1025);
+      expect(flx.finish(), [255, 251, 5, 2]);
+    }
+    {
+      var flx = Builder();
+      flx.addDouble(0.1);
+      expect(flx.finish(), [154, 153, 153, 153, 153, 153, 185, 63, 15, 8]);
+    }
+    {
+      var flx = Builder();
+      flx.addDouble(0.5);
+      expect(flx.finish(), [0, 0, 0, 63, 14, 4]);
+    }
+    {
+      var flx = Builder();
+      flx.addString('Maxim');
+      expect(flx.finish(), [5, 77, 97, 120, 105, 109, 0, 6, 20, 1]);
+    }
+    {
+      var flx = Builder();
+      flx.addString('hello 😱');
+      expect(flx.finish(),
+          [10, 104, 101, 108, 108, 111, 32, 240, 159, 152, 177, 0, 11, 20, 1]);
+    }
+  });
+
+  test('build vector', () {
+    {
+      var flx = Builder()
+        ..startVector()
+        ..addInt(1)
+        ..addInt(2)
+        ..end();
+      expect(flx.finish(), [1, 2, 2, 64, 1]);
+    }
+    {
+      var flx = Builder()
+        ..startVector()
+        ..addInt(-1)
+        ..addInt(256)
+        ..end();
+      expect(flx.finish(), [255, 255, 0, 1, 4, 65, 1]);
+    }
+    {
+      var flx = Builder()
+        ..startVector()
+        ..addInt(-45)
+        ..addInt(256000)
+        ..end();
+      expect(flx.finish(), [211, 255, 255, 255, 0, 232, 3, 0, 8, 66, 1]);
+    }
+    {
+      var flx = Builder()
+        ..startVector()
+        ..addDouble(1.1)
+        ..addDouble(-256)
+        ..end();
+      expect(flx.finish(), [
+        154,
+        153,
+        153,
+        153,
+        153,
+        153,
+        241,
+        63,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        112,
+        192,
+        16,
+        75,
+        1
+      ]);
+    }
+    {
+      var flx = Builder()
+        ..startVector()
+        ..addInt(1)
+        ..addInt(2)
+        ..addInt(4)
+        ..end();
+      expect(flx.finish(), [1, 2, 4, 3, 76, 1]);
+    }
+    {
+      var flx = Builder()
+        ..startVector()
+        ..addInt(-1)
+        ..addInt(256)
+        ..addInt(4)
+        ..end();
+      expect(flx.finish(), [255, 255, 0, 1, 4, 0, 6, 77, 1]);
+    }
+    {
+      var flx = Builder()
+        ..startVector()
+        ..startVector()
+        ..addInt(61)
+        ..end()
+        ..addInt(64)
+        ..end();
+      expect(flx.finish(), [1, 61, 2, 2, 64, 44, 4, 4, 40, 1]);
+    }
+    {
+      var flx = Builder()
+        ..startVector()
+        ..addString('foo')
+        ..addString('bar')
+        ..addString('baz')
+        ..end();
+      expect(flx.finish(), [
+        3,
+        102,
+        111,
+        111,
+        0,
+        3,
+        98,
+        97,
+        114,
+        0,
+        3,
+        98,
+        97,
+        122,
+        0,
+        3,
+        15,
+        11,
+        7,
+        3,
+        60,
+        1
+      ]);
+    }
+    {
+      var flx = Builder()
+        ..startVector()
+        ..addString('foo')
+        ..addString('bar')
+        ..addString('baz')
+        ..addString('foo')
+        ..addString('bar')
+        ..addString('baz')
+        ..end();
+      expect(flx.finish(), [
+        3,
+        102,
+        111,
+        111,
+        0,
+        3,
+        98,
+        97,
+        114,
+        0,
+        3,
+        98,
+        97,
+        122,
+        0,
+        6,
+        15,
+        11,
+        7,
+        18,
+        14,
+        10,
+        6,
+        60,
+        1
+      ]);
+    }
+    {
+      var flx = Builder()
+        ..startVector()
+        ..addBool(true)
+        ..addBool(false)
+        ..addBool(true)
+        ..end();
+      expect(flx.finish(), [3, 1, 0, 1, 3, 144, 1]);
+    }
+    {
+      var flx = Builder()
+        ..startVector()
+        ..addString('foo')
+        ..addInt(1)
+        ..addInt(-5)
+        ..addDouble(1.3)
+        ..addBool(true)
+        ..end();
+      expect(flx.finish(), [
+        3,
+        102,
+        111,
+        111,
+        0,
+        0,
+        0,
+        0,
+        5,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        15,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        251,
+        255,
+        255,
+        255,
+        255,
+        255,
+        255,
+        255,
+        205,
+        204,
+        204,
+        204,
+        204,
+        204,
+        244,
+        63,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        20,
+        4,
+        4,
+        15,
+        104,
+        45,
+        43,
+        1
+      ]);
+    }
+  });
+
+  test('build map', () {
+    {
+      var flx = Builder()
+        ..startMap()
+        ..addKey('a')
+        ..addInt(12)
+        ..end();
+      expect(flx.finish(), [97, 0, 1, 3, 1, 1, 1, 12, 4, 2, 36, 1]);
+    }
+    {
+      var flx = Builder()
+        ..startMap()
+        ..addKey('a')
+        ..addInt(12)
+        ..addKey('')
+        ..addInt(45)
+        ..end();
+      expect(
+          flx.finish(), [97, 0, 0, 2, 2, 5, 2, 1, 2, 45, 12, 4, 4, 4, 36, 1]);
+    }
+    {
+      var flx = Builder()
+        ..startVector()
+        ..startMap()
+        ..addKey('something')
+        ..addInt(12)
+        ..end()
+        ..startMap()
+        ..addKey('something')
+        ..addInt(45)
+        ..end()
+        ..end();
+      expect(flx.finish(), [
+        115,
+        111,
+        109,
+        101,
+        116,
+        104,
+        105,
+        110,
+        103,
+        0,
+        1,
+        11,
+        1,
+        1,
+        1,
+        12,
+        4,
+        6,
+        1,
+        1,
+        45,
+        4,
+        2,
+        8,
+        4,
+        36,
+        36,
+        4,
+        40,
+        1
+      ]);
+    }
+  });
+
+  test('build blob', () {
+    {
+      var flx = Builder()..addBlob(Uint8List.fromList([1, 2, 3]).buffer);
+      expect(flx.finish(), [3, 1, 2, 3, 3, 100, 1]);
+    }
+  });
+
+  test('build from object', () {
+    expect(
+        Builder.buildFromObject(Uint8List.fromList([1, 2, 3]).buffer)
+            .asUint8List(),
+        [3, 1, 2, 3, 3, 100, 1]);
+    expect(Builder.buildFromObject(null).asUint8List(), [0, 0, 1]);
+    expect(Builder.buildFromObject(true).asUint8List(), [1, 104, 1]);
+    expect(Builder.buildFromObject(false).asUint8List(), [0, 104, 1]);
+    expect(Builder.buildFromObject(25).asUint8List(), [25, 4, 1]);
+    expect(Builder.buildFromObject(-250).asUint8List(), [6, 255, 5, 2]);
+    expect(
+        Builder.buildFromObject(-2.50).asUint8List(), [0, 0, 32, 192, 14, 4]);
+    expect(Builder.buildFromObject('Maxim').asUint8List(),
+        [5, 77, 97, 120, 105, 109, 0, 6, 20, 1]);
+    expect(
+        Builder.buildFromObject([1, 3.3, 'max', true, null, false])
+            .asUint8List(),
+        [
+          3,
+          109,
+          97,
+          120,
+          0,
+          0,
+          0,
+          0,
+          6,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          102,
+          102,
+          102,
+          102,
+          102,
+          102,
+          10,
+          64,
+          31,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          4,
+          15,
+          20,
+          104,
+          0,
+          104,
+          54,
+          43,
+          1
+        ]);
+    expect(
+        Builder.buildFromObject([
+          {'something': 12},
+          {'something': 45}
+        ]).asUint8List(),
+        [
+          115,
+          111,
+          109,
+          101,
+          116,
+          104,
+          105,
+          110,
+          103,
+          0,
+          1,
+          11,
+          1,
+          1,
+          1,
+          12,
+          4,
+          6,
+          1,
+          1,
+          45,
+          4,
+          2,
+          8,
+          4,
+          36,
+          36,
+          4,
+          40,
+          1
+        ]);
+  });
+
+  test('add double indirectly', () {
+    var flx = Builder()..addDoubleIndirectly(0.1);
+    expect(flx.finish(), [154, 153, 153, 153, 153, 153, 185, 63, 8, 35, 1]);
+  });
+
+  test('add double indirectly to vector with cache', () {
+    var flx = Builder()
+      ..startVector()
+      ..addDoubleIndirectly(0.1, cache: true)
+      ..addDoubleIndirectly(0.1, cache: true)
+      ..addDoubleIndirectly(0.1, cache: true)
+      ..addDoubleIndirectly(0.1, cache: true)
+      ..end();
+    expect(flx.finish(), [
+      154,
+      153,
+      153,
+      153,
+      153,
+      153,
+      185,
+      63,
+      4,
+      9,
+      10,
+      11,
+      12,
+      35,
+      35,
+      35,
+      35,
+      8,
+      40,
+      1
+    ]);
+  });
+
+  test('add int indirectly', () {
+    var flx = Builder()..addIntIndirectly(2345234523452345);
+    expect(flx.finish(), [185, 115, 175, 118, 250, 84, 8, 0, 8, 27, 1]);
+  });
+
+  test('add int indirectly to vector with cache', () {
+    var flx = Builder()
+      ..startVector()
+      ..addIntIndirectly(2345234523452345, cache: true)
+      ..addIntIndirectly(2345234523452345, cache: true)
+      ..addIntIndirectly(2345234523452345, cache: true)
+      ..addIntIndirectly(2345234523452345, cache: true)
+      ..end();
+    expect(flx.finish(), [
+      185,
+      115,
+      175,
+      118,
+      250,
+      84,
+      8,
+      0,
+      4,
+      9,
+      10,
+      11,
+      12,
+      27,
+      27,
+      27,
+      27,
+      8,
+      40,
+      1
+    ]);
+  });
+
+  test('snapshot', () {
+    var flx = Builder();
+    flx.startVector();
+    flx.addInt(12);
+    expect(flx.snapshot().asUint8List(), [1, 12, 1, 44, 1]);
+    flx.addInt(24);
+    expect(flx.snapshot().asUint8List(), [12, 24, 2, 64, 1]);
+    flx.addInt(45);
+    expect(flx.snapshot().asUint8List(), [12, 24, 45, 3, 76, 1]);
+  });
+}

dart/test/flex_reader_test.dart

@@ -0,0 +1,990 @@
+import 'dart:typed_data';
+
+import 'package:flat_buffers/flex_buffers.dart' show Reference, Builder;
+import 'package:test/test.dart';
+
+void main() {
+  test('is null', () {
+    expect(Reference.fromBuffer(b([0, 0, 1])).isNull, isTrue);
+  });
+
+  test('bool value', () {
+    expect(Reference.fromBuffer(b([1, 104, 1])).boolValue, isTrue);
+    expect(Reference.fromBuffer(b([0, 104, 1])).boolValue, isFalse);
+  });
+  test('int value', () {
+    expect(Reference.fromBuffer(b([25, 4, 1])).intValue, 25);
+    expect(Reference.fromBuffer(b([231, 4, 1])).intValue, -25);
+    expect(Reference.fromBuffer(b([230, 8, 1])).intValue, 230);
+    expect(Reference.fromBuffer(b([230, 0, 5, 2])).intValue, 230);
+    expect(Reference.fromBuffer(b([1, 4, 5, 2])).intValue, 1025);
+    expect(Reference.fromBuffer(b([255, 251, 5, 2])).intValue, -1025);
+    expect(Reference.fromBuffer(b([1, 4, 9, 2])).intValue, 1025);
+    expect(Reference.fromBuffer(b([255, 255, 255, 127, 6, 4])).intValue,
+        2147483647);
+    expect(Reference.fromBuffer(b([0, 0, 0, 128, 6, 4])).intValue, -2147483648);
+    expect(
+        Reference.fromBuffer(b([255, 255, 255, 255, 0, 0, 0, 0, 7, 8]))
+            .intValue,
+        4294967295);
+    expect(
+        Reference.fromBuffer(b([255, 255, 255, 255, 255, 255, 255, 127, 7, 8]))
+            .intValue,
+        9223372036854775807);
+    expect(Reference.fromBuffer(b([0, 0, 0, 0, 0, 0, 0, 128, 7, 8])).intValue,
+        -9223372036854775808);
+    // Dart does not really support UInt64
+//      expect(FlxValue.fromBuffer(b([255, 255, 255, 255, 255, 255, 255, 255, 11, 8])).intValue, 18446744073709551615);
+  });
+  test('double value', () {
+    expect(Reference.fromBuffer(b([0, 0, 144, 64, 14, 4])).doubleValue, 4.5);
+    expect(Reference.fromBuffer(b([205, 204, 204, 61, 14, 4])).doubleValue,
+        closeTo(.1, .001));
+    expect(
+        Reference.fromBuffer(b([154, 153, 153, 153, 153, 153, 185, 63, 15, 8]))
+            .doubleValue,
+        .1);
+  });
+  test('num value', () {
+    expect(Reference.fromBuffer(b([0, 0, 144, 64, 14, 4])).numValue, 4.5);
+    expect(Reference.fromBuffer(b([205, 204, 204, 61, 14, 4])).numValue,
+        closeTo(.1, .001));
+    expect(
+        Reference.fromBuffer(b([154, 153, 153, 153, 153, 153, 185, 63, 15, 8]))
+            .numValue,
+        .1);
+    expect(Reference.fromBuffer(b([255, 251, 5, 2])).numValue, -1025);
+  });
+  test('string value', () {
+    expect(
+        Reference.fromBuffer(b([5, 77, 97, 120, 105, 109, 0, 6, 20, 1]))
+            .stringValue,
+        'Maxim');
+    expect(
+        Reference.fromBuffer(b([
+          10,
+          104,
+          101,
+          108,
+          108,
+          111,
+          32,
+          240,
+          159,
+          152,
+          177,
+          0,
+          11,
+          20,
+          1
+        ])).stringValue,
+        'hello 😱');
+  });
+  test('blob value', () {
+    expect(
+        Reference.fromBuffer(b([3, 1, 2, 3, 3, 100, 1])).blobValue, [1, 2, 3]);
+  });
+  test('bool vector', () {
+    var flx = Reference.fromBuffer(b([3, 1, 0, 1, 3, 144, 1]));
+    expect(flx[0].boolValue, true);
+    expect(flx[1].boolValue, false);
+    expect(flx[2].boolValue, true);
+  });
+  test('number vector', () {
+    testNumbers([3, 1, 2, 3, 3, 44, 1], [1, 2, 3]);
+    testNumbers([3, 255, 2, 3, 3, 44, 1], [-1, 2, 3]);
+    testNumbers([3, 0, 1, 0, 43, 2, 3, 0, 6, 45, 1], [1, 555, 3]);
+    testNumbers([3, 0, 0, 0, 1, 0, 0, 0, 204, 216, 0, 0, 3, 0, 0, 0, 12, 46, 1],
+        [1, 55500, 3]);
+    testNumbers([
+      3,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      172,
+      128,
+      94,
+      239,
+      12,
+      0,
+      0,
+      0,
+      3,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      24,
+      47,
+      1
+    ], [
+      1,
+      55555555500,
+      3
+    ]);
+    testNumbers(
+        [3, 0, 0, 0, 0, 0, 192, 63, 0, 0, 32, 64, 0, 0, 96, 64, 12, 54, 1],
+        [1.5, 2.5, 3.5]);
+    testNumbers([
+      3,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      154,
+      153,
+      153,
+      153,
+      153,
+      153,
+      241,
+      63,
+      154,
+      153,
+      153,
+      153,
+      153,
+      153,
+      1,
+      64,
+      102,
+      102,
+      102,
+      102,
+      102,
+      102,
+      10,
+      64,
+      24,
+      55,
+      1
+    ], [
+      1.1,
+      2.2,
+      3.3
+    ]);
+  });
+  test('number vector, fixed type', () {
+    testNumbers([1, 2, 2, 64, 1], [1, 2]);
+    testNumbers([255, 255, 0, 1, 4, 65, 1], [-1, 256]);
+    testNumbers([211, 255, 255, 255, 0, 232, 3, 0, 8, 66, 1], [-45, 256000]);
+    testNumbers([
+      211,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      127,
+      16,
+      67,
+      1
+    ], [
+      -45,
+      9223372036854775807
+    ]);
+
+    testNumbers([1, 2, 2, 68, 1], [1, 2]);
+    testNumbers([1, 0, 0, 1, 4, 69, 1], [1, 256]);
+    testNumbers([45, 0, 0, 0, 0, 232, 3, 0, 8, 70, 1], [45, 256000]);
+
+    testNumbers([205, 204, 140, 63, 0, 0, 0, 192, 8, 74, 1], [1.1, -2]);
+    testNumbers([
+      154,
+      153,
+      153,
+      153,
+      153,
+      153,
+      241,
+      63,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      112,
+      192,
+      16,
+      75,
+      1
+    ], [
+      1.1,
+      -256
+    ]);
+
+    testNumbers([211, 255, 255, 255, 0, 232, 3, 0, 4, 0, 0, 0, 12, 78, 1],
+        [-45, 256000, 4]);
+
+    testNumbers([
+      211,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      127,
+      4,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      9,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      32,
+      91,
+      1
+    ], [
+      -45,
+      9223372036854775807,
+      4,
+      9
+    ]);
+
+    testNumbers([
+      45,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      127,
+      4,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      9,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      32,
+      95,
+      1
+    ], [
+      45,
+      9223372036854775807,
+      4,
+      9
+    ]);
+
+    testNumbers([
+      154,
+      153,
+      153,
+      153,
+      153,
+      153,
+      241,
+      63,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      112,
+      64,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      16,
+      64,
+      24,
+      87,
+      1
+    ], [
+      1.1,
+      256,
+      4
+    ]);
+
+    testNumbers([
+      154,
+      153,
+      153,
+      153,
+      153,
+      153,
+      241,
+      63,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      112,
+      64,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      16,
+      64,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      34,
+      64,
+      32,
+      99,
+      1
+    ], [
+      1.1,
+      256,
+      4,
+      9
+    ]);
+  });
+  test('string vector', () {
+    testStrings([
+      3,
+      102,
+      111,
+      111,
+      0,
+      3,
+      98,
+      97,
+      114,
+      0,
+      3,
+      98,
+      97,
+      122,
+      0,
+      3,
+      15,
+      11,
+      7,
+      3,
+      60,
+      1
+    ], [
+      'foo',
+      'bar',
+      'baz'
+    ]);
+    testStrings([
+      3,
+      102,
+      111,
+      111,
+      0,
+      3,
+      98,
+      97,
+      114,
+      0,
+      3,
+      98,
+      97,
+      122,
+      0,
+      6,
+      15,
+      11,
+      7,
+      18,
+      14,
+      10,
+      6,
+      60,
+      1
+    ], [
+      'foo',
+      'bar',
+      'baz',
+      'foo',
+      'bar',
+      'baz'
+    ]);
+  });
+  test('mixed vector', () {
+    var flx = Reference.fromBuffer(b([
+      3,
+      102,
+      111,
+      111,
+      0,
+      0,
+      0,
+      0,
+      5,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      15,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      251,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      205,
+      204,
+      204,
+      204,
+      204,
+      204,
+      244,
+      63,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      20,
+      4,
+      4,
+      15,
+      104,
+      45,
+      43,
+      1
+    ]));
+    expect(flx.length, 5);
+    expect(flx[0].stringValue, 'foo');
+    expect(flx[1].numValue, 1);
+    expect(flx[2].numValue, -5);
+    expect(flx[3].numValue, 1.3);
+    expect(flx[4].boolValue, true);
+  });
+
+  test('single value map', () {
+    var flx = Reference.fromBuffer(b([97, 0, 1, 3, 1, 1, 1, 12, 4, 2, 36, 1]));
+    expect(flx.length, 1);
+    expect(flx['a'].numValue, 12);
+  });
+  test('two value map', () {
+    var flx = Reference.fromBuffer(
+        b([0, 97, 0, 2, 4, 4, 2, 1, 2, 45, 12, 4, 4, 4, 36, 1]));
+    expect(flx.length, 2);
+    expect(flx['a'].numValue, 12);
+    expect(flx[''].numValue, 45);
+  });
+  test('complex map', () {
+    var flx = complexMap();
+    expect(flx.length, 5);
+    expect(flx['age'].numValue, 35);
+    expect(flx['weight'].numValue, 72.5);
+    expect(flx['name'].stringValue, 'Maxim');
+
+    expect(flx['flags'].length, 4);
+    expect(flx['flags'][0].boolValue, true);
+    expect(flx['flags'][1].boolValue, false);
+    expect(flx['flags'][2].boolValue, true);
+    expect(flx['flags'][3].boolValue, true);
+
+    expect(flx['address'].length, 3);
+    expect(flx['address']['city'].stringValue, 'Bla');
+    expect(flx['address']['zip'].stringValue, '12345');
+    expect(flx['address']['countryCode'].stringValue, 'XX');
+
+    expect(
+        () => flx['address']['country'].stringValue,
+        throwsA(predicate((dynamic e) =>
+            e is ArgumentError &&
+            e.message ==
+                'Key: [country] is not applicable on: //address of: ValueType.Map')));
+    expect(
+        () => flx['address']['countryCode'][0],
+        throwsA(predicate((dynamic e) =>
+            e is ArgumentError &&
+            e.message ==
+                'Key: [0] is not applicable on: //address/countryCode of: ValueType.String')));
+    expect(
+        () => flx[1],
+        throwsA(predicate((dynamic e) =>
+            e is ArgumentError &&
+            e.message ==
+                'Key: [1] is not applicable on: / of: ValueType.Map')));
+    expect(
+        () => flx['flags'][4],
+        throwsA(predicate((dynamic e) =>
+            e is ArgumentError &&
+            e.message ==
+                'Key: [4] is not applicable on: //flags of: ValueType.VectorBool length: 4')));
+    expect(
+        () => flx['flags'][-1],
+        throwsA(predicate((dynamic e) =>
+            e is ArgumentError &&
+            e.message ==
+                'Key: [-1] is not applicable on: //flags of: ValueType.VectorBool length: 4')));
+  });
+  test('complex map to json', () {
+    var flx = complexMap();
+    expect(flx.json,
+        '{"address":{"city":"Bla","countryCode":"XX","zip":"12345"},"age":35,"flags":[true,false,true,true],"name":"Maxim","weight":72.5}');
+  });
+
+  test('complex map iterators', () {
+    var flx = complexMap();
+    expect(flx.mapKeyIterable.map((e) => e).toList(),
+        ['address', 'age', 'flags', 'name', 'weight']);
+    expect(flx.mapValueIterable.map((e) => e.json).toList(), [
+      flx['address'].json,
+      flx['age'].json,
+      flx['flags'].json,
+      flx['name'].json,
+      flx['weight'].json
+    ]);
+    expect(flx['flags'].vectorIterable.map((e) => e.boolValue).toList(),
+        [true, false, true, true]);
+  });
+
+  test('bug where offest were stored as int instead of uint', () {
+    const data = [
+      99,
+      104,
+      97,
+      110,
+      110,
+      101,
+      108,
+      115,
+      95,
+      105,
+      110,
+      0,
+      100,
+      105,
+      108,
+      97,
+      116,
+      105,
+      111,
+      110,
+      95,
+      104,
+      101,
+      105,
+      103,
+      104,
+      116,
+      95,
+      102,
+      97,
+      99,
+      116,
+      111,
+      114,
+      0,
+      100,
+      105,
+      108,
+      97,
+      116,
+      105,
+      111,
+      110,
+      95,
+      119,
+      105,
+      100,
+      116,
+      104,
+      95,
+      102,
+      97,
+      99,
+      116,
+      111,
+      114,
+      0,
+      102,
+      117,
+      115,
+      101,
+      100,
+      95,
+      97,
+      99,
+      116,
+      105,
+      118,
+      97,
+      116,
+      105,
+      111,
+      110,
+      95,
+      102,
+      117,
+      110,
+      99,
+      116,
+      105,
+      111,
+      110,
+      0,
+      112,
+      97,
+      100,
+      95,
+      118,
+      97,
+      108,
+      117,
+      101,
+      115,
+      0,
+      112,
+      97,
+      100,
+      100,
+      105,
+      110,
+      103,
+      0,
+      115,
+      116,
+      114,
+      105,
+      100,
+      101,
+      95,
+      104,
+      101,
+      105,
+      103,
+      104,
+      116,
+      0,
+      115,
+      116,
+      114,
+      105,
+      100,
+      101,
+      95,
+      119,
+      105,
+      100,
+      116,
+      104,
+      0,
+      8,
+      130,
+      119,
+      97,
+      76,
+      51,
+      41,
+      34,
+      21,
+      8,
+      1,
+      8,
+      64,
+      1,
+      1,
+      1,
+      1,
+      0,
+      1,
+      1,
+      4,
+      4,
+      4,
+      4,
+      4,
+      4,
+      4,
+      4,
+      16,
+      36,
+      1
+    ];
+    var flx = Reference.fromBuffer(b(data));
+    expect(flx.json,
+        '{"channels_in":64,"dilation_height_factor":1,"dilation_width_factor":1,"fused_activation_function":1,"pad_values":1,"padding":0,"stride_height":1,"stride_width":1}');
+    const object = {
+      "channels_in": 64,
+      "dilation_height_factor": 1,
+      "dilation_width_factor": 1,
+      "fused_activation_function": 1,
+      "pad_values": 1,
+      "padding": 0,
+      "stride_height": 1,
+      "stride_width": 1
+    };
+    var data1 = Builder.buildFromObject(object).asUint8List();
+    expect(data1.length, data.length);
+    var flx1 = Reference.fromBuffer(b(data1));
+    expect(flx1.json,
+        '{"channels_in":64,"dilation_height_factor":1,"dilation_width_factor":1,"fused_activation_function":1,"pad_values":1,"padding":0,"stride_height":1,"stride_width":1}');
+  });
+}
+
+ByteBuffer b(List<int> values) {
+  var data = Uint8List.fromList(values);
+  return data.buffer;
+}
+
+void testNumbers(List<int> buffer, List<num> numbers) {
+  var flx = Reference.fromBuffer(b(buffer));
+  expect(flx.length, numbers.length);
+  for (var i = 0; i < flx.length; i++) {
+    expect(flx[i].numValue, closeTo(numbers[i], 0.001));
+  }
+}
+
+void testStrings(List<int> buffer, List<String> numbers) {
+  var flx = Reference.fromBuffer(b(buffer));
+  expect(flx.length, numbers.length);
+  for (var i = 0; i < flx.length; i++) {
+    expect(flx[i].stringValue, numbers[i]);
+  }
+}
+
+Reference complexMap() {
+//  {
+//    "age": 35,
+//    "flags": [True, False, True, True],
+//    "weight": 72.5,
+//    "name": "Maxim",
+//    "address": {
+//      "city": "Bla",
+//      "zip": "12345",
+//      "countryCode": "XX",
+//    }
+//  }
+  return Reference.fromBuffer(b([
+    97,
+    100,
+    100,
+    114,
+    101,
+    115,
+    115,
+    0,
+    99,
+    105,
+    116,
+    121,
+    0,
+    3,
+    66,
+    108,
+    97,
+    0,
+    99,
+    111,
+    117,
+    110,
+    116,
+    114,
+    121,
+    67,
+    111,
+    100,
+    101,
+    0,
+    2,
+    88,
+    88,
+    0,
+    122,
+    105,
+    112,
+    0,
+    5,
+    49,
+    50,
+    51,
+    52,
+    53,
+    0,
+    3,
+    38,
+    29,
+    14,
+    3,
+    1,
+    3,
+    38,
+    22,
+    15,
+    20,
+    20,
+    20,
+    97,
+    103,
+    101,
+    0,
+    102,
+    108,
+    97,
+    103,
+    115,
+    0,
+    4,
+    1,
+    0,
+    1,
+    1,
+    110,
+    97,
+    109,
+    101,
+    0,
+    5,
+    77,
+    97,
+    120,
+    105,
+    109,
+    0,
+    119,
+    101,
+    105,
+    103,
+    104,
+    116,
+    0,
+    5,
+    93,
+    36,
+    33,
+    23,
+    12,
+    0,
+    0,
+    7,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    5,
+    0,
+    0,
+    0,
+    60,
+    0,
+    0,
+    0,
+    35,
+    0,
+    0,
+    0,
+    51,
+    0,
+    0,
+    0,
+    45,
+    0,
+    0,
+    0,
+    0,
+    0,
+    145,
+    66,
+    36,
+    4,
+    144,
+    20,
+    14,
+    25,
+    38,
+    1
+  ]));
+}

dart/test/flex_types_test.dart

@@ -0,0 +1,184 @@
+import 'package:flat_buffers/src/types.dart';
+import 'package:test/test.dart';
+
+void main() {
+  test('is inline', () {
+    expect(ValueTypeUtils.isInline(ValueType.Bool), isTrue);
+    expect(ValueTypeUtils.isInline(ValueType.Int), isTrue);
+    expect(ValueTypeUtils.isInline(ValueType.UInt), isTrue);
+    expect(ValueTypeUtils.isInline(ValueType.Float), isTrue);
+    expect(ValueTypeUtils.isInline(ValueType.Null), isTrue);
+    expect(ValueTypeUtils.isInline(ValueType.String), isFalse);
+  });
+  test('is type vector element', () {
+    expect(ValueTypeUtils.isTypedVectorElement(ValueType.Bool), isTrue);
+    expect(ValueTypeUtils.isTypedVectorElement(ValueType.Int), isTrue);
+    expect(ValueTypeUtils.isTypedVectorElement(ValueType.UInt), isTrue);
+    expect(ValueTypeUtils.isTypedVectorElement(ValueType.Float), isTrue);
+    expect(ValueTypeUtils.isTypedVectorElement(ValueType.Key), isTrue);
+    expect(ValueTypeUtils.isTypedVectorElement(ValueType.String), isTrue);
+
+    expect(ValueTypeUtils.isTypedVectorElement(ValueType.Null), isFalse);
+    expect(ValueTypeUtils.isTypedVectorElement(ValueType.Blob), isFalse);
+  });
+  test('is typed vector', () {
+    expect(ValueTypeUtils.isTypedVector(ValueType.VectorInt), isTrue);
+    expect(ValueTypeUtils.isTypedVector(ValueType.VectorUInt), isTrue);
+    expect(ValueTypeUtils.isTypedVector(ValueType.VectorFloat), isTrue);
+    expect(ValueTypeUtils.isTypedVector(ValueType.VectorBool), isTrue);
+    expect(ValueTypeUtils.isTypedVector(ValueType.VectorKey), isTrue);
+    expect(ValueTypeUtils.isTypedVector(ValueType.VectorString), isTrue);
+
+    expect(ValueTypeUtils.isTypedVector(ValueType.Vector), isFalse);
+    expect(ValueTypeUtils.isTypedVector(ValueType.Map), isFalse);
+    expect(ValueTypeUtils.isTypedVector(ValueType.Bool), isFalse);
+    expect(ValueTypeUtils.isTypedVector(ValueType.VectorInt2), isFalse);
+  });
+  test('is fixed typed vector', () {
+    expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorInt2), isTrue);
+    expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorInt3), isTrue);
+    expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorInt4), isTrue);
+    expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorUInt2), isTrue);
+    expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorUInt3), isTrue);
+    expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorUInt4), isTrue);
+    expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorFloat2), isTrue);
+    expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorFloat3), isTrue);
+    expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorFloat4), isTrue);
+
+    expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorInt), isFalse);
+  });
+  test('to typed vector', () {
+    expect(ValueTypeUtils.toTypedVector(ValueType.Int, 0),
+        equals(ValueType.VectorInt));
+    expect(ValueTypeUtils.toTypedVector(ValueType.UInt, 0),
+        equals(ValueType.VectorUInt));
+    expect(ValueTypeUtils.toTypedVector(ValueType.Bool, 0),
+        equals(ValueType.VectorBool));
+    expect(ValueTypeUtils.toTypedVector(ValueType.Float, 0),
+        equals(ValueType.VectorFloat));
+    expect(ValueTypeUtils.toTypedVector(ValueType.Key, 0),
+        equals(ValueType.VectorKey));
+    expect(ValueTypeUtils.toTypedVector(ValueType.String, 0),
+        equals(ValueType.VectorString));
+
+    expect(ValueTypeUtils.toTypedVector(ValueType.Int, 2),
+        equals(ValueType.VectorInt2));
+    expect(ValueTypeUtils.toTypedVector(ValueType.UInt, 2),
+        equals(ValueType.VectorUInt2));
+    expect(ValueTypeUtils.toTypedVector(ValueType.Float, 2),
+        equals(ValueType.VectorFloat2));
+
+    expect(ValueTypeUtils.toTypedVector(ValueType.Int, 3),
+        equals(ValueType.VectorInt3));
+    expect(ValueTypeUtils.toTypedVector(ValueType.UInt, 3),
+        equals(ValueType.VectorUInt3));
+    expect(ValueTypeUtils.toTypedVector(ValueType.Float, 3),
+        equals(ValueType.VectorFloat3));
+
+    expect(ValueTypeUtils.toTypedVector(ValueType.Int, 4),
+        equals(ValueType.VectorInt4));
+    expect(ValueTypeUtils.toTypedVector(ValueType.UInt, 4),
+        equals(ValueType.VectorUInt4));
+    expect(ValueTypeUtils.toTypedVector(ValueType.Float, 4),
+        equals(ValueType.VectorFloat4));
+  });
+  test('typed vector element type', () {
+    expect(ValueTypeUtils.typedVectorElementType(ValueType.VectorInt),
+        equals(ValueType.Int));
+    expect(ValueTypeUtils.typedVectorElementType(ValueType.VectorUInt),
+        equals(ValueType.UInt));
+    expect(ValueTypeUtils.typedVectorElementType(ValueType.VectorFloat),
+        equals(ValueType.Float));
+    expect(ValueTypeUtils.typedVectorElementType(ValueType.VectorString),
+        equals(ValueType.String));
+    expect(ValueTypeUtils.typedVectorElementType(ValueType.VectorKey),
+        equals(ValueType.Key));
+    expect(ValueTypeUtils.typedVectorElementType(ValueType.VectorBool),
+        equals(ValueType.Bool));
+  });
+  test('fixed typed vector element type', () {
+    expect(ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorInt2),
+        equals(ValueType.Int));
+    expect(ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorInt3),
+        equals(ValueType.Int));
+    expect(ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorInt4),
+        equals(ValueType.Int));
+
+    expect(ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorUInt2),
+        equals(ValueType.UInt));
+    expect(ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorUInt3),
+        equals(ValueType.UInt));
+    expect(ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorUInt4),
+        equals(ValueType.UInt));
+
+    expect(ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorFloat2),
+        equals(ValueType.Float));
+    expect(ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorFloat3),
+        equals(ValueType.Float));
+    expect(ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorFloat4),
+        equals(ValueType.Float));
+  });
+  test('fixed typed vector element size', () {
+    expect(ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorInt2),
+        equals(2));
+    expect(ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorInt3),
+        equals(3));
+    expect(ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorInt4),
+        equals(4));
+
+    expect(ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorUInt2),
+        equals(2));
+    expect(ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorUInt3),
+        equals(3));
+    expect(ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorUInt4),
+        equals(4));
+
+    expect(ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorFloat2),
+        equals(2));
+    expect(ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorFloat3),
+        equals(3));
+    expect(ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorFloat4),
+        equals(4));
+  });
+  test('packed type', () {
+    expect(
+        ValueTypeUtils.packedType(ValueType.Null, BitWidth.width8), equals(0));
+    expect(
+        ValueTypeUtils.packedType(ValueType.Null, BitWidth.width16), equals(1));
+    expect(
+        ValueTypeUtils.packedType(ValueType.Null, BitWidth.width32), equals(2));
+    expect(
+        ValueTypeUtils.packedType(ValueType.Null, BitWidth.width64), equals(3));
+
+    expect(
+        ValueTypeUtils.packedType(ValueType.Int, BitWidth.width8), equals(4));
+    expect(
+        ValueTypeUtils.packedType(ValueType.Int, BitWidth.width16), equals(5));
+    expect(
+        ValueTypeUtils.packedType(ValueType.Int, BitWidth.width32), equals(6));
+    expect(
+        ValueTypeUtils.packedType(ValueType.Int, BitWidth.width64), equals(7));
+  });
+  test('bit width', () {
+    expect(BitWidthUtil.width(0), BitWidth.width8);
+    expect(BitWidthUtil.width(-20), BitWidth.width8);
+    expect(BitWidthUtil.width(127), BitWidth.width8);
+    expect(BitWidthUtil.width(128), BitWidth.width16);
+    expect(BitWidthUtil.width(128123), BitWidth.width32);
+    expect(BitWidthUtil.width(12812324534), BitWidth.width64);
+    expect(BitWidthUtil.width(-127), BitWidth.width8);
+    expect(BitWidthUtil.width(-128), BitWidth.width16);
+    expect(BitWidthUtil.width(-12812324534), BitWidth.width64);
+    expect(BitWidthUtil.width(-0.1), BitWidth.width64);
+    expect(BitWidthUtil.width(0.25), BitWidth.width32);
+  });
+  test('padding size', () {
+    expect(BitWidthUtil.paddingSize(10, 8), 6);
+    expect(BitWidthUtil.paddingSize(10, 4), 2);
+    expect(BitWidthUtil.paddingSize(15, 4), 1);
+    expect(BitWidthUtil.paddingSize(15, 2), 1);
+    expect(BitWidthUtil.paddingSize(15, 1), 0);
+    expect(BitWidthUtil.paddingSize(16, 8), 0);
+    expect(BitWidthUtil.paddingSize(17, 8), 7);
+  });
+}

dart/test/monster_test.fbs

@@ -0,0 +1,154 @@
+// test schema file
+
+include "include_test1.fbs";
+
+namespace MyGame;
+
+table InParentNamespace {}
+
+namespace MyGame.Example2;
+
+table Monster {}  // Test having same name as below, but in different namespace.
+
+namespace MyGame.Example;
+
+attribute "priority";
+
+/// Composite components of Monster color.
+enum Color:ubyte (bit_flags) {
+  Red = 0, // color Red = (1u << 0)
+  /// \brief color Green
+  /// Green is bit_flag with value (1u << 1)
+  Green,
+  /// \brief color Blue (1u << 3)
+  Blue = 3,
+}
+
+enum Race:byte {
+  None = -1,
+  Human = 0,
+  Dwarf,
+  Elf,
+}
+
+union Any { Monster, TestSimpleTableWithEnum, MyGame.Example2.Monster }
+
+union AnyUniqueAliases { M: Monster, TS: TestSimpleTableWithEnum, M2: MyGame.Example2.Monster }
+union AnyAmbiguousAliases { M1: Monster, M2: Monster, M3: Monster }
+
+struct Test { a:short; b:byte; }
+
+table TestSimpleTableWithEnum (csharp_partial, private) {
+  color: Color = Green;
+}
+
+struct Vec3 (force_align: 8) {
+  x:float;
+  y:float;
+  z:float;
+  test1:double;
+  test2:Color;
+  test3:Test;
+}
+
+struct Ability {
+  id:uint(key);
+  distance:uint;
+}
+
+struct StructOfStructs {
+  a: Ability;
+  b: Test;
+  c: Ability;
+}
+
+table Stat {
+  id:string;
+  val:long;
+  count:ushort (key);
+}
+
+table Referrable {
+  id:ulong(key, hash:"fnv1a_64");
+}
+
+/// an example documentation comment: "monster object"
+table Monster {
+  pos:Vec3 (id: 0);
+  hp:short = 100 (id: 2);
+  mana:short = 150 (id: 1);
+  name:string (id: 3, key);
+  color:Color = Blue (id: 6);
+  inventory:[ubyte] (id: 5);
+  friendly:bool = false (deprecated, priority: 1, id: 4);
+  /// an example documentation comment: this will end up in the generated code
+  /// multiline too
+  testarrayoftables:[Monster] (id: 11);
+  testarrayofstring:[string] (id: 10);
+  testarrayofstring2:[string] (id: 28);
+  testarrayofbools:[bool] (id: 24);
+  testarrayofsortedstruct:[Ability] (id: 29);
+  enemy:MyGame.Example.Monster (id:12);  // Test referring by full namespace.
+  test:Any (id: 8);
+  test4:[Test] (id: 9);
+  test5:[Test] (id: 31);
+  testnestedflatbuffer:[ubyte] (id:13, nested_flatbuffer: "Monster");
+  testempty:Stat (id:14);
+  testbool:bool (id:15);
+  testhashs32_fnv1:int (id:16, hash:"fnv1_32");
+  testhashu32_fnv1:uint (id:17, hash:"fnv1_32");
+  testhashs64_fnv1:long (id:18, hash:"fnv1_64");
+  testhashu64_fnv1:ulong (id:19, hash:"fnv1_64");
+  testhashs32_fnv1a:int (id:20, hash:"fnv1a_32");
+  testhashu32_fnv1a:uint (id:21, hash:"fnv1a_32", cpp_type:"Stat");
+  testhashs64_fnv1a:long (id:22, hash:"fnv1a_64");
+  testhashu64_fnv1a:ulong (id:23, hash:"fnv1a_64");
+  testf:float = 3.14159 (id:25);
+  testf2:float = 3 (id:26);
+  testf3:float (id:27);
+  flex:[ubyte] (id:30, flexbuffer);
+  vector_of_longs:[long] (id:32);
+  vector_of_doubles:[double] (id:33);
+  parent_namespace_test:InParentNamespace (id:34);
+  vector_of_referrables:[Referrable](id:35);
+  single_weak_reference:ulong(id:36, hash:"fnv1a_64", cpp_type:"ReferrableT");
+  vector_of_weak_references:[ulong](id:37, hash:"fnv1a_64", cpp_type:"ReferrableT");
+  vector_of_strong_referrables:[Referrable](id:38, cpp_ptr_type:"default_ptr_type");                 //was shared_ptr
+  co_owning_reference:ulong(id:39, hash:"fnv1a_64", cpp_type:"ReferrableT", cpp_ptr_type:"naked");  //was shared_ptr as well
+  vector_of_co_owning_references:[ulong](id:40, hash:"fnv1a_64", cpp_type:"ReferrableT", cpp_ptr_type:"default_ptr_type", cpp_ptr_type_get:".get()");  //was shared_ptr
+  non_owning_reference:ulong(id:41, hash:"fnv1a_64", cpp_type:"ReferrableT", cpp_ptr_type:"naked", cpp_ptr_type_get:"");                              //was weak_ptr
+  vector_of_non_owning_references:[ulong](id:42, hash:"fnv1a_64", cpp_type:"ReferrableT", cpp_ptr_type:"naked", cpp_ptr_type_get:"");                 //was weak_ptr
+  any_unique:AnyUniqueAliases(id:44);
+  any_ambiguous:AnyAmbiguousAliases (id:46);
+  vector_of_enums:[Color] (id:47);
+  signed_enum:Race = None (id:48);
+  testrequirednestedflatbuffer:[ubyte] (id:49, nested_flatbuffer: "Monster");
+  scalar_key_sorted_tables:[Stat] (id: 50);
+}
+
+table TypeAliases {
+    i8:int8;
+    u8:uint8;
+    i16:int16;
+    u16:uint16;
+    i32:int32;
+    u32:uint32;
+    i64:int64;
+    u64:uint64;
+    f32:float32;
+    f64:float64;
+    v8:[int8];
+    vf64:[float64];
+}
+
+rpc_service MonsterStorage {
+  Store(Monster):Stat (streaming: "none");
+  Retrieve(Stat):Monster (streaming: "server", idempotent);
+  GetMaxHitPoint(Monster):Stat (streaming: "client");
+  GetMinMaxHitPoints(Monster):Stat (streaming: "bidi");
+}
+
+root_type Monster;
+
+file_identifier "MONS";
+file_extension "mon";

dart/test/monster_test_my_game.example2_generated.dart

@@ -1,24 +1,22 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-// ignore_for_file: unused_import, unused_field, unused_local_variable
+// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable
 
 library my_game.example2;
 
 import 'dart:typed_data' show Uint8List;
 import 'package:flat_buffers/flat_buffers.dart' as fb;
 
-import 'include_test1_my_game.example2_generated.dart';
-import 'include_test2_my_game.example2_generated.dart';
 import './monster_test_my_game_generated.dart' as my_game;
 import './monster_test_my_game.example_generated.dart' as my_game_example;
 
 class Monster {
   Monster._(this._bc, this._bcOffset);
   factory Monster(List<int> bytes) {
-    fb.BufferContext rootRef = new fb.BufferContext.fromBytes(bytes);
+    final rootRef = fb.BufferContext.fromBytes(bytes);
     return reader.read(rootRef, 0);
   }
 
-  static const fb.Reader<Monster> reader = const _MonsterReader();
+  static const fb.Reader<Monster> reader = _MonsterReader();
 
   final fb.BufferContext _bc;
   final int _bcOffset;
@@ -28,6 +26,26 @@ class Monster {
   String toString() {
     return 'Monster{}';
   }
+
+  MonsterT unpack() => MonsterT();
+
+  static int pack(fb.Builder fbBuilder, MonsterT? object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class MonsterT implements fb.Packable {
+  @override
+  int pack(fb.Builder fbBuilder) {
+    fbBuilder.startTable(0);
+    return fbBuilder.endTable();
+  }
+
+  @override
+  String toString() {
+    return 'MonsterT{}';
+  }
 }
 
 class _MonsterReader extends fb.TableReader<Monster> {
@@ -35,7 +53,7 @@ class _MonsterReader extends fb.TableReader<Monster> {
 
   @override
   Monster createObject(fb.BufferContext bc, int offset) => 
-    new Monster._(bc, offset);
+    Monster._(bc, offset);
 }
 
 class MonsterObjectBuilder extends fb.ObjectBuilder {
@@ -44,19 +62,16 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
 
   /// Finish building, and store into the [fbBuilder].
   @override
-  int finish(
-    fb.Builder fbBuilder) {
-    assert(fbBuilder != null);
-
-    fbBuilder.startTable();
+  int finish(fb.Builder fbBuilder) {
+    fbBuilder.startTable(0);
     return fbBuilder.endTable();
   }
 
   /// Convenience method to serialize to byte list.
   @override
-  Uint8List toBytes([String fileIdentifier]) {
-    fb.Builder fbBuilder = new fb.Builder();
-    int offset = finish(fbBuilder);
-    return fbBuilder.finish(offset, fileIdentifier);
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
   }
 }

dart/test/monster_test_my_game_generated.dart

@@ -1,24 +1,22 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-// ignore_for_file: unused_import, unused_field, unused_local_variable
+// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable
 
 library my_game;
 
 import 'dart:typed_data' show Uint8List;
 import 'package:flat_buffers/flat_buffers.dart' as fb;
 
-import 'include_test1_my_game_generated.dart';
-import 'include_test2_my_game_generated.dart';
 import './monster_test_my_game.example_generated.dart' as my_game_example;
 import './monster_test_my_game.example2_generated.dart' as my_game_example2;
 
 class InParentNamespace {
   InParentNamespace._(this._bc, this._bcOffset);
   factory InParentNamespace(List<int> bytes) {
-    fb.BufferContext rootRef = new fb.BufferContext.fromBytes(bytes);
+    final rootRef = fb.BufferContext.fromBytes(bytes);
     return reader.read(rootRef, 0);
   }
 
-  static const fb.Reader<InParentNamespace> reader = const _InParentNamespaceReader();
+  static const fb.Reader<InParentNamespace> reader = _InParentNamespaceReader();
 
   final fb.BufferContext _bc;
   final int _bcOffset;
@@ -28,6 +26,26 @@ class InParentNamespace {
   String toString() {
     return 'InParentNamespace{}';
   }
+
+  InParentNamespaceT unpack() => InParentNamespaceT();
+
+  static int pack(fb.Builder fbBuilder, InParentNamespaceT? object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class InParentNamespaceT implements fb.Packable {
+  @override
+  int pack(fb.Builder fbBuilder) {
+    fbBuilder.startTable(0);
+    return fbBuilder.endTable();
+  }
+
+  @override
+  String toString() {
+    return 'InParentNamespaceT{}';
+  }
 }
 
 class _InParentNamespaceReader extends fb.TableReader<InParentNamespace> {
@@ -35,7 +53,7 @@ class _InParentNamespaceReader extends fb.TableReader<InParentNamespace> {
 
   @override
   InParentNamespace createObject(fb.BufferContext bc, int offset) => 
-    new InParentNamespace._(bc, offset);
+    InParentNamespace._(bc, offset);
 }
 
 class InParentNamespaceObjectBuilder extends fb.ObjectBuilder {
@@ -44,19 +62,16 @@ class InParentNamespaceObjectBuilder extends fb.ObjectBuilder {
 
   /// Finish building, and store into the [fbBuilder].
   @override
-  int finish(
-    fb.Builder fbBuilder) {
-    assert(fbBuilder != null);
-
-    fbBuilder.startTable();
+  int finish(fb.Builder fbBuilder) {
+    fbBuilder.startTable(0);
     return fbBuilder.endTable();
   }
 
   /// Convenience method to serialize to byte list.
   @override
-  Uint8List toBytes([String fileIdentifier]) {
-    fb.Builder fbBuilder = new fb.Builder();
-    int offset = finish(fbBuilder);
-    return fbBuilder.finish(offset, fileIdentifier);
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
   }
 }

docs/source/Building.md

@@ -29,6 +29,27 @@ Building should also produce two sample executables, `flatsamplebinary` and
 *Note that you MUST be in the root of the FlatBuffers distribution when you
 run 'flattests' or `flatsampletext`, or it will fail to load its files.*
 
+### Make all warnings into errors
+
+By default all Flatbuffers `cmake` targets are build with `-Werror` flag.
+With this flag (or `/WX` for MSVC) C++ compiler will treat all warnings as errors.
+Additionally `-Wall -pedantic -Wextra` (or `/W4` form MSVC) flags are set.
+These flags minimize the number of possible defects in code and keep code highly portable.
+Using these flags is considered good practice but sometimes it can break dependent projects 
+if a compiler is upgraded or a toolset is changed.
+Usually, newer compiler versions add new compile-time diagnostics that were unavailable before.
+These new diagnostic warnings could stop the build process if `-Werror` flag is set.
+
+It is possible to cancel `warnings as errors` flag at `cmake` configuration stage using 
+`FLATBUFFERS_CXX_FLAGS` option. Compilation flags declared in `FLATBUFFERS_CXX_FLAGS` will be 
+appended to the project-level `CMAKE_CXX_FLAGS` variable.
+Examples:
+
+- GCC and Clang: `cmake . -D FLATBUFFERS_CXX_FLAGS="-Wno-error"`
+- MSVC: `cmake . -D FLATBUFFERS_CXX_FLAGS="/WX-"`
+- MSVC: `cmake . -D FLATBUFFERS_CXX_FLAGS="/Wv <compiler.version>"`
+
+
 ## Building with VCPKG
 
 You can download and install flatbuffers using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager:

docs/source/CUsage.md

@@ -7,7 +7,7 @@ The `flatcc` C schema compiler can generate code offline as well as
 online via a C library. It can also generate buffer verifiers and fast
 JSON parsers, printers.
 
-Great care has been taken to ensure compatibily with the main `flatc`
+Great care has been taken to ensure compatibility with the main `flatc`
 project.
 
 ## General Documention

docs/source/Compiler.md

@@ -79,7 +79,7 @@ Additional options:
 -   `--allow-non-utf8` : Pass non-UTF-8 input through parser and emit nonstandard
     \x escapes in JSON. (Default is to raise parse error on non-UTF-8 input.)
 
--  `--natural-utf8` : Output strings with UTF-8 as human-readable strings.
+-   `--natural-utf8` : Output strings with UTF-8 as human-readable strings.
      By default, UTF-8 characters are printed as \uXXXX escapes."
 
 -   `--defaults-json` : Output fields whose value is equal to the default value
@@ -116,6 +116,9 @@ Additional options:
 
 -   `--gen-generated` : Add @Generated annotation for Java.
 
+-   `--gen-jvmstatic` : Add @JvmStatic annotation for Kotlin methods
+    in companion object for interop from Java to Kotlin.
+
 -   `--gen-all` : Generate not just code for the current schema files, but
     for all files it includes as well. If the language uses a single file for
     output (by default the case for C++ and JS), all code will end up in
@@ -134,25 +137,19 @@ Additional options:
     std::string from Flatbuffers, but (char* + length). This allows efficient
 	construction of custom string types, including zero-copy construction.
 
+-   `--no-cpp-direct-copy` : Don't generate direct copy methods for C++
+    object-based API.
+
 -   `--cpp-std CPP_STD` : Generate a C++ code using features of selected C++ standard.
      Supported `CPP_STD` values:
-    * `c++0x` - generate code compatible with old compilers (VS2010).
-    * `c++11` - use C++11 code generator (default);
+    * `c++0x` - generate code compatible with old compilers (VS2010),
+    * `c++11` - use C++11 code generator (default),
+    * `c++17` - use C++17 features in generated code (experimental).
 
 -   `--object-prefix` : Customise class prefix for C++ object-based API.
 
 -   `--object-suffix` : Customise class suffix for C++ object-based API.
 
--   `--no-js-exports` : Removes Node.js style export lines (useful for JS)
-
--   `--goog-js-export` :  Uses goog.exportsSymbol and goog.exportsProperty
-    instead of Node.js style exporting.  Needed for compatibility with the
-    Google closure compiler (useful for JS).
-
--   `--es6-js-export` : Generates ECMAScript v6 style export definitions
-    instead of Node.js style exporting. Useful when integrating flatbuffers
-    with modern Javascript projects.
-
 -   `--go-namespace` : Generate the overrided namespace in Golang.
 
 -   `--go-import` : Generate the overrided import for flatbuffers in Golang.
@@ -200,18 +197,14 @@ Additional options:
 
 -   `--keep-prefix` : Keep original prefix of schema include statement.
 
--   `--no-fb-impor` : Don't include flatbuffers import statement for TypeScript.
-
--   `--no-ts-reexpor` : Don't re-export imported dependencies for TypeScript.
-
--   `--short-name` : Use short function names for JS and TypeScript.
-
 -   `--reflect-types` : Add minimal type reflection to code generation.
 
 -   `--reflect-names` : Add minimal type/name reflection.
 
 -   `--root-type T` : Select or override the default root_type.
 
+-   `--require-explicit-ids` : When parsing schemas, require explicit ids (id: x).
+
 -   `--force-defaults` : Emit default values in binary output from JSON.
 
 -   `--force-empty` : When serializing from object API representation, force
@@ -220,5 +213,12 @@ Additional options:
 -   `--force-empty-vectors` : When serializing from object API representation, force
      vectors to empty rather than null.
 
+-   `--flexbuffers` : Used with "binary" and "json" options, it generates
+     data using schema-less FlexBuffers.
+
+-   `--no-warnings` : Inhibit all warning messages.
+
+-   `--cs-global-alias` : Prepend `global::` to all user generated csharp classes and structs.
+
 NOTE: short-form options for generators are deprecated, use the long form
 whenever possible.

docs/source/CppUsage.md

@@ -56,7 +56,7 @@ For example, here is how you would read a FlatBuffer binary file in C++:
 First, include the library and generated code. Then read the file into
 a `char *` array, which you pass to `GetMonster()`.
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
+```cpp
     #include "flatbuffers/flatbuffers.h"
     #include "monster_test_generate.h"
     #include <iostream> // C++ header file for printing
@@ -73,18 +73,18 @@ a `char *` array, which you pass to `GetMonster()`.
     infile.close();
 
     auto monster = GetMonster(data);
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+```
 
 `monster` is of type `Monster *`, and points to somewhere *inside* your
-buffer (root object pointers are not the same as `buffer_pointer` !).
+buffer (root object pointers are not the same as `buffer_pointer` \!).
 If you look in your generated header, you'll see it has
 convenient accessors for all fields, e.g. `hp()`, `mana()`, etc:
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
-    std::cout << "hp : " << monster->hp() << std::endl;            // `80`
-    std::cout << "mana : " << monster->mana() << std::endl;        // default value of `150`
-    std::cout << "name : " << monster->name()->c_str() << std::endl;        // "MyMonster"
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+```cpp
+    std::cout << "hp : " << monster->hp() << std::endl;              // '80'
+    std::cout << "mana : " << monster->mana() << std::endl;          // default value of '150'
+    std::cout << "name : " << monster->name()->c_str() << std::endl; // "MyMonster"
+```
 
 *Note: That we never stored a `mana` value, so it will return the default.*
 
@@ -96,7 +96,7 @@ The following attributes are supported:
     Specifically, `CreateXxxDirect` functions and `Pack` functions for object
     based API (see below) will use `CreateSharedString` to create strings.
 
-## Object based API.  {#flatbuffers_cpp_object_based_api}
+## Object based API  {#flatbuffers_cpp_object_based_api}
 
 FlatBuffers is all about memory efficiency, which is why its base API is written
 around using as little as possible of it. This does make the API clumsier
@@ -109,7 +109,7 @@ construction, access and mutation.
 
 To use:
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
+```cpp
     // Autogenerated class from table Monster.
     MonsterT monsterobj;
 
@@ -117,13 +117,13 @@ To use:
     GetMonster(flatbuffer)->UnPackTo(&monsterobj);
 
     // Update object directly like a C++ class instance.
-    cout << monsterobj->name;  // This is now a std::string!
-    monsterobj->name = "Bob";  // Change the name.
+    cout << monsterobj.name;  // This is now a std::string!
+    monsterobj.name = "Bob";  // Change the name.
 
     // Serialize into new flatbuffer.
     FlatBufferBuilder fbb;
     fbb.Finish(Monster::Pack(fbb, &monsterobj));
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+```
 
 The following attributes are specific to the object-based API code generation:
 
@@ -133,27 +133,30 @@ The following attributes are specific to the object-based API code generation:
     This attribute changes the member declaration to use the type directly
     rather than wrapped in a unique_ptr.
 
--   `native_default`: "value" (on a field): For members that are declared
+-   `native_default("value")` (on a field): For members that are declared
     "native_inline", the value specified with this attribute will be included
     verbatim in the class constructor initializer list for this member.
 
--   `native_custom_alloc`:"custom_allocator" (on a table or struct): When using the
+-   `native_custom_alloc("custom_allocator")` (on a table or struct): When using the
     object-based API all generated NativeTables that  are allocated when unpacking
     your  flatbuffer will use "custom allocator". The allocator is also used by
     any std::vector that appears in a table defined with `native_custom_alloc`.
     This can be  used to provide allocation from a pool for example, for faster
     unpacking when using the object-based API.
 
-    Minimal Example:
+Minimal Example:
 
-    schema:
+schema:
 
+```cpp
     table mytable(native_custom_alloc:"custom_allocator") {
       ...
     }
+```
 
-    with custom_allocator defined before flatbuffers.h is included, as:
+with `custom_allocator` defined before `flatbuffers.h` is included, as:
 
+```cpp
     template <typename T> struct custom_allocator : public std::allocator<T> {
 
       typedef T *pointer;
@@ -172,51 +175,77 @@ The following attributes are specific to the object-based API code generation:
       }
 
       custom_allocator() throw() {}
+
       template <class U>
       custom_allocator(const custom_allocator<U>&) throw() {}
     };
+```
 
--   `native_type`' "type" (on a struct): In some cases, a more optimal C++ data
-    type exists for a given struct.  For example, the following schema:
+-   `native_type("type")` (on a struct): In some cases, a more optimal C++ data
+type exists for a given struct.  For example, the following schema:
 
-      struct Vec2 {
-        x: float;
-        y: float;
-      }
+```cpp
+    struct Vec2 {
+      x: float;
+      y: float;
+    }
+```
 
-    generates the following Object-Based API class:
+generates the following Object-Based API class:
 
-      struct Vec2T : flatbuffers::NativeTable {
-        float x;
-        float y;
-      };
+```cpp
+    struct Vec2T : flatbuffers::NativeTable {
+      float x;
+      float y;
+    };
+```
 
-    However, it can be useful to instead use a user-defined C++ type since it
-    can provide more functionality, eg.
+However, it can be useful to instead use a user-defined C++ type since it
+can provide more functionality, eg.
 
-      struct vector2 {
-        float x = 0, y = 0;
-        vector2 operator+(vector2 rhs) const { ... }
-        vector2 operator-(vector2 rhs) const { ... }
-        float length() const { ... }
-        // etc.
-      };
+```cpp
+    struct vector2 {
+      float x = 0, y = 0;
+      vector2 operator+(vector2 rhs) const { ... }
+      vector2 operator-(vector2 rhs) const { ... }
+      float length() const { ... }
+      // etc.
+    };
+```
 
-    The `native_type` attribute will replace the usage of the generated class
-    with the given type.  So, continuing with the example, the generated
-    code would use |vector2| in place of |Vec2T| for all generated code.
+The `native_type` attribute will replace the usage of the generated class
+with the given type.  So, continuing with the example, the generated
+code would use `vector2` in place of `Vec2T` for all generated code of
+the Object-Based API.
 
-    However, becuase the native_type is unknown to flatbuffers, the user must
-    provide the following functions to aide in the serialization process:
+However, because the `native_type` is unknown to flatbuffers, the user must
+provide the following functions to aide in the serialization process:
 
-      namespace flatbuffers {
-        FlatbufferStruct Pack(const native_type& obj);
-        native_type UnPack(const FlatbufferStruct& obj);
-      }
+```cpp
+    namespace flatbuffers {
+      Vec2 Pack(const vector2& obj);
+      vector2 UnPack(const Vec2& obj);
+    }
+```
 
-Finally, the following top-level attribute
+-   `native_type_pack_name("name")` (on a struct when `native_type` is
+    specified, too): when you want to use the same `native_type` multiple times
+    (e. g. with different precision) you must make the names of the Pack/UnPack
+    functions unique, otherwise you will run into compile errors. This attribute
+    appends a name to the expected Pack/UnPack functions. So when you
+    specify `native_type_pack_name("Vec2")` in the above example you now need to
+    implement these serialization functions instead:
 
--   `native_include`: "path" (at file level): Because the `native_type` attribute
+```cpp
+    namespace flatbuffers {
+      Vec2 PackVec2(const vector2& obj);
+      vector2 UnPackVec2(const Vec2& obj);
+    }
+```
+
+Finally, the following top-level attributes:
+
+-   `native_include("path")` (at file level): Because the `native_type` attribute
     can be used to introduce types that are unknown to flatbuffers, it may be
     necessary to include "external" header files in the generated code.  This
     attribute can be used to directly add an #include directive to the top of
@@ -225,7 +254,7 @@ Finally, the following top-level attribute
 -   `force_align`: this attribute may not be respected in the object API,
     depending on the aligned of the allocator used with `new`.
 
-# External references.
+# External references
 
 An additional feature of the object API is the ability to allow you to load
 multiple independent FlatBuffers, and have them refer to eachothers objects
@@ -244,7 +273,7 @@ same string (or hash).
 When you call `UnPack` (or `Create`), you'll need a function that maps from
 hash to the object (see `resolver_function_t` for details).
 
-# Using different pointer types.
+# Using different pointer types
 
 By default the object tree is built out of `std::unique_ptr`, but you can
 influence this either globally (using the `--cpp-ptr-type` argument to
@@ -255,13 +284,13 @@ you, so you'll have to manage their lifecycles manually.  To reference the
 pointer type specified by the `--cpp-ptr-type` argument to `flatc` from a
 flatbuffer field set the `cpp_ptr_type` attribute to `default_ptr_type`.
 
-# Using different string type.
+# Using different string type
 
 By default the object tree is built out of `std::string`, but you can
 influence this either globally (using the `--cpp-str-type` argument to
 `flatc`) or per field using the `cpp_str_type` attribute.
 
-The type must support T::c_str(), T::length() and T::empty() as member functions.
+The type must support `T::c_str()`, `T::length()` and `T::empty()` as member functions.
 
 Further, the type must be constructible from std::string, as by default a
 std::string instance is constructed and then used to initialize the custom
@@ -270,7 +299,7 @@ custom string types; the `--cpp-str-flex-ctor` argument to `flatc` or the
 per field attribute `cpp_str_flex_ctor` can be used to change this behavior,
 so that the custom string type is constructed by passing the pointer and
 length of the FlatBuffers String. The custom string class will require a
-constructor in the following format: custom_str_class(const char *, size_t).
+constructor in the following format: `custom_str_class(const char *, size_t)`.
 Please note that the character array is not guaranteed to be NULL terminated,
 you should always use the provided size to determine end of string.
 
@@ -281,7 +310,7 @@ read and write data even if you don't know the exact format of a buffer, and
 even allows you to change sizes of strings and vectors in-place.
 
 The way this works is very elegant; there is actually a FlatBuffer schema that
-describes schemas (!) which you can find in `reflection/reflection.fbs`.
+describes schemas (\!) which you can find in `reflection/reflection.fbs`.
 The compiler, `flatc`, can write out any schemas it has just parsed as a binary
 FlatBuffer, corresponding to this meta-schema.
 
@@ -299,7 +328,7 @@ And example of usage, for the time being, can be found in
 ## Mini Reflection
 
 A more limited form of reflection is available for direct inclusion in
-generated code, which doesn't any (binary) schema access at all. It was designed
+generated code, which doesn't do any (binary) schema access at all. It was designed
 to keep the overhead of reflection as low as possible (on the order of 2-6
 bytes per field added to your executable), but doesn't contain all the
 information the (binary) schema contains.
@@ -390,9 +419,9 @@ is accessed, all reads will end up inside the buffer.
 Each root type will have a verification function generated for it,
 e.g. for `Monster`, you can call:
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
+```cpp
 	bool ok = VerifyMonsterBuffer(Verifier(buf, len));
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+```
 
 if `ok` is true, the buffer is safe to read.
 
@@ -458,15 +487,15 @@ Load text (either a schema or json) into an in-memory buffer (there is a
 convenient `LoadFile()` utility function in `flatbuffers/util.h` if you
 wish). Construct a parser:
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
+```cpp
     flatbuffers::Parser parser;
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+```
 
 Now you can parse any number of text files in sequence:
 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
+```cpp
     parser.Parse(text_file.c_str());
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+```
 
 This works similarly to how the command-line compiler works: a sequence
 of files parsed by the same `Parser` object allow later files to
@@ -498,7 +527,7 @@ Creating a FlatBuffer is not thread safe. All state related to building
 a FlatBuffer is contained in a FlatBufferBuilder instance, and no memory
 outside of it is touched. To make this thread safe, either do not
 share instances of FlatBufferBuilder between threads (recommended), or
-manually wrap it in synchronisation primites. There's no automatic way to
+manually wrap it in synchronisation primitives. There's no automatic way to
 accomplish this, by design, as we feel multithreaded construction
 of a single buffer will be rare, and synchronisation overhead would be costly.