More missing version changes

Change-Id: I317d731d17d733088cad608364b614bff8151c36

.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

@@ -6,7 +6,7 @@ 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, be sure to run
-`cd tests && sh generate_code.sh` (or equivalent .bat) and include the generated
+`cd tests && bash 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,

.github/labeler.yml

@@ -0,0 +1,96 @@
+# 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
+
+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,229 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build-linux:
+    name: Build Linux
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        cxx: [g++-9, clang++-9]
+    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: upload build artifacts
+      uses: actions/upload-artifact@v1
+      with:
+        name: Linux flatc binary ${{ matrix.cxx }}
+        path: flatc
+
+  build-windows:
+    name: Build Windows
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: Add msbuild to PATH
+      uses: microsoft/setup-msbuild@v1.0.2
+    - 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-2016
+    steps:
+    - uses: actions/checkout@v1
+    - name: Add msbuild to PATH
+      uses: microsoft/setup-msbuild@v1.0.2
+    - name: cmake
+      run: cmake -G "Visual Studio 15 2017" -A x64 -DCMAKE_BUILD_TYPE=Release .
+    - name: build
+      run: msbuild.exe FlatBuffers.sln /p:Configuration=Release /p:Platform=x64
+    - 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: test
+      run: _build/Release/flattests
+    - 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++-9, clang++-9]
+    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: bash scripts/check-generate-code.sh && bash scripts/check-grpc-generated-code.sh
+
+  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:
+    name: Build Kotlin
+    runs-on: macos-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v1
+    - name: Build
+      working-directory: kotlin  
+      run: ./gradlew clean build allTests
+    - name: Run Benchmark
+      working-directory: kotlin  
+      run: ./gradlew benchmark
+    - 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-js:
+  #  name: Build JS
+  #  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 JavaScriptTest.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-csharp:
+  #  name: Build CSharp
+  #  runs-on: ubuntu-latest
+  #  steps:
+  #  - uses: actions/checkout@v1
+  #  - name: test
+  #    working-directory: tests/FlatBuffers.Test
+  #    run: bash NetTest.sh
+
+  #build-php:
+  #  name: Build PHP
+  #  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: |
+  #      php phpTest.php
+  #      sh phpUnionVectorTest.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

.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,20 @@
+name: Mark stale issues and pull requests
+
+on:
+  schedule:
+  - cron: "30 20 * * *"
+
+jobs:
+  stale:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/stale@v3
+      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

.gitignore

@@ -2,6 +2,7 @@
 *_wire.bin
 .DS_Store
 **/.build
+build
 **/Packages
 /*.xcodeproj
 **/xcuserdata/
@@ -69,8 +70,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/**
@@ -122,6 +121,23 @@ dart/doc/api/
 Cargo.lock
 .corpus**
 .seed**
+.crash**
 grpc/google/
 **/Package.resolved
 .clangd/**
+package-lock.json
+/*.ilk
+/*.pdb
+.clwb
+js/**/*.js
+js/**/*.d.ts
+mjs/**/*.js
+mjs/**/*.d.ts
+yarn-error.log
+.cache/
+/flatbuffers.lib
+.cmake/
+**/dist
+**/vendor
+**/go.sum
+flatbuffers.pc

.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,7 @@ 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
+      - bash scripts/check-generate-code.sh
 
     - language: cpp
       os: osx
@@ -125,6 +126,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 +140,7 @@ 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
+      - bash scripts/check-generate-code.sh
 
     - <<: *conan-linux-master
       env: CONAN_GCC_VERSIONS=8 CONAN_DOCKER_IMAGE=conanio/gcc8
@@ -185,37 +191,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 src/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"],
 )
@@ -27,6 +27,7 @@ filegroup(
         "include/flatbuffers/code_generators.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",

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 0)
+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
+      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

@@ -38,6 +38,11 @@ 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)
 
 if(NOT FLATBUFFERS_BUILD_FLATC AND FLATBUFFERS_BUILD_TESTS)
     message(WARNING
@@ -93,7 +98,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
@@ -115,10 +120,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 +159,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 +171,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
@@ -268,8 +278,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 +322,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 +345,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 +382,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 "2")
+  set(FlatBuffers_Library_SONAME_FULL "${FlatBuffers_Library_SONAME_MAJOR}.0.0")
   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.
@@ -448,6 +486,7 @@ if(FLATBUFFERS_BUILD_TESTS)
   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(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)
@@ -504,10 +543,13 @@ 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(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})
@@ -589,6 +631,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 +669,10 @@ 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()

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 src/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

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.36.1"
+
+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,144 @@
+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 {
+    stlport {
+      dimension "stl-variant"
+      applicationIdSuffix ".stlport"
+      versionNameSuffix "-stlport"
+      externalNativeBuild {
+        ndkBuild {
+          arguments "APP_STL=stlport_static"
+        }
+      }
+    }
+    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,59 @@
+# 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/base.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/flatbuffers.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/hash.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/idl.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/util.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/reflection.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/reflection_generated.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/stl_emulation.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/flexbuffers.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/registry.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/minireflect.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
@@ -26,14 +27,6 @@ environment:
       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
   - x64
@@ -47,8 +40,6 @@ before_build:
   - 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,11 +51,7 @@ 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%
@@ -75,48 +62,25 @@ test_script:
   - 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

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_local_variable
 
 library my_game.sample;
 
@@ -12,7 +12,7 @@ class Color {
   const Color._(this.value);
 
   factory Color.fromValue(int value) {
-    if (value == null) return null;
+    if (value == null) value = 0;
     if (!values.containsKey(value)) {
       throw new StateError('Invalid value $value for bit flag enum Color');
     }
@@ -26,7 +26,7 @@ class Color {
   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 Map<int,Color> values = {0: Red,1: Green,2: Blue,};
 
   static const fb.Reader<Color> reader = const _ColorReader();
 
@@ -52,7 +52,7 @@ class EquipmentTypeId {
   const EquipmentTypeId._(this.value);
 
   factory EquipmentTypeId.fromValue(int value) {
-    if (value == null) return null;
+    if (value == null) value = 0;
     if (!values.containsKey(value)) {
       throw new StateError('Invalid value $value for bit flag enum EquipmentTypeId');
     }
@@ -65,7 +65,7 @@ class EquipmentTypeId {
 
   static const EquipmentTypeId NONE = const EquipmentTypeId._(0);
   static const EquipmentTypeId Weapon = const EquipmentTypeId._(1);
-  static get values => {0: NONE,1: Weapon,};
+  static const Map<int,EquipmentTypeId> values = {0: NONE,1: Weapon,};
 
   static const fb.Reader<EquipmentTypeId> reader = const _EquipmentTypeIdReader();
 
@@ -184,7 +184,7 @@ class Monster {
   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));
+  EquipmentTypeId get equippedType => new EquipmentTypeId.fromValue(const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 20, 0));
   dynamic get equipped {
     switch (equippedType?.value) {
       case 1: return Weapon.reader.vTableGet(_bc, _bcOffset, 22, null);
@@ -363,7 +363,7 @@ class Weapon {
   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);
+  int get damage => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 6, 0);
 
   @override
   String toString() {

dart/lib/flat_buffers.dart

@@ -149,6 +149,9 @@ class Builder {
     reset();
   }
 
+  /// Calculate the finished buffer size (aligned).
+  int size() => _tail + ((-_tail) % _maxAlign);
+
   /// Add the [field] with the given boolean [value].  The field is not added if
   /// the [value] is equal to [def].  Booleans are stored as 8-bit fields with
   /// `0` for `false` and `1` for `true`.
@@ -335,8 +338,7 @@ class Builder {
   ///
   /// Most clients should prefer calling [finish].
   Uint8List lowFinish() {
-    int alignedTail = _tail + ((-_tail) % _maxAlign);
-    return _buf.buffer.asUint8List(_buf.lengthInBytes - alignedTail);
+    return _buf.buffer.asUint8List(_buf.lengthInBytes - size());
   }
 
   /// Finish off the creation of the buffer.  The given [offset] is used as the
@@ -346,15 +348,15 @@ class Builder {
   /// bytes 4-7 of the file.
   Uint8List finish(int offset, [String fileIdentifier]) {
     _prepare(max(_sizeofUint32, _maxAlign), fileIdentifier == null ? 1 : 2);
-    int alignedTail = _tail + ((-_tail) % _maxAlign);
-    _setUint32AtTail(_buf, alignedTail, alignedTail - offset);
+    final finishedSize = size();
+    _setUint32AtTail(_buf, finishedSize, finishedSize - offset);
     if (fileIdentifier != null) {
       for (int i = 0; i < 4; i++) {
-        _setUint8AtTail(_buf, alignedTail - _sizeofUint32 - i,
+        _setUint8AtTail(_buf, finishedSize - _sizeofUint32 - i,
             fileIdentifier.codeUnitAt(i));
       }
     }
-    return _buf.buffer.asUint8List(_buf.lengthInBytes - alignedTail);
+    return _buf.buffer.asUint8List(_buf.lengthInBytes - finishedSize);
   }
 
   /// Writes a Float64 to the tail of the buffer after preparing space for it.
@@ -443,6 +445,7 @@ class Builder {
     _maxAlign = 1;
     _tail = 0;
     _currentVTable = null;
+    _vTables.clear();
     if (_strings != null) {
       _strings = new Map<String, int>();
     }
@@ -669,6 +672,7 @@ class Builder {
     for (int i = 0; i < length; i++) {
       _buf.setUint8(offset++, bytes[i]);
     }
+    _buf.setUint8(offset, 0); // trailing zero
     return result;
   }
 

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,666 @@
+import 'dart:convert';
+import 'dart:typed_data';
+
+import 'types.dart';
+
+/// The main builder class for creation of a FlexBuffer.
+class Builder {
+  ByteData _buffer;
+  List<_StackValue> _stack;
+  List<_StackPointer> _stackPointers;
+  int _offset;
+  bool _finished;
+  Map<String, _StackValue> _stringCache;
+  Map<String, _StackValue> _keyCache;
+  Map<_KeysHash, _StackValue> _keyVectorCache;
+  Map<int, _StackValue> _indirectIntCache;
+  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);
+    _stack = [];
+    _stackPointers = [];
+    _offset = 0;
+    _finished = false;
+    _stringCache = {};
+    _keyCache = {};
+    _keyVectorCache = {};
+    _indirectIntCache = {};
+    _indirectDoubleCache = {};
+  }
+
+  /// 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);
+    var 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.');
+    }
+
+    var 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 {
+  Object _value;
+  int _offset;
+  ValueType _type;
+  BitWidth _width;
+  _StackValue.WithNull() {
+    _type = ValueType.Null;
+    _width = BitWidth.width8;
+  }
+  _StackValue.WithInt(int value) {
+    _type = value != null ? ValueType.Int : ValueType.Null;
+    _width = BitWidthUtil.width(value);
+    _value = value;
+  }
+  _StackValue.WithBool(bool value) {
+    _type = value != null ? ValueType.Bool : ValueType.Null;
+    _width = BitWidth.width8;
+    _value = value;
+  }
+  _StackValue.WithDouble(double value) {
+    _type = value != null ? ValueType.Float : ValueType.Null;
+    _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;
+    for(var i = 0; i < 4; i++) {
+      final width = 1 << i;
+      final offsetLoc = size + BitWidthUtil.paddingSize(size, width) + index * width;
+      final offset = offsetLoc - _offset;
+      final bitWidth = BitWidthUtil.uwidth(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, Endian.little);
+          return result.buffer.asUint8List();
+        } else {
+          final result = ByteData(8);
+          result.setFloat64(0, _value, Endian.little);
+          return result.buffer.asUint8List();
+        }
+      } else {
+        switch(width) {
+          case BitWidth.width8:
+            final result = ByteData(1);
+            result.setInt8(0, _value);
+            return result.buffer.asUint8List();
+          case BitWidth.width16:
+            final result = ByteData(2);
+            result.setInt16(0, _value, Endian.little);
+            return result.buffer.asUint8List();
+          case BitWidth.width32:
+            final result = ByteData(4);
+            result.setInt32(0, _value, Endian.little);
+            return result.buffer.asUint8List();
+          case BitWidth.width64:
+            final result = ByteData(8);
+            result.setInt64(0, _value, 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 ? 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,446 @@
+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;
+  int _byteWidth;
+  ValueType _valueType;
+  int _length;
+
+  Reference._(this._buffer, this._offset, this._parentWidth, int packedType, this._path) {
+    _byteWidth = 1 << (packedType & 3);
+    _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;
+      final reference = Reference._(_buffer, elementOffset, BitWidthUtil.fromByteWidth(_byteWidth), 0, "$_path[$index]");
+      reference._byteWidth = 1;
+      if (ValueTypeUtils.isTypedVector(_valueType)) {
+        reference._valueType = ValueTypeUtils.typedVectorElementType(_valueType);
+        return reference;
+      }
+      if(ValueTypeUtils.isFixedTypedVector(_valueType)) {
+        reference._valueType = ValueTypeUtils.fixedTypedVectorElementType(_valueType);
+        return reference;
+      }
+      final packedType = _buffer.getUint8(_indirect + length * _byteWidth + index);
+      return Reference._(_buffer, elementOffset, BitWidthUtil.fromByteWidth(_byteWidth), packedType, "$_path[$index]");
+    }
+    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) {
+      return _length;
+    }
+    // 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 size_byte_width = _byteWidth;
+      var size = _readUInt(indirect - size_byte_width, BitWidthUtil.fromByteWidth(size_byte_width));
+      while (_buffer.getInt8(indirect + size) != 0) {
+        size_byte_width <<= 1;
+        size = _readUInt(indirect - size_byte_width, BitWidthUtil.fromByteWidth(size_byte_width));
+      }
+      _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 indirect_offset, int byteWidth) {
+    final keyOffset = indirect_offset + 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;
+
+  _VectorIterator(this._vector) {
+    index = -1;
+  }
+
+  @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;
+
+  _MapKeyIterator(this._map) {
+    index = -1;
+  }
+
+  @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;
+
+  _MapValueIterator(this._map) {
+    index = -1;
+  }
+
+  @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,166 @@
+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) ? 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) ? 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,25 @@
 # 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
+cp -r ../tests/include_test/*.fbs test/
+cp -r ../tests/include_test/sub test/
+
+pushd example
+../../flatc --dart ./monster.fbs
+popd
+
+pushd test
+../../flatc --dart ./monster_test.fbs
+popd
+
+dart pub publish
 
 rm example/monster.fbs
-rm test/monster_test.fbs
+rm test/*.fbs
+rm -rf test/sub

dart/pubspec.yaml

@@ -1,5 +1,5 @@
 name: flat_buffers
-version: 1.12.0
+version: 2.0.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

dart/test/flat_buffers_test.dart

@@ -17,6 +17,7 @@ main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(BuilderTest);
     defineReflectiveTests(CheckOtherLangaugesData);
+    defineReflectiveTests(GeneratorTest);
   });
 }
 
@@ -30,8 +31,7 @@ class CheckOtherLangaugesData {
     List<int> data = await new io.File(path.join(
       path.dirname(io.Platform.script.path),
       'monsterdata_test.mon',
-    ))
-        .readAsBytes();
+    )).readAsBytes();
     example.Monster mon = new example.Monster(data);
     expect(mon.hp, 80);
     expect(mon.mana, 150);
@@ -58,8 +58,74 @@ class CheckOtherLangaugesData {
     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: 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, '
+      'anyUniqueType: AnyUniqueAliasesTypeId{value: 0}, anyUnique: null, '
+      'anyAmbiguousType: AnyAmbiguousAliasesTypeId{value: 0}, '
+      'anyAmbiguous: null, vectorOfEnums: null, signedEnum: Race{value: -1}, '
+      'testrequirednestedflatbuffer: 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, '
+      'anyUniqueType: AnyUniqueAliasesTypeId{value: 0}, anyUnique: null, '
+      'anyAmbiguousType: AnyAmbiguousAliasesTypeId{value: 0}, '
+      'anyAmbiguous: null, vectorOfEnums: null, signedEnum: Race{value: -1}, '
+      'testrequirednestedflatbuffer: 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: 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, '
+      'anyUniqueType: AnyUniqueAliasesTypeId{value: 0}, anyUnique: null, '
+      'anyAmbiguousType: AnyAmbiguousAliasesTypeId{value: 0}, '
+      'anyAmbiguous: null, vectorOfEnums: null, signedEnum: Race{value: -1}, '
+      'testrequirednestedflatbuffer: null}',
+    );
   }
 }
 
@@ -88,7 +154,6 @@ class BuilderTest {
     testBuilder.finish(30, 40);
     final test4 = fbBuilder.endStructVector(2);
 
-
     monBuilder
       ..begin()
       ..addPos(
@@ -167,8 +232,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);
@@ -200,6 +265,7 @@ class BuilderTest {
       builder.addInt32(1, 20, 10);
       int offset = builder.endTable();
       byteList = builder.finish(offset);
+      expect(builder.size(), byteList.length);
     }
     // read and verify
     BufferContext buffer = new BufferContext.fromBytes(byteList);
@@ -231,8 +297,8 @@ class BuilderTest {
     // 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 +308,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);
     }
   }
 
@@ -571,3 +636,14 @@ class TestPointReader extends TableReader<TestPointImpl> {
     return new 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,315 @@
+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,334 @@
+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((e) => e is ArgumentError && e.message == 'Key: [country] is not applicable on: //address of: ValueType.Map')));
+    expect(() => flx['address']['countryCode'][0],
+      throwsA(predicate((e) => e is ArgumentError && e.message == 'Key: [0] is not applicable on: //address/countryCode of: ValueType.String')));
+    expect(() => flx[1],
+      throwsA(predicate((e) => e is ArgumentError && e.message == 'Key: [1] is not applicable on: / of: ValueType.Map')));
+    expect(() => flx['flags'][4],
+      throwsA(predicate((e) => e is ArgumentError && e.message == 'Key: [4] is not applicable on: //flags of: ValueType.VectorBool length: 4')));
+    expect(() => flx['flags'][-1],
+      throwsA(predicate((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,137 @@
+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_my_game.example2_generated.dart

@@ -6,8 +6,6 @@ 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;
 

dart/test/monster_test_my_game.example_generated.dart

@@ -6,8 +6,6 @@ library my_game.example;
 import 'dart:typed_data' show Uint8List;
 import 'package:flat_buffers/flat_buffers.dart' as fb;
 
-import 'include_test1_my_game.example_generated.dart';
-import 'include_test2_my_game.example_generated.dart';
 import './monster_test_my_game_generated.dart' as my_game;
 import './monster_test_my_game.example2_generated.dart' as my_game_example2;
 
@@ -34,7 +32,7 @@ class Color {
 
   ///  \brief color Blue (1u << 3)
   static const Color Blue = const Color._(8);
-  static get values => {1: Red,2: Green,8: Blue,};
+  static const Map<int,Color> values = {1: Red,2: Green,8: Blue,};
 
   static const fb.Reader<Color> reader = const _ColorReader();
 
@@ -75,7 +73,7 @@ class Race {
   static const Race Human = const Race._(0);
   static const Race Dwarf = const Race._(1);
   static const Race Elf = const Race._(2);
-  static get values => {-1: None,0: Human,1: Dwarf,2: Elf,};
+  static const Map<int,Race> values = {-1: None,0: Human,1: Dwarf,2: Elf,};
 
   static const fb.Reader<Race> reader = const _RaceReader();
 
@@ -116,7 +114,7 @@ class AnyTypeId {
   static const AnyTypeId Monster = const AnyTypeId._(1);
   static const AnyTypeId TestSimpleTableWithEnum = const AnyTypeId._(2);
   static const AnyTypeId MyGame_Example2_Monster = const AnyTypeId._(3);
-  static get values => {0: NONE,1: Monster,2: TestSimpleTableWithEnum,3: MyGame_Example2_Monster,};
+  static const Map<int,AnyTypeId> values = {0: NONE,1: Monster,2: TestSimpleTableWithEnum,3: MyGame_Example2_Monster,};
 
   static const fb.Reader<AnyTypeId> reader = const _AnyTypeIdReader();
 
@@ -157,7 +155,7 @@ class AnyUniqueAliasesTypeId {
   static const AnyUniqueAliasesTypeId M = const AnyUniqueAliasesTypeId._(1);
   static const AnyUniqueAliasesTypeId TS = const AnyUniqueAliasesTypeId._(2);
   static const AnyUniqueAliasesTypeId M2 = const AnyUniqueAliasesTypeId._(3);
-  static get values => {0: NONE,1: M,2: TS,3: M2,};
+  static const Map<int,AnyUniqueAliasesTypeId> values = {0: NONE,1: M,2: TS,3: M2,};
 
   static const fb.Reader<AnyUniqueAliasesTypeId> reader = const _AnyUniqueAliasesTypeIdReader();
 
@@ -198,7 +196,7 @@ class AnyAmbiguousAliasesTypeId {
   static const AnyAmbiguousAliasesTypeId M1 = const AnyAmbiguousAliasesTypeId._(1);
   static const AnyAmbiguousAliasesTypeId M2 = const AnyAmbiguousAliasesTypeId._(2);
   static const AnyAmbiguousAliasesTypeId M3 = const AnyAmbiguousAliasesTypeId._(3);
-  static get values => {0: NONE,1: M1,2: M2,3: M3,};
+  static const Map<int,AnyAmbiguousAliasesTypeId> values = {0: NONE,1: M1,2: M2,3: M3,};
 
   static const fb.Reader<AnyAmbiguousAliasesTypeId> reader = const _AnyAmbiguousAliasesTypeIdReader();
 
@@ -546,6 +544,85 @@ class AbilityObjectBuilder extends fb.ObjectBuilder {
     return fbBuilder.finish(offset, fileIdentifier);
   }
 }
+class StructOfStructs {
+  StructOfStructs._(this._bc, this._bcOffset);
+
+  static const fb.Reader<StructOfStructs> reader = const _StructOfStructsReader();
+
+  final fb.BufferContext _bc;
+  final int _bcOffset;
+
+  Ability get a => Ability.reader.read(_bc, _bcOffset + 0);
+  Test get b => Test.reader.read(_bc, _bcOffset + 8);
+  Ability get c => Ability.reader.read(_bc, _bcOffset + 12);
+
+  @override
+  String toString() {
+    return 'StructOfStructs{a: $a, b: $b, c: $c}';
+  }
+}
+
+class _StructOfStructsReader extends fb.StructReader<StructOfStructs> {
+  const _StructOfStructsReader();
+
+  @override
+  int get size => 20;
+
+  @override
+  StructOfStructs createObject(fb.BufferContext bc, int offset) => 
+    new StructOfStructs._(bc, offset);
+}
+
+class StructOfStructsBuilder {
+  StructOfStructsBuilder(this.fbBuilder) {
+    assert(fbBuilder != null);
+  }
+
+  final fb.Builder fbBuilder;
+
+  int finish(fb.StructBuilder a, fb.StructBuilder b, fb.StructBuilder c) {
+    c();
+    b();
+    a();
+    return fbBuilder.offset;
+  }
+
+}
+
+class StructOfStructsObjectBuilder extends fb.ObjectBuilder {
+  final AbilityObjectBuilder _a;
+  final TestObjectBuilder _b;
+  final AbilityObjectBuilder _c;
+
+  StructOfStructsObjectBuilder({
+    AbilityObjectBuilder a,
+    TestObjectBuilder b,
+    AbilityObjectBuilder c,
+  })
+      : _a = a,
+        _b = b,
+        _c = c;
+
+  /// Finish building, and store into the [fbBuilder].
+  @override
+  int finish(
+    fb.Builder fbBuilder) {
+    assert(fbBuilder != null);
+
+    _c.finish(fbBuilder);
+    _b.finish(fbBuilder);
+    _a.finish(fbBuilder);
+    return fbBuilder.offset;
+  }
+
+  /// 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);
+  }
+}
 class Stat {
   Stat._(this._bc, this._bcOffset);
   factory Stat(List<int> bytes) {
@@ -719,7 +796,7 @@ class ReferrableObjectBuilder extends fb.ObjectBuilder {
     return fbBuilder.finish(offset, fileIdentifier);
   }
 }
-///  an example documentation comment: monster object
+///  an example documentation comment: "monster object"
 class Monster {
   Monster._(this._bc, this._bcOffset);
   factory Monster(List<int> bytes) {
@@ -786,27 +863,29 @@ class Monster {
   AnyUniqueAliasesTypeId get anyUniqueType => new AnyUniqueAliasesTypeId.fromValue(const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 90, 0));
   dynamic get anyUnique {
     switch (anyUniqueType?.value) {
-      case 1: return M.reader.vTableGet(_bc, _bcOffset, 92, null);
-      case 2: return TS.reader.vTableGet(_bc, _bcOffset, 92, null);
-      case 3: return M2.reader.vTableGet(_bc, _bcOffset, 92, null);
+      case 1: return Monster.reader.vTableGet(_bc, _bcOffset, 92, null);
+      case 2: return TestSimpleTableWithEnum.reader.vTableGet(_bc, _bcOffset, 92, null);
+      case 3: return my_game_example2.Monster.reader.vTableGet(_bc, _bcOffset, 92, null);
       default: return null;
     }
   }
   AnyAmbiguousAliasesTypeId get anyAmbiguousType => new AnyAmbiguousAliasesTypeId.fromValue(const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 94, 0));
   dynamic get anyAmbiguous {
     switch (anyAmbiguousType?.value) {
-      case 1: return M1.reader.vTableGet(_bc, _bcOffset, 96, null);
-      case 2: return M2.reader.vTableGet(_bc, _bcOffset, 96, null);
-      case 3: return M3.reader.vTableGet(_bc, _bcOffset, 96, null);
+      case 1: return Monster.reader.vTableGet(_bc, _bcOffset, 96, null);
+      case 2: return Monster.reader.vTableGet(_bc, _bcOffset, 96, null);
+      case 3: return Monster.reader.vTableGet(_bc, _bcOffset, 96, null);
       default: return null;
     }
   }
   List<Color> get vectorOfEnums => const fb.ListReader<Color>(Color.reader).vTableGet(_bc, _bcOffset, 98, null);
   Race get signedEnum => new Race.fromValue(const fb.Int8Reader().vTableGet(_bc, _bcOffset, 100, -1));
+  List<int> get testrequirednestedflatbuffer => const fb.ListReader<int>(const fb.Uint8Reader()).vTableGet(_bc, _bcOffset, 102, null);
+  List<Stat> get scalarKeySortedTables => const fb.ListReader<Stat>(Stat.reader).vTableGet(_bc, _bcOffset, 104, null);
 
   @override
   String toString() {
-    return 'Monster{pos: $pos, mana: $mana, hp: $hp, name: $name, inventory: $inventory, color: $color, testType: $testType, test: $test, test4: $test4, testarrayofstring: $testarrayofstring, testarrayoftables: $testarrayoftables, enemy: $enemy, testnestedflatbuffer: $testnestedflatbuffer, testempty: $testempty, testbool: $testbool, testhashs32Fnv1: $testhashs32Fnv1, testhashu32Fnv1: $testhashu32Fnv1, testhashs64Fnv1: $testhashs64Fnv1, testhashu64Fnv1: $testhashu64Fnv1, testhashs32Fnv1a: $testhashs32Fnv1a, testhashu32Fnv1a: $testhashu32Fnv1a, testhashs64Fnv1a: $testhashs64Fnv1a, testhashu64Fnv1a: $testhashu64Fnv1a, testarrayofbools: $testarrayofbools, testf: $testf, testf2: $testf2, testf3: $testf3, testarrayofstring2: $testarrayofstring2, testarrayofsortedstruct: $testarrayofsortedstruct, flex: $flex, test5: $test5, vectorOfLongs: $vectorOfLongs, vectorOfDoubles: $vectorOfDoubles, parentNamespaceTest: $parentNamespaceTest, vectorOfReferrables: $vectorOfReferrables, singleWeakReference: $singleWeakReference, vectorOfWeakReferences: $vectorOfWeakReferences, vectorOfStrongReferrables: $vectorOfStrongReferrables, coOwningReference: $coOwningReference, vectorOfCoOwningReferences: $vectorOfCoOwningReferences, nonOwningReference: $nonOwningReference, vectorOfNonOwningReferences: $vectorOfNonOwningReferences, anyUniqueType: $anyUniqueType, anyUnique: $anyUnique, anyAmbiguousType: $anyAmbiguousType, anyAmbiguous: $anyAmbiguous, vectorOfEnums: $vectorOfEnums, signedEnum: $signedEnum}';
+    return 'Monster{pos: $pos, mana: $mana, hp: $hp, name: $name, inventory: $inventory, color: $color, testType: $testType, test: $test, test4: $test4, testarrayofstring: $testarrayofstring, testarrayoftables: $testarrayoftables, enemy: $enemy, testnestedflatbuffer: $testnestedflatbuffer, testempty: $testempty, testbool: $testbool, testhashs32Fnv1: $testhashs32Fnv1, testhashu32Fnv1: $testhashu32Fnv1, testhashs64Fnv1: $testhashs64Fnv1, testhashu64Fnv1: $testhashu64Fnv1, testhashs32Fnv1a: $testhashs32Fnv1a, testhashu32Fnv1a: $testhashu32Fnv1a, testhashs64Fnv1a: $testhashs64Fnv1a, testhashu64Fnv1a: $testhashu64Fnv1a, testarrayofbools: $testarrayofbools, testf: $testf, testf2: $testf2, testf3: $testf3, testarrayofstring2: $testarrayofstring2, testarrayofsortedstruct: $testarrayofsortedstruct, flex: $flex, test5: $test5, vectorOfLongs: $vectorOfLongs, vectorOfDoubles: $vectorOfDoubles, parentNamespaceTest: $parentNamespaceTest, vectorOfReferrables: $vectorOfReferrables, singleWeakReference: $singleWeakReference, vectorOfWeakReferences: $vectorOfWeakReferences, vectorOfStrongReferrables: $vectorOfStrongReferrables, coOwningReference: $coOwningReference, vectorOfCoOwningReferences: $vectorOfCoOwningReferences, nonOwningReference: $nonOwningReference, vectorOfNonOwningReferences: $vectorOfNonOwningReferences, anyUniqueType: $anyUniqueType, anyUnique: $anyUnique, anyAmbiguousType: $anyAmbiguousType, anyAmbiguous: $anyAmbiguous, vectorOfEnums: $vectorOfEnums, signedEnum: $signedEnum, testrequirednestedflatbuffer: $testrequirednestedflatbuffer, scalarKeySortedTables: $scalarKeySortedTables}';
   }
 }
 
@@ -1021,6 +1100,14 @@ class MonsterBuilder {
     fbBuilder.addInt8(48, signedEnum?.value);
     return fbBuilder.offset;
   }
+  int addTestrequirednestedflatbufferOffset(int offset) {
+    fbBuilder.addOffset(49, offset);
+    return fbBuilder.offset;
+  }
+  int addScalarKeySortedTablesOffset(int offset) {
+    fbBuilder.addOffset(50, offset);
+    return fbBuilder.offset;
+  }
 
   int finish() {
     return fbBuilder.endTable();
@@ -1076,6 +1163,8 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
   final dynamic _anyAmbiguous;
   final List<Color> _vectorOfEnums;
   final Race _signedEnum;
+  final List<int> _testrequirednestedflatbuffer;
+  final List<StatObjectBuilder> _scalarKeySortedTables;
 
   MonsterObjectBuilder({
     Vec3ObjectBuilder pos,
@@ -1126,6 +1215,8 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
     dynamic anyAmbiguous,
     List<Color> vectorOfEnums,
     Race signedEnum,
+    List<int> testrequirednestedflatbuffer,
+    List<StatObjectBuilder> scalarKeySortedTables,
   })
       : _pos = pos,
         _mana = mana,
@@ -1174,7 +1265,9 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
         _anyAmbiguousType = anyAmbiguousType,
         _anyAmbiguous = anyAmbiguous,
         _vectorOfEnums = vectorOfEnums,
-        _signedEnum = signedEnum;
+        _signedEnum = signedEnum,
+        _testrequirednestedflatbuffer = testrequirednestedflatbuffer,
+        _scalarKeySortedTables = scalarKeySortedTables;
 
   /// Finish building, and store into the [fbBuilder].
   @override
@@ -1242,6 +1335,12 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
     final int vectorOfEnumsOffset = _vectorOfEnums?.isNotEmpty == true
         ? fbBuilder.writeListUint8(_vectorOfEnums.map((f) => f.value))
         : null;
+    final int testrequirednestedflatbufferOffset = _testrequirednestedflatbuffer?.isNotEmpty == true
+        ? fbBuilder.writeListUint8(_testrequirednestedflatbuffer)
+        : null;
+    final int scalarKeySortedTablesOffset = _scalarKeySortedTables?.isNotEmpty == true
+        ? fbBuilder.writeList(_scalarKeySortedTables.map((b) => b.getOrCreateOffset(fbBuilder)).toList())
+        : null;
 
     fbBuilder.startTable();
     if (_pos != null) {
@@ -1344,6 +1443,12 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
       fbBuilder.addOffset(47, vectorOfEnumsOffset);
     }
     fbBuilder.addInt8(48, _signedEnum?.value);
+    if (testrequirednestedflatbufferOffset != null) {
+      fbBuilder.addOffset(49, testrequirednestedflatbufferOffset);
+    }
+    if (scalarKeySortedTablesOffset != null) {
+      fbBuilder.addOffset(50, scalarKeySortedTablesOffset);
+    }
     return fbBuilder.endTable();
   }
 

dart/test/monster_test_my_game_generated.dart

@@ -6,8 +6,6 @@ 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;
 

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/Compiler.md

@@ -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,10 @@ 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.
+
 NOTE: short-form options for generators are deprecated, use the long form
 whenever possible.

docs/source/CppUsage.md

@@ -117,8 +117,8 @@ 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;
@@ -133,11 +133,11 @@ 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`.
@@ -148,12 +148,15 @@ The following attributes are specific to the object-based API code generation:
 
     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;
@@ -175,48 +178,73 @@ The following attributes are specific to the object-based API code generation:
       template <class U>
       custom_allocator(const custom_allocator<U>&) throw() {}
     };
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
--   `native_type`' "type" (on a struct): In some cases, a more optimal C++ data
+-   `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:
 
-      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.
 
-      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.
+    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
+    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
@@ -299,7 +327,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.

docs/source/CsharpUsage.md

@@ -14,14 +14,38 @@ documentation to build `flatc` and should be familiar with
 [Using the schema compiler](@ref flatbuffers_guide_using_schema_compiler) and
 [Writing a schema](@ref flatbuffers_guide_writing_schema).
 
-## FlatBuffers C-sharp code location
+## FlatBuffers C# code location
 
 The code for the FlatBuffers C# library can be found at
 `flatbuffers/net/FlatBuffers`. You can browse the library on the
 [FlatBuffers GitHub page](https://github.com/google/flatbuffers/tree/master/net/
 FlatBuffers).
 
-## Testing the FlatBuffers C-sharp libraries
+## Building the FlatBuffers C# library
+
+The `FlatBuffers.csproj` project contains multitargeting for .NET Standard 2.1,
+.NET Standard 2.0, and .NET Framework 4.6 (Unity 2017). Support for .NET
+Framework 3.5 (Unity 5) is provided by the `FlatBuffers.net35.csproj` project.
+In most cases (including Unity 2018 and newer), .NET Standard 2.0 is
+recommended.
+
+You can build for a specific framework target when using the cross-platform
+[.NET Core SDK](https://dotnet.microsoft.com/download) by adding the `-f`
+command line option:
+
+~~~{.sh}
+    dotnet build -f netstandard2.0 "FlatBuffers.csproj"
+~~~
+
+The `FlatBuffers.csproj` project also provides support for defining various
+conditional compilation symbols (see "Conditional compilation symbols" section
+below) using the `-p` command line option:
+
+~~~{.sh}
+    dotnet build -f netstandard2.1 -p:ENABLE_SPAN_T=true -p:UNSAFE_BYTEBUFFER=true "FlatBuffers.csproj"
+~~~
+
+## Testing the FlatBuffers C# library
 
 The code to test the libraries can be found at `flatbuffers/tests`.
 
@@ -31,12 +55,12 @@ tests, open `FlatBuffers.Test.csproj` in [Visual Studio](
 https://www.visualstudio.com), and compile/run the project.
 
 Optionally, you can run this using [Mono](http://www.mono-project.com/) instead.
-Once you have installed `Mono`, you can run the tests from the command line
+Once you have installed Mono, you can run the tests from the command line
 by running the following commands from inside the `FlatBuffers.Test` folder:
 
 ~~~{.sh}
-  mcs *.cs ../MyGame/Example/*.cs ../../net/FlatBuffers/*.cs
-  mono Assert.exe
+    mcs *.cs ../MyGame/Example/*.cs ../../net/FlatBuffers/*.cs
+    mono Assert.exe
 ~~~
 
 ## Using the FlatBuffers C# library
@@ -74,7 +98,7 @@ Now you can access the data from the `Monster monster`:
     Vec3 pos = monster.Pos;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-C# code naming follows standard C# style with `PascalCasing` identifiers,
+C# code naming follows standard C# style with PascalCasing identifiers,
 e.g. `GetRootAsMyRootType`. Also, values (except vectors and unions) are
 available as properties instead of parameterless accessor methods.
 The performance-enhancing methods to which you can pass an already created
@@ -133,8 +157,8 @@ around using as little as possible of it. This does make the API clumsier
 
 For times when efficiency is less important a more convenient object based API
 can be used (through `--gen-object-api`) that is able to unpack & pack a
-FlatBuffer into objects and standard System.Collections.Generic containers, allowing for convenient
-construction, access and mutation.
+FlatBuffer into objects and standard `System.Collections.Generic` containers,
+allowing for convenient construction, access and mutation.
 
 To use:
 
@@ -154,8 +178,8 @@ To use:
 ### Json Serialization
 
 An additional feature of the object API is the ability to allow you to
-serialize & deserialize a JSON text. 
-To use Json Serialization, add `--gen-json-serializer` option to `flatc` and
+serialize & deserialize a JSON text.
+To use Json Serialization, add `--cs-gen-json-serializer` option to `flatc` and
 add `Newtonsoft.Json` nuget package to csproj.
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cs}
@@ -172,4 +196,31 @@ add `Newtonsoft.Json` nuget package to csproj.
 * NuGet package Dependency
   * [Newtonsoft.Json](https://github.com/JamesNK/Newtonsoft.Json)
 
+## Conditional compilation symbols
+
+There are three conditional compilation symbols that have an impact on
+performance/features of the C# `ByteBuffer` implementation.
+
+* `UNSAFE_BYTEBUFFER`
+
+  This will use unsafe code to manipulate the underlying byte array. This can
+  yield a reasonable performance increase.
+
+* `BYTEBUFFER_NO_BOUNDS_CHECK`
+
+  This will disable the bounds check asserts to the byte array. This can yield a
+  small performance gain in normal code.
+
+* `ENABLE_SPAN_T`
+
+  This will enable reading and writing blocks of memory with a `Span<T>` instead
+  of just `T[]`. You can also enable writing directly to shared memory or other
+  types of memory by providing a custom implementation of `ByteBufferAllocator`.
+  `ENABLE_SPAN_T` also requires `UNSAFE_BYTEBUFFER` to be defined, or .NET
+  Standard 2.1.
+
+Using `UNSAFE_BYTEBUFFER` and `BYTEBUFFER_NO_BOUNDS_CHECK` together can yield a
+performance gain of ~15% for some operations, however doing so is potentially
+dangerous. Do so at your own risk!
+
 <br>

docs/source/FlatBuffers.md

@@ -64,8 +64,8 @@ Protocol Buffers is indeed relatively similar to FlatBuffers,
 with the primary difference being that FlatBuffers does not need a parsing/
 unpacking step to a secondary representation before you can
 access data, often coupled with per-object memory allocation. The code
-is an order of magnitude bigger, too. Protocol Buffers has neither optional
-text import/export nor schema language features like unions.
+is an order of magnitude bigger, too. Protocol Buffers has no optional
+text import/export.
 
 ### But all the cool kids use JSON!
 

docs/source/Grammar.md

@@ -35,9 +35,9 @@ enumval\_decl = ident [ `=` integer\_constant ]
 
 metadata = [ `(` commasep( ident [ `:` single\_value ] ) `)` ]
 
-scalar = integer\_constant | float\_constant
+scalar = boolean\_constant | integer\_constant | float\_constant
 
-object = { commasep( ident `:` value ) }
+object = `{` commasep( ident `:` value ) `}`
 
 single\_value = scalar | string\_constant
 
@@ -69,6 +69,6 @@ hex\_float\_constant = `[-+]?0[xX](([.][:xdigit:]+)|([:xdigit:]+[.][:xdigit:]*)|
 
 special\_float\_constant = `[-+]?(nan|inf|infinity)`
 
-float\_constant = decimal\_float\_constant | hexadecimal\_float\_constant | special\_float\_constant
+float\_constant = dec\_float\_constant | hex\_float\_constant | special\_float\_constant
 
-boolean\_constant = `(true|false)` | (integer\_constant ? `true` : `false`)
+boolean\_constant = `true` | `false`

docs/source/Internals.md

@@ -62,7 +62,7 @@ when needed. Unsigned means they can only point in one direction, which
 typically is forward (towards a higher memory location). Any backwards
 offsets will be explicitly marked as such.
 
-The format starts with an `uoffset_t` to the root object in the buffer.
+The format starts with an `uoffset_t` to the root table in the buffer.
 
 We have two kinds of objects, structs and tables.
 
@@ -88,7 +88,9 @@ They start with an `soffset_t` to a vtable. This is a signed version of
 This offset is substracted (not added) from the object start to arrive at
 the vtable start. This offset is followed by all the
 fields as aligned scalars (or offsets). Unlike structs, not all fields
-need to be present. There is no set order and layout.
+need to be present. There is no set order and layout. A table may contain
+field offsets that point to the same value if the user explicitly
+serializes the same offset twice.
 
 To be able to access fields regardless of these uncertainties, we go
 through a vtable of offsets. Vtables are shared between any objects that
@@ -111,13 +113,21 @@ is 0, that means the field is not present in this object, and the
 default value is return. Otherwise, the entry is used as offset to the
 field to be read.
 
+### Unions
+
+Unions are encoded as the combination of two fields: an enum representing the
+union choice and the offset to the actual element. FlatBuffers reserves the
+enumeration constant `NONE` (encoded as 0) to mean that the union field is not
+set.
+
 ### Strings and Vectors
 
 Strings are simply a vector of bytes, and are always
 null-terminated. Vectors are stored as contiguous aligned scalar
 elements prefixed by a 32bit element count (not including any
 null termination). Neither is stored inline in their parent, but are referred to
-by offset.
+by offset. A vector may consist of more than one offset pointing to the same
+value if the user explicitly serializes the same offset twice.
 
 ### Construction
 
@@ -346,6 +356,9 @@ Since this is an untyped vector `SL_VECTOR`, it is followed by 3 type
 bytes (one per element of the vector), which are always following the vector,
 and are always a uint8_t even if the vector is made up of bigger scalars.
 
+A vector may include more than one offset pointing to the same value if the
+user explicitly serializes the same offset twice.
+
 ### Types
 
 A type byte is made up of 2 components (see flexbuffers.h for exact values):

docs/source/JavaScriptUsage.md

@@ -16,43 +16,31 @@ documentation to build `flatc` and should be familiar with
 
 ## FlatBuffers JavaScript library code location
 
-The code for the FlatBuffers JavaScript library can be found at
-`flatbuffers/js`. You can browse the library code on the [FlatBuffers
-GitHub page](https://github.com/google/flatbuffers/tree/master/js).
+The generated code for the FlatBuffers JavaScript library can be found at 
+https://www.npmjs.com/package/flatbuffers. To use it from sources:
 
-## Testing the FlatBuffers JavaScript library
-
-The code to test the JavaScript library can be found at `flatbuffers/tests`.
-The test code itself is located in [JavaScriptTest.js](https://github.com/
-google/flatbuffers/blob/master/tests/JavaScriptTest.js).
-
-To run the tests, use the [JavaScriptTest.sh](https://github.com/google/
-flatbuffers/blob/master/tests/JavaScriptTest.sh) shell script.
-
-*Note: The JavaScript test file requires [Node.js](https://nodejs.org/en/).*
+1. Run `npm run compile` from the main folder to generate JS files from TS.
+1. In your project, install it as a normal dependency, using the flatbuffers
+folder as the source.
 
 ## Using the FlatBuffers JavaScript libary
 
 *Note: See [Tutorial](@ref flatbuffers_guide_tutorial) for a more in-depth
-example of how to use FlatBuffers in JavaScript.*
+example of how to use FlatBuffers.*
 
-FlatBuffers supports both reading and writing FlatBuffers in JavaScript.
+Due to the complexity related with large amounts of JS flavors and module types,
+native JS support has been replaced in 2.0 by transpilation from TypeScript.
 
-To use FlatBuffers in your own code, first generate JavaScript classes from your
-schema with the `--js` option to `flatc`. Then you can include both FlatBuffers
-and the generated code to read or write a FlatBuffer.
+Please look at [TypeScript usage](@ref flatbuffers_guide_use_typescript) and
+transpile your sources to desired JS flavor. The minimal steps to get up and
+running with JS are:
 
-For example, here is how you would read a FlatBuffer binary file in Javascript:
-First, include the library and generated code. Then read the file into an
-`Uint8Array`. Make a `flatbuffers.ByteBuffer` out of the `Uint8Array`, and pass
-the ByteBuffer to the `getRootAsMonster` function.
-
-*Note: Both JavaScript module loaders (e.g. Node.js) and browser-based
-HTML/JavaScript code segments are shown below in the following snippet:*
+1. Generate TS files from `*.fbs` by using the `--ts` option.
+1. Transpile resulting TS files to desired JS flavor using `tsc` (see 
+   https://www.typescriptlang.org/download for installation instructions).
 
 ~~~{.js}
-  // Note: These require functions are specific to JavaScript module loaders
-  //       (namely, Node.js). See below for a browser-based example.
+  // Note: These require functions are an example - use your desired module flavor.
   var fs = require('fs');
 
   var flatbuffers = require('../flatbuffers').flatbuffers;
@@ -65,7 +53,7 @@ HTML/JavaScript code segments are shown below in the following snippet:*
 
   //--------------------------------------------------------------------------//
 
-  // Note: This code is specific to browser-based HTML/JavaScript. See above
+  // Note: This code is an example of browser-based HTML/JavaScript. See above
   //       for the code using JavaScript module loaders (e.g. Node.js).
   <script src="../js/flatbuffers.js"></script>
   <script src="monster_generated.js"></script>

docs/source/LuaUsage.md

@@ -29,8 +29,8 @@ flatbuffers/blob/master/tests/luatest.lua).
 To run the tests, use the [LuaTest.sh](https://github.com/google/flatbuffers/
 blob/master/tests/LuaTest.sh) shell script.
 
-*Note: This script requires [Lua 5.3](https://www.lua.org/) to be
-installed.*
+*Note: This script requires [Lua 5.3](https://www.lua.org/) and
+[LuaJIT](http://luajit.org/) to be installed.*
 
 ## Using the FlatBuffers Lua library
 

docs/source/Schemas.md

@@ -39,16 +39,16 @@ first:
 
 ### Tables
 
-Tables are the main way of defining objects in FlatBuffers, and consist
-of a name (here `Monster`) and a list of fields. Each field has a name,
-a type, and optionally a default value (if omitted, it defaults to `0` /
-`NULL`).
+Tables are the main way of defining objects in FlatBuffers, and consist of a
+name (here `Monster`) and a list of fields. Each field has a name, a type, and
+optionally a default value. If the default value is not specified in the schema,
+it will be `0` for scalar types, or `null` for other types. Some languages
+support setting a scalar's default to `null`. This makes the scalar optional.
 
-Each field is optional: It does not have to appear in the wire
-representation, and you can choose to omit fields for each individual
-object. As a result, you have the flexibility to add fields without fear of
-bloating your data. This design is also FlatBuffer's mechanism for forward
-and backwards compatibility. Note that:
+Fields do not have to appear in the wire representation, and you can choose
+to omit fields when constructing an object. You have the flexibility to add
+fields without fear of bloating your data. This design is also FlatBuffer's
+mechanism for forward and backwards compatibility. Note that:
 
 -   You can add new fields in the schema ONLY at the end of a table
     definition. Older data will still
@@ -135,24 +135,35 @@ Both representations are binary equivalent.
 
 Arrays are currently only supported in a `struct`.
 
-### (Default) Values
+### Default, Optional and Required Values
 
-Values are a sequence of digits. Values may be optionally followed by a decimal
-point (`.`) and more digits, for float constants, or optionally prefixed by
-a `-`. Floats may also be in scientific notation; optionally ending with an `e`
-or `E`, followed by a `+` or `-` and more digits.
+There are three, mutually exclusive, reactions to the non-presence of a table's
+field in the binary data:
+
+1.   Default valued fields will return the default value (as defined in the schema).
+2.   Optional valued fields will return some form of `null` depending on the
+     local language. (In a sense, `null` is the default value).
+3.   Required fields will cause an error. Flatbuffer verifiers would
+     consider the whole buffer invalid. See the `required` tag below.
+
+When writing a schema, values are a sequence of digits. Values may be optionally
+followed by a decimal point (`.`) and more digits, for float constants, or
+optionally prefixed by a `-`. Floats may also be in scientific notation;
+optionally ending with an `e` or `E`, followed by a `+` or `-` and more digits.
+Values can also be the keyword `null`.
 
 Only scalar values can have defaults, non-scalar (string/vector/table) fields
-default to `NULL` when not present.
+default to `null` when not present.
 
 You generally do not want to change default values after they're initially
 defined. Fields that have the default value are not actually stored in the
-serialized data (see also Gotchas below) but are generated in code,
-so when you change the default, you'd
-now get a different value than from code generated from an older version of
-the schema. There are situations, however, where this may be
-desirable, especially if you can ensure a simultaneous rebuild of
-all code.
+serialized data (see also Gotchas below). Values explicitly written by code
+generated by the old schema old version, if they happen to be the default, will
+be read as a different value by code generated with the new schema. This is
+slightly less bad when converting an optional scalar into a default valued
+scalar since non-presence would not be overloaded with a previous default value.
+There are situations, however, where this may be desirable, especially if you
+can ensure a simultaneous rebuild of all code.
 
 ### Enums
 
@@ -200,9 +211,11 @@ If you have a need to distinguish between different FlatBuffers in a more
 open-ended way, for example for use as files, see the file identification
 feature below.
 
-There is an experimental support only in C++ for a vector of unions
-(and types). In the example IDL file above, use [Any] to add a
-vector of Any to Monster table.
+There is an experimental support only in C++ for a vector of unions (and
+types). In the example IDL file above, use [Any] to add a vector of Any to
+Monster table. There is also experimental support for other types besides
+tables in unions, in particular structs and strings. There's no direct support
+for scalars in unions, but they can be wrapped in a struct at no space cost.
 
 ### Namespaces
 
@@ -325,18 +338,16 @@ Current understood attributes:
     deprecate a field that was previous required, old code may fail to validate
     new data (when using the optional verifier).
 -   `required` (on a non-scalar table field): this field must always be set.
-    By default, all fields are optional, i.e. may be left out. This is
+    By default, fields do not need to be present in the binary. This is
     desirable, as it helps with forwards/backwards compatibility, and
-    flexibility of data structures. It is also a burden on the reading code,
-    since for non-scalar fields it requires you to check against NULL and
-    take appropriate action. By specifying this field, you force code that
-    constructs FlatBuffers to ensure this field is initialized, so the reading
-    code may access it directly, without checking for NULL. If the constructing
-    code does not initialize this field, they will get an assert, and also
-    the verifier will fail on buffers that have missing required fields. Note
-    that if you add this attribute to an existing field, this will only be
-    valid if existing data always contains this field / existing code always
-    writes this field.
+    flexibility of data structures. By specifying this attribute, you make non-
+    presence in an error for both reader and writer. The reading code may access
+    the field directly, without checking for null. If the constructing code does
+    not initialize this field, they will get an assert, and also the verifier
+    will fail on buffers that have missing required fields. Both adding and
+    removing this attribute may be forwards/backwards incompatible as readers
+    will be unable read old or new data, respectively, unless the data happens to
+    always have the field set.
 -   `force_align: size` (on a struct): force the alignment of this struct
     to be something higher than what it is naturally aligned to. Causes
     these structs to be aligned to that amount inside a buffer, IF that
@@ -486,7 +497,7 @@ of related data structures is a union. Unions do have a cost however,
 so an alternative to a union is to have a single table that has
 all the fields of all the data structures you are trying to
 represent, if they are relatively similar / share many fields.
-Again, this is efficient because optional fields are cheap.
+Again, this is efficient because non-present fields are cheap.
 
 FlatBuffers supports the full range of integer sizes, so try to pick
 the smallest size needed, rather than defaulting to int/long.
@@ -611,22 +622,25 @@ Most serialization formats (e.g. JSON or Protocol Buffers) make it very
 explicit in the format whether a field is present in an object or not,
 allowing you to use this as "extra" information.
 
-In FlatBuffers, this also holds for everything except scalar values.
+FlatBuffers will not write fields that are equal to their default value,
+sometimes resulting in significant space savings. However, this also means we
+cannot disambiguate the meaning of non-presence as "written default value" or
+"not written at all". This only applies to scalar fields since only they support
+default values. Unless otherwise specified, their default is 0.
 
-FlatBuffers by default will not write fields that are equal to the default
-value (for scalars), sometimes resulting in a significant space savings.
-
-However, this also means testing whether a field is "present" is somewhat
-meaningless, since it does not tell you if the field was actually written by
-calling `add_field` style calls, unless you're only interested in this
-information for non-default values.
+If you care about the presence of scalars, most languages support "optional
+scalars." You can set `null` as the default value in the schema. `null` is a
+value that's outside of all types, so we will always write if `add_field` is
+called. The generated field accessor should use the local language's canonical
+optional type.
 
 Some `FlatBufferBuilder` implementations have an option called `force_defaults`
-that circumvents this behavior, and writes fields even if they are equal to
-the default. You can then use `IsFieldPresent` to query this.
+that circumvents this "not writing defaults" behavior you can then use
+`IsFieldPresent` to query presence.
 
 Another option that works in all languages is to wrap a scalar field in a
-struct. This way it will return null if it is not present. The cool thing
-is that structs don't take up any more space than the scalar they represent.
+struct. This way it will return null if it is not present. This will be slightly
+less ergonomic but structs don't take up any more space than the scalar they
+represent.
 
    [Interface Definition Language]: https://en.wikipedia.org/wiki/Interface_description_language

docs/source/Support.md

@@ -18,31 +18,40 @@ In general:
 
 NOTE: this table is a start, it needs to be extended.
 
-Feature                        | C++    | Java   | C#     | Go     | Python | JS        | TS        | C       | PHP | Dart    | Lobster | Rust    | Swift 
------------------------------- | ------ | ------ | ------ | ------ | ------ | --------- | --------- | ------  | --- | ------- | ------- | ------- | ------
-Codegen for all basic features | Yes    | Yes    | Yes    | Yes    | Yes    | Yes       | Yes       | Yes     | WiP | Yes     | Yes     | Yes     | Yes
-JSON parsing                   | Yes    | No     | No     | No     | No     | No        | No        | Yes     | No  | No      | Yes     | No      | No
-Simple mutation                | Yes    | Yes    | Yes    | Yes    | No     | No        | No        | No      | No  | No      | No      | No      | No
-Reflection                     | Yes    | No     | No     | No     | No     | No        | No        | Basic   | No  | No      | No      | No      | No
-Buffer verifier                | Yes    | No     | No     | No     | No     | No        | No        | Yes     | No  | No      | No      | No      | No
-Testing: basic                 | Yes    | Yes    | Yes    | Yes    | Yes    | Yes       | Yes       | Yes     | ?   | Yes     | Yes     | Yes     | Yes
-Testing: fuzz                  | Yes    | No     | No     | Yes    | Yes    | No        | No        | No      | ?   | No      | No      | Yes     | No
-Performance:                   | Superb | Great  | Great  | Great  | Ok     | ?         | ?         | Superb  | ?   | ?       | Great   | Superb  | ?
-Platform: Windows              | VS2010 | Yes    | Yes    | ?      | ?      | ?         | Yes       | VS2010  | ?   | Yes     | Yes     | Yes     | No
-Platform: Linux                | GCC282 | Yes    | ?      | Yes    | Yes    | ?         | Yes       | Yes     | ?   | Yes     | Yes     | Yes     | Yes
-Platform: OS X                 | Xcode4 | ?      | ?      | ?      | Yes    | ?         | Yes       | Yes     | ?   | Yes     | Yes     | Yes     | Yes
-Platform: Android              | NDK10d | Yes    | ?      | ?      | ?      | ?         | ?         | ?       | ?   | Flutter | Yes     | ?       | No
-Platform: iOS                  | ?      | ?      | ?      | ?      | ?      | ?         | ?         | ?       | ?   | Flutter | Yes     | ?       | Yes
-Engine: Unity                  | ?      | ?      | Yes    | ?      | ?      | ?         | ?         | ?       | ?   | ?       | No      | ?       | No
-Primary authors (github)       | aard*  | aard*  | ev*/js*| rw     | rw     | evanw/ev* | kr*       | mik*    | ch* | dnfield | aard*   | rw      | mi*/mz*
+Feature                        | C++    | Java  | C#       | Go    | Python | JS    | TS  | C      | PHP | Dart    | Lobster | Rust   | Swift
+------------------------------ | ------ | ----- | -------- | ----- | ------ | ----- | --- | ------ | --- | ------- | ------- | ------ | ------
+Codegen for all basic features | Yes    | Yes   | Yes      | Yes   | Yes    | Yes   | Yes | Yes    | WiP | Yes     | Yes     | Yes    | Yes
+JSON parsing                   | Yes    | No    | No       | No    | No     | No    | No  | Yes    | No  | No      | Yes     | No     | No
+Simple mutation                | Yes    | Yes   | Yes      | Yes   | No     | No    | No  | No     | No  | No      | No      | No     | Yes
+Reflection                     | Yes    | No    | No       | No    | No     | No    | No  | Basic  | No  | No      | No      | No     | No
+Buffer verifier                | Yes    | No    | No       | No    | No     | No    | No  | Yes    | No  | No      | No      | No     | No
+Native Object API              | Yes    | No    | Yes      | Yes   | Yes    | Yes   | Yes | No     | No  | No      | No      | No     | No
+Optional Scalars               | Yes    | Yes   | Yes      | No    | No     | Yes   | Yes | Yes    | No  | No      | Yes     | Yes    | Yes
+Flexbuffers                    | Yes    | Yes   | ?        | ?     | ?      | ?     | ?   | ?      | ?   | ?       | ?       | Yes    | ?
+Testing: basic                 | Yes    | Yes   | Yes      | Yes   | Yes    | Yes   | Yes | Yes    | ?   | Yes     | Yes     | Yes    | Yes
+Testing: fuzz                  | Yes    | No    | No       | Yes   | Yes    | No    | No  | No     | ?   | No      | No      | Yes    | No
+Performance:                   | Superb | Great | Great    | Great | Ok     | ?     | ?   | Superb | ?   | ?       | Great   | Superb | Great
+Platform: Windows              | VS2010 | Yes   | Yes      | ?     | ?      | ?     | Yes | VS2010 | ?   | Yes     | Yes     | Yes    | No
+Platform: Linux                | GCC282 | Yes   | ?        | Yes   | Yes    | ?     | Yes | Yes    | ?   | Yes     | Yes     | Yes    | Yes
+Platform: OS X                 | Xcode4 | ?     | ?        | ?     | Yes    | ?     | Yes | Yes    | ?   | Yes     | Yes     | Yes    | Yes
+Platform: Android              | NDK10d | Yes   | ?        | ?     | ?      | ?     | ?   | ?      | ?   | Flutter | Yes     | ?      | No
+Platform: iOS                  | ?      | ?     | ?        | ?     | ?      | ?     | ?   | ?      | ?   | Flutter | Yes     | ?      | Yes
+Engine: Unity                  | ?      | ?     | Yes      | ?     | ?      | ?     | ?   | ?      | ?   | ?       | No      | ?      | No
+Primary authors (github)       | aard   | aard  | ev/js/df | rw    | rw     | ew/ev | kr  | mik    | ch  | df      | aard    | rw/cn  | mi/mz
 
-  * aard = aardappel (previously: gwvo)
-  * ev = evolutional
-  * js = jonsimantov
-  * mik = mikkelfj
-  * ch = chobie
-  * kr = krojew
-  * mi = mustiikhalil
-  * mz = mzaks
+Above | Github username
+----- | -----------------------------
+aard  | aardappel (previously: gwvo)
+ch    | chobie
+cn    | caspern
+df    | dnfield
+ev    | evolutional
+ew    | evanw
+js    | jonsimantov
+kr    | krojew
+mi    | mustiikhalil
+mik   | mikkelfj
+mz    | mzaks
+rw    | rw
 
 <br>

docs/source/SwiftUsage.md

@@ -64,7 +64,8 @@ Now you can access values like this:
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.swift}
     let hp = monster.hp
-    let pos = monster.pos
+    let pos = monster.pos // uses native swift structs
+    let pos = monster.mutablePos // uses flatbuffers structs
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 
@@ -76,8 +77,10 @@ In some cases it's necessary to modify values in an existing FlatBuffer in place
     if !monster.mutate(hp: 10) {
       fatalError("couldn't mutate")
     }
-    // mutate a struct field
-    let vec = monster.pos.mutate(z: 4)
+    // mutate a struct field using flatbuffers struct
+    // DONT use monster.pos to mutate since swift copy on write 
+    // will not mutate the value in the buffer
+    let vec = monster.mutablePos.mutate(z: 4)
 
     // This mutation will fail because the mana field is not available in
     // the buffer. It should be set when creating the buffer.

docs/source/Tutorial.md

@@ -130,7 +130,7 @@ For your chosen language, please cross-reference with:
 [sample_binary.py](https://github.com/google/flatbuffers/blob/master/samples/sample_binary.py)
 </div>
 <div class="language-javascript">
-[samplebinary.js](https://github.com/google/flatbuffers/blob/master/samples/samplebinary.js)
+No sample binary is provided, since JS needs to be transpiled from TypeScript. Please see TypeScript support.
 </div>
 <div class="language-typescript">
 <em>none yet</em>
@@ -227,17 +227,18 @@ less memory and have faster lookup.
 
 The `Monster` table is the main object in our FlatBuffer. This will be used as
 the template to store our `orc` monster. We specify some default values for
-fields, such as `mana:short = 150`. All unspecified fields will default to `0`
-or `NULL`. Another thing to note is the line
-`friendly:bool = false (deprecated);`. Since you cannot delete fields from a
-`table` (to support backwards compatability), you can set fields as
-`deprecated`, which will prevent the generation of accessors for this field in
-the generated code. Be careful when using `deprecated`, however, as it may break
-legacy code that used this accessor.
+fields, such as `mana:short = 150`. If unspecified, scalar fields (like `int`,
+`uint`, or `float`) will be given a default of `0` while strings and tables will
+be given a default of `null`. Another thing to note is the line `friendly:bool =
+false (deprecated);`. Since you cannot delete fields from a `table` (to support
+backwards compatability), you can set fields as `deprecated`, which will prevent
+the generation of accessors for this field in the generated code. Be careful
+when using `deprecated`, however, as it may break legacy code that used this
+accessor.
 
 The `Weapon` table is a sub-table used within our FlatBuffer. It is
 used twice: once within the `Monster` table and once within the `Equipment`
-enum. For our `Monster`, it is used to populate a `vector of tables` via the
+union. For our `Monster`, it is used to populate a `vector of tables` via the
 `weapons` field within our `Monster`. It is also the only table referenced by
 the `Equipment` union.
 
@@ -249,10 +250,12 @@ The scalar types can also use alias type names such as `int16` instead
 of `short` and `float32` instead of `float`. Thus we could also write
 the `Weapon` table as:
 
+~~~
   table Weapon {
     name:string;
     damage:int16;
   }
+~~~
 
 #### More Information About Schemas
 
@@ -279,7 +282,6 @@ See [flatcc build instructions](https://github.com/dvidelabs/flatcc#building).
 Please be aware of the difference between `flatc` and `flatcc` tools.
 <br>
 </div>
-
 <div class="language-cpp">
 ~~~{.sh}
   cd flatbuffers/samples
@@ -319,7 +321,9 @@ Please be aware of the difference between `flatc` and `flatcc` tools.
 <div class="language-javascript">
 ~~~{.sh}
   cd flatbuffers/samples
-  ./../flatc --js monster.fbs
+  ./../flatc --ts monster.fbs
+  # customize your TS -> JS transpilation
+  tsc monster_generated.ts
 ~~~
 </div>
 <div class="language-typescript">
@@ -437,8 +441,7 @@ The first step is to import/include the library, generated files, etc.
 </div>
 <div class="language-javascript">
 ~~~{.js}
-  // The following code is for JavaScript module loaders (e.g. Node.js). See
-  // below for a browser-based HTML/JavaScript example of including the library.
+  // The following code is an example - use your desired module flavor by transpiling from TS. 
   var flatbuffers = require('/js/flatbuffers').flatbuffers;
   var MyGame = require('./monster_generated').MyGame; // Generated by `flatc`.
 
@@ -451,9 +454,11 @@ The first step is to import/include the library, generated files, etc.
 ~~~
 </div>
 <div class="language-typescript">
+~~~{.ts}
   // note: import flatbuffers with your desired import method
 
   import { MyGame } from './monster_generated';
+~~~
 </div>
 <div class="language-php">
 ~~~{.php}
@@ -532,7 +537,6 @@ The first step is to import/include the library, generated files, etc.
                                                Weapon, WeaponArgs};
 ~~~
 </div>
-
 <div class="language-swift">
 ~~~{.swift}
   /**
@@ -541,10 +545,10 @@ The first step is to import/include the library, generated files, etc.
   import Flatbuffers
 
   // typealiases for convenience
-  typealias Monster = MyGame1.Sample.Monster
-  typealias Weapon = MyGame1.Sample.Weapon
-  typealias Color = MyGame1.Sample.Color
-  typealias Vec3 = MyGame1.Sample.Vec3
+  typealias Monster = MyGame1_Sample_Monster
+  typealias Weapon = MyGame1_Sample_Weapon
+  typealias Color = MyGame1_Sample_Color
+  typealias Vec3 = MyGame1_Sample_Vec3
 ~~~
 </div>
 
@@ -660,7 +664,7 @@ which will grow automatically if needed:
 </div>
 
 After creating the `builder`, we can start serializing our data. Before we make
-our `orc` Monster, lets create some `Weapon`s: a `Sword` and an `Axe`.
+our `orc` Monster, let's create some `Weapon`s: a `Sword` and an `Axe`.
 
 <div class="language-cpp">
 ~~~{.cpp}
@@ -738,16 +742,16 @@ our `orc` Monster, lets create some `Weapon`s: a `Sword` and an `Axe`.
   weapon_two = builder.CreateString('Axe')
 
   # Create the first `Weapon` ('Sword').
-  MyGame.Sample.Weapon.WeaponStart(builder)
-  MyGame.Sample.Weapon.WeaponAddName(builder, weapon_one)
-  MyGame.Sample.Weapon.WeaponAddDamage(builder, 3)
-  sword = MyGame.Sample.Weapon.WeaponEnd(builder)
+  MyGame.Sample.Weapon.Start(builder)
+  MyGame.Sample.Weapon.AddName(builder, weapon_one)
+  MyGame.Sample.Weapon.AddDamage(builder, 3)
+  sword = MyGame.Sample.Weapon.End(builder)
 
   # Create the second `Weapon` ('Axe').
-  MyGame.Sample.Weapon.WeaponStart(builder)
-  MyGame.Sample.Weapon.WeaponAddName(builder, weapon_two)
-  MyGame.Sample.Weapon.WeaponAddDamage(builder, 5)
-  axe = MyGame.Sample.Weapon.WeaponEnd(builder)
+  MyGame.Sample.Weapon.Start(builder)
+  MyGame.Sample.Weapon.AddName(builder, weapon_two)
+  MyGame.Sample.Weapon.AddDamage(builder, 5)
+  axe = MyGame.Sample.Weapon.End(builder)
 ~~~
 </div>
 <div class="language-javascript">
@@ -769,7 +773,7 @@ our `orc` Monster, lets create some `Weapon`s: a `Sword` and an `Axe`.
 ~~~
 </div>
 <div class="language-typescript">
-~~~{.js}
+~~~{.ts}
   let weaponOne = builder.createString('Sword');
   let weaponTwo = builder.createString('Axe');
 
@@ -908,23 +912,22 @@ our `orc` Monster, lets create some `Weapon`s: a `Sword` and an `Axe`.
   });
 ~~~
 </div>
-
 <div class="language-swift">
 ~~~{.swift}
   let weapon1Name = builder.create(string: "Sword")
   let weapon2Name = builder.create(string: "Axe")
 
   // start creating the weapon by calling startWeapon
-  let weapon1Start = Weapon.startWeapon(builder)
-  Weapon.add(name: weapon1Name, builder)
-  Weapon.add(damage: 3, builder)
+  let weapon1Start = Weapon.startWeapon(&builder)
+  Weapon.add(name: weapon1Name, &builder)
+  Weapon.add(damage: 3, &builder)
   // end the object by passing the start point for the weapon 1
-  let sword = Weapon.endWeapon(builder, start: weapon1Start)
+  let sword = Weapon.endWeapon(&builder, start: weapon1Start)
 
-  let weapon2Start = Weapon.startWeapon(builder)
-  Weapon.add(name: weapon2Name, builder)
-  Weapon.add(damage: 5, builder)
-  let axe = Weapon.endWeapon(builder, start: weapon2Start)
+  let weapon2Start = Weapon.startWeapon(&builder)
+  Weapon.add(name: weapon2Name, &builder)
+  Weapon.add(damage: 5, &builder)
+  let axe = Weapon.endWeapon(&builder, start: weapon2Start)
 ~~~
 </div>
 
@@ -937,7 +940,7 @@ let's fill his inventory with some potential treasures that can be taken once he
 is defeated.
 
 Before we serialize a monster, we need to first serialize any objects that are
-contained there-in, i.e. we serialize the data tree using depth-first, pre-order
+contained therein, i.e. we serialize the data tree using depth-first, pre-order
 traversal. This is generally easy to do on any tree structures.
 
 <div class="language-cpp">
@@ -1012,10 +1015,10 @@ traversal. This is generally easy to do on any tree structures.
   # Create a `vector` representing the inventory of the Orc. Each number
   # could correspond to an item that can be claimed after he is slain.
   # Note: Since we prepend the bytes, this loop iterates in reverse.
-  MyGame.Sample.Monster.MonsterStartInventoryVector(builder, 10)
+  MyGame.Sample.Monster.StartInventoryVector(builder, 10)
   for i in reversed(range(0, 10)):
     builder.PrependByte(i)
-  inv = builder.EndVector(10)
+  inv = builder.EndVector()
 ~~~
 </div>
 <div class="language-javascript">
@@ -1030,7 +1033,7 @@ traversal. This is generally easy to do on any tree structures.
 ~~~
 </div>
 <div class="language-typescript">
-~~~{.js}
+~~~{.ts}
   // Serialize a name for our monster, called 'Orc'.
   let name = builder.createString('Orc');
 
@@ -1202,10 +1205,10 @@ offsets.
 ~~~{.py}
   # Create a FlatBuffer vector and prepend the weapons.
   # Note: Since we prepend the data, prepend them in reverse order.
-  MyGame.Sample.Monster.MonsterStartWeaponsVector(builder, 2)
+  MyGame.Sample.Monster.StartWeaponsVector(builder, 2)
   builder.PrependUOffsetTRelative(axe)
   builder.PrependUOffsetTRelative(sword)
-  weapons = builder.EndVector(2)
+  weapons = builder.EndVector()
 ~~~
 </div>
 <div class="language-javascript">
@@ -1281,8 +1284,8 @@ offsets.
 </div>
 
 <br>
-Note there's additional convenience overloads of `CreateVector`, allowing you
-to work with data that's not in a `std::vector`, or allowing you to generate
+Note there are additional convenience overloads of `CreateVector`, allowing you
+to work with data that's not in a `std::vector` or allowing you to generate
 elements by calling a lambda. For the common case of `std::vector<std::string>`
 there's also `CreateVectorOfStrings`.
 </div>
@@ -1331,10 +1334,10 @@ for the `path` field above:
 </div>
 <div class="language-python">
 ~~~{.py}
-  MyGame.Sample.Monster.MonsterStartPathVector(builder, 2)
+  MyGame.Sample.Monster.StartPathVector(builder, 2)
   MyGame.Sample.Vec3.CreateVec3(builder, 1.0, 2.0, 3.0)
   MyGame.Sample.Vec3.CreateVec3(builder, 4.0, 5.0, 6.0)
-  path = builder.EndVector(2)
+  path = builder.EndVector()
 ~~~
 </div>
 <div class="language-javascript">
@@ -1418,9 +1421,21 @@ for the `path` field above:
 <div class="language-swift">
 ~~~{.swift}
   //
-  let points = builder.createVector(structs: [MyGame.Sample.createVec3(x: 1, y: 2, z: 3), 
-                                              MyGame.Sample.createVec3(x: 4, y: 5, z: 6)],
-                                   type: Vec3.self)
+  let points = fbb.createVector(ofStructs: [
+    Vec3(x: 1, y: 2, z: 3),
+    Vec3(x: 4, y: 5, z: 6)
+  ])
+
+  // OR
+  var vec3 = [
+    Vec3(x: 1, y: 2, z: 3),
+    Vec3(x: 4, y: 5, z: 6)
+  ]
+  Monster.startVectorOfVec3(2, in: &fbb)
+  for i in obj {
+    _ = create(struct: i)
+  }
+  let points = fbb.endVector(len: size)
 ~~~
 </div>
 
@@ -1510,21 +1525,21 @@ can serialize the monster itself:
 </div>
 <div class="language-python">
 ~~~{.py}
-  # Create our monster by using `MonsterStart()` and `MonsterEnd()`.
-  MyGame.Sample.Monster.MonsterStart(builder)
-  MyGame.Sample.Monster.MonsterAddPos(builder,
+  # Create our monster by using `Monster.Start()` and `Monster.End()`.
+  MyGame.Sample.Monster.Start(builder)
+  MyGame.Sample.Monster.AddPos(builder,
                           MyGame.Sample.Vec3.CreateVec3(builder, 1.0, 2.0, 3.0))
-  MyGame.Sample.Monster.MonsterAddHp(builder, 300)
-  MyGame.Sample.Monster.MonsterAddName(builder, name)
-  MyGame.Sample.Monster.MonsterAddInventory(builder, inv)
-  MyGame.Sample.Monster.MonsterAddColor(builder,
+  MyGame.Sample.Monster.AddHp(builder, 300)
+  MyGame.Sample.Monster.AddName(builder, name)
+  MyGame.Sample.Monster.AddInventory(builder, inv)
+  MyGame.Sample.Monster.AddColor(builder,
                                         MyGame.Sample.Color.Color().Red)
-  MyGame.Sample.Monster.MonsterAddWeapons(builder, weapons)
-  MyGame.Sample.Monster.MonsterAddEquippedType(
+  MyGame.Sample.Monster.AddWeapons(builder, weapons)
+  MyGame.Sample.Monster.AddEquippedType(
       builder, MyGame.Sample.Equipment.Equipment().Weapon)
-  MyGame.Sample.Monster.MonsterAddEquipped(builder, axe)
-  MyGame.Sample.Monster.MonsterAddPath(builder, path)
-  orc = MyGame.Sample.Monster.MonsterEnd(builder)
+  MyGame.Sample.Monster.AddEquipped(builder, axe)
+  MyGame.Sample.Monster.AddPath(builder, path)
+  orc = MyGame.Sample.Monster.End(builder)
 ~~~
 </div>
 <div class="language-javascript">
@@ -1699,15 +1714,16 @@ can serialize the monster itself:
 </div>
 <div class="language-swift">
 ~~~{.swift}
-  let orc = Monster.createMonster(builder, 
-                                  offsetOfPos: pos,
-                                  hp: 300,
-                                  offsetOfName: name,
-                                  vectorOfInventory: inventoryOffset,
-                                  color: .red,
-                                  vectorOfWeapons: weaponsOffset,
-                                  equippedType: .weapon,
-                                  offsetOfEquipped: axe)
+  let orc = Monster.createMonster(
+    &builder,
+    pos: MyGame_Sample_Vec3(x: 1, y: 2, z: 3),
+    hp: 300,
+    nameOffset: name,
+    inventoryVectorOffset: inventoryOffset,
+    color: .red,
+    weaponsVectorOffset: weaponsOffset,
+    equippedType: .weapon,
+    equippedOffset: axe)
 ~~~
 </div>
 
@@ -1724,7 +1740,7 @@ you will get an assert/exception/panic depending on your language.
 default value, the field will not actually be written to the buffer, since the
 default value will be returned on query anyway. This is a nice space savings,
 especially if default values are common in your data. It also means that you do
-not need to be worried of adding a lot of fields that are only used in a small
+not need to be worried about adding a lot of fields that are only used in a small
 number of instances, as it will not bloat the buffer if unused.*
 
 <div class="language-cpp">
@@ -1777,29 +1793,29 @@ a bit more flexibility.
 
 <div class="language-swift">
 ~~~{.swift}
-  let start = Monster.startMonster(builder)
-  Monster.add(pos: pos, builder)
-  Monster.add(hp: 300, builder)
-  Monster.add(name: name, builder)
-  Monster.addVectorOf(inventory: inventoryOffset, builder)
-  Monster.add(color: .red, builder)
-  Monster.addVectorOf(weapons: weaponsOffset, builder)
-  Monster.add(equippedType: .weapon, builder)
-  Monster.add(equipped: axe, builder)
-  var orc = Monster.endMonster(builder, start: start)
+  let start = Monster.startMonster(&builder)
+  Monster.add(pos: Vec3(x: 1, y: 2, z: 3), &builder)
+  Monster.add(hp: 300, &builder)
+  Monster.add(name: name, &builder)
+  Monster.addVectorOf(inventory: inventoryOffset, &builder)
+  Monster.add(color: .red, &builder)
+  Monster.addVectorOf(weapons: weaponsOffset, &builder)
+  Monster.add(equippedType: .weapon, &builder)
+  Monster.add(equipped: axe, &builder)
+  var orc = Monster.endMonster(&builder, start: start)
 ~~~
 </div>
 
 Before finishing the serialization, let's take a quick look at FlatBuffer
-`union Equipped`. There are two parts to each FlatBuffer `union`. The first, is
-a hidden field `_type`, that is generated to hold the type of `table` referred
+`union Equipped`. There are two parts to each FlatBuffer `union`. The first is
+a hidden field `_type` that is generated to hold the type of `table` referred
 to by the `union`. This allows you to know which type to cast to at runtime.
-Second, is the `union`'s data.
+Second is the `union`'s data.
 
 In our example, the last two things we added to our `Monster` were the
 `Equipped Type` and the `Equipped` union itself.
 
-Here is a repetition these lines, to help highlight them more clearly:
+Here is a repetition of these lines, to help highlight them more clearly:
 
 <div class="language-cpp">
   ~~~{.cpp}
@@ -1833,9 +1849,9 @@ Here is a repetition these lines, to help highlight them more clearly:
 </div>
 <div class="language-python">
   ~~~{.py}
-    MyGame.Sample.Monster.MonsterAddEquippedType(            # Union type
+    MyGame.Sample.Monster.AddEquippedType(            # Union type
         builder, MyGame.Sample.Equipment.Equipment().Weapon)
-    MyGame.Sample.Monster.MonsterAddEquipped(builder, axe)   # Union data
+    MyGame.Sample.Monster.AddEquipped(builder, axe)   # Union data
   ~~~
 </div>
 <div class="language-javascript">
@@ -1911,8 +1927,7 @@ appropriate `finish` method.
   // Call `Finish()` to instruct the builder that this monster is complete.
   // Note: Regardless of how you created the `orc`, you still need to call
   // `Finish()` on the `FlatBufferBuilder`.
-  builder.Finish(orc); // You could also call `FinishMonsterBuffer(builder,
-                       //                                          orc);`.
+  builder.Finish(orc); // You could also call `FinishMonsterBuffer(builder, orc);`.
 ~~~
 </div>
 <div class="language-java">
@@ -1948,22 +1963,19 @@ appropriate `finish` method.
 <div class="language-javascript">
 ~~~{.js}
   // Call `finish()` to instruct the builder that this monster is complete.
-  builder.finish(orc); // You could also call `MyGame.Sample.Monster.finishMonsterBuffer(builder,
-                       //                                                                 orc);`.
+  builder.finish(orc); // You could also call `MyGame.Sample.Monster.finishMonsterBuffer(builder, orc);`.
 ~~~
 </div>
 <div class="language-typescript">
 ~~~{.ts}
   // Call `finish()` to instruct the builder that this monster is complete.
-  builder.finish(orc); // You could also call `MyGame.Sample.Monster.finishMonsterBuffer(builder,
-                       //                                                                 orc);`.
+  builder.finish(orc); // You could also call `MyGame.Sample.Monster.finishMonsterBuffer(builder, orc);`.
 ~~~
 </div>
 <div class="language-php">
 ~~~{.php}
   // Call `finish()` to instruct the builder that this monster is complete.
-   $builder->finish($orc); // You may also call `\MyGame\Sample\Monster::FinishMonsterBuffer(
-                           //                        $builder, $orc);`.
+   $builder->finish($orc); // You may also call `\MyGame\Sample\Monster::FinishMonsterBuffer($builder, $orc);`.
 ~~~
 </div>
 <div class="language-c">
@@ -2128,7 +2140,6 @@ like so:
   let buf = builder.finished_data(); // Of type `&[u8]`
 ~~~
 </div>
-
 <div class="language-swift">
 ~~~{.swift}
   // This must be called after `finish()`.
@@ -2139,11 +2150,24 @@ like so:
 ~~~
 </div>
 
-Now you can write the bytes to a file, send them over the network..
+Now you can write the bytes to a file or send them over the network.
 **Make sure your file mode (or transfer protocol) is set to BINARY, not text.**
 If you transfer a FlatBuffer in text mode, the buffer will be corrupted,
 which will lead to hard to find problems when you read the buffer.
 
+<div class="language-javascript">
+For example, in Node you can simply do:
+~~~{.js}
+  writeFileSync('monster.bin', buf, 'binary');
+~~~
+</div>
+<div class="language-typescript">
+For example, in Node you can simply do:
+~~~{.ts}
+  writeFileSync('monster.bin', buf, 'binary');
+~~~
+</div>
+
 #### Reading Orc FlatBuffers
 
 Now that we have successfully created an `Orc` FlatBuffer, the monster data can
@@ -2201,23 +2225,23 @@ before:
 </div>
 <div class="language-javascript">
 ~~~{.js}
-  // The following code is for JavaScript module loaders (e.g. Node.js). See
-  // below for a browser-based HTML/JavaScript example of including the library.
+  // The following code is an example - use your desired module flavor by transpiling from TS. 
   var flatbuffers = require('/js/flatbuffers').flatbuffers;
   var MyGame = require('./monster_generated').MyGame; // Generated by `flatc`.
 
   //--------------------------------------------------------------------------//
 
-  // The following code is for browser-based HTML/JavaScript. Use the above code
+  // The following code an example for browser-based HTML/JavaScript. Use the above code
   // for JavaScript module loaders (e.g. Node.js).
   <script src="../js/flatbuffers.js"></script>
   <script src="monster_generated.js"></script> // Generated by `flatc`.
 ~~~
 </div>
 <div class="language-typescript">
-~~~{.js}
-  // note: import flabuffers with your desired import method
+~~~{.ts}
+  // note: import flatbuffers with your desired import method
 
+  // note: the `./monster_generated.ts` file was previously generated by `flatc` above using the `monster.fbs` schema
   import { MyGame } from './monster_generated';
 ~~~
 </div>
@@ -2295,10 +2319,10 @@ import './monster_my_game.sample_generated.dart' as myGame;
 </div>
 
 Then, assuming you have a buffer of bytes received from disk,
-network, etc., you can create start accessing the buffer like so:
+network, etc., you can start accessing the buffer like so:
 
 **Again, make sure you read the bytes in BINARY mode, otherwise the code below
-won't work**
+won't work.**
 
 <div class="language-cpp">
 ~~~{.cpp}
@@ -2358,7 +2382,7 @@ won't work**
   buf = /* the data you just read, in an object of type "bytearray" */
 
   // Get an accessor to the root object inside the buffer.
-  monster = MyGame.Sample.Monster.Monster.GetRootAsMonster(buf, 0)
+  monster = MyGame.Sample.Monster.Monster.GetRootAs(buf, 0)
 
   # Note: We use `0` for the offset here, which is typical for most buffers
   # you would read.  If you wanted to read from the `builder.Bytes` directly,
@@ -2368,7 +2392,11 @@ won't work**
 </div>
 <div class="language-javascript">
 ~~~{.js}
-  var bytes = /* the data you just read, in an object of type "Uint8Array" */
+  // the data you just read, as a `Uint8Array`
+  // Note that the example here uses `readFileSync` from the built-in `fs` module,
+  // but other methods for accessing the file contents will also work.
+  var bytes = new Uint8Array(readFileSync('./monsterdata.bin'));
+
   var buf = new flatbuffers.ByteBuffer(bytes);
 
   // Get an accessor to the root object inside the buffer.
@@ -2377,7 +2405,11 @@ won't work**
 </div>
 <div class="language-typescript">
 ~~~{.ts}
-  let bytes = /* the data you just read, in an object of type "Uint8Array" */
+  // the data you just read, as a `Uint8Array`.
+  // Note that the example here uses `readFileSync` from the built-in `fs` module,
+  // but other methods for accessing the file contents will also work.
+  let bytes = new Uint8Array(readFileSync('./monsterdata.bin'));
+
   let buf = new flatbuffers.ByteBuffer(bytes);
 
   // Get an accessor to the root object inside the buffer.
@@ -2437,7 +2469,6 @@ myGame.Monster monster = new myGame.Monster(data);
   let monster = get_root_as_monster(buf);
 ~~~
 </div>
-
 <div class="language-swift">
 ~~~{.swift}
   // create a ByteBuffer(:) from an [UInt8] or Data()
@@ -2497,16 +2528,16 @@ accessors for all non-`deprecated` fields. For example:
 </div>
 <div class="language-javascript">
 ~~~{.js}
-  var hp = $monster.hp();
-  var mana = $monster.mana();
-  var name = $monster.name();
+  var hp = monster.hp();
+  var mana = monster.mana();
+  var name = monster.name();
 ~~~
 </div>
 <div class="language-typescript">
 ~~~{.ts}
-  let hp = $monster.hp();
-  let mana = $monster.mana();
-  let name = $monster.name();
+  let hp = monster.hp();
+  let mana = monster.mana();
+  let name = monster.name();
 ~~~
 </div>
 <div class="language-php">
@@ -2554,7 +2585,6 @@ accessors for all non-`deprecated` fields. For example:
   let name = monster.name();
 ~~~
 </div>
-
 <div class="language-swift">
 ~~~{.swift}
   let hp = monster.hp
@@ -2687,7 +2717,6 @@ To access sub-objects, in the case of our `pos`, which is a `Vec3`:
   let z = pos.z();
 ~~~
 </div>
-
 <div class="language-swift">
 ~~~{.swift}
   let pos = monster.pos
@@ -2699,7 +2728,7 @@ To access sub-objects, in the case of our `pos`, which is a `Vec3`:
 
 `x`, `y`, and `z` will contain `1.0`, `2.0`, and `3.0`, respectively.
 
-*Note: Had we not set `pos` during serialization, it would be a `NULL`-value.*
+*Note: Had we not set `pos` during serialization, it would be a `null`-value.*
 
 Similarly, we can access elements of the inventory `vector` by indexing it. You
 can also iterate over the length of the array/vector representing the
@@ -2788,7 +2817,7 @@ FlatBuffers `vector`.
 </div>
 <div class="language-rust">
 ~~~{.rs}
-  // Get a test an element from the `inventory` FlatBuffer's `vector`.
+  // Get and test an element from the `inventory` FlatBuffer's `vector`.
   let inv = monster.inventory().unwrap();
 
   // Note that this vector is returned as a slice, because direct access for
@@ -2796,7 +2825,6 @@ FlatBuffers `vector`.
   let third_item = inv[2];
 ~~~
 </div>
-
 <div class="language-swift">
 ~~~{.swift}
   // Get a the count of objects in the vector
@@ -2812,7 +2840,7 @@ FlatBuffers `vector`.
 </div>
 
 For `vector`s of `table`s, you can access the elements like any other vector,
-except your need to handle the result as a FlatBuffer `table`:
+except you need to handle the result as a FlatBuffer `table`:
 
 <div class="language-cpp">
 ~~~{.cpp}
@@ -3032,8 +3060,8 @@ We can access the type to dynamically cast the data as needed (since the
   var unionType = monster.equippedType();
 
   if (unionType == MyGame.Sample.Equipment.Weapon) {
-    var weapon_name = monster.equipped(new MyGame.Sample.Weapon()).name();     // 'Axe'
-    var weapon_damage = monster.equipped(new MyGame.Sample.Weapon()).damage(); // 5
+    var weaponName = monster.equipped(new MyGame.Sample.Weapon()).name();     // 'Axe'
+    var weaponDamage = monster.equipped(new MyGame.Sample.Weapon()).damage(); // 5
   }
 ~~~
 </div>
@@ -3042,8 +3070,8 @@ We can access the type to dynamically cast the data as needed (since the
   let unionType = monster.equippedType();
 
   if (unionType == MyGame.Sample.Equipment.Weapon) {
-    let weapon_name = monster.equipped(new MyGame.Sample.Weapon()).name();     // 'Axe'
-    let weapon_damage = monster.equipped(new MyGame.Sample.Weapon()).damage(); // 5
+    let weaponName = monster.equipped(new MyGame.Sample.Weapon()).name();     // 'Axe'
+    let weaponDamage = monster.equipped(new MyGame.Sample.Weapon()).damage(); // 5
   }
 ~~~
 </div>
@@ -3111,7 +3139,7 @@ We can access the type to dynamically cast the data as needed (since the
 ~~~{.rs}
   // Get and test the `Equipment` union (`equipped` field).
   // `equipped_as_weapon` returns a FlatBuffer handle much like normal table
-  // fields, but this will return `None` is the union is not actually of that
+  // fields, but this will return `None` if the union is not actually of that
   // type.
   if monster.equipped_type() == Equipment::Weapon {
     let equipped = monster.equipped_as_weapon().unwrap();
@@ -3119,7 +3147,6 @@ We can access the type to dynamically cast the data as needed (since the
     let weapon_damage = equipped.damage();
 ~~~
 </div>
-
 <div class="language-swift">
 ~~~{.swift}
   // Get and check if the monster has an equipped item
@@ -3233,12 +3260,12 @@ mutators like so:
   <API for mutating FlatBuffers is not yet available in Rust.>
 ~~~
 </div>
-
 <div class="language-swift">
 ~~~{.swift}
   let monster = Monster.getRootAsMonster(bb: ByteBuffer(bytes: buf))
   monster.mutate(hp: 10) // mutates a value in a table
-  monster.pos.mutate(z: 4) // mutates a value in a struct
+  /// to mutate structs in swift you have to use the mutable accessors
+  monster.mutablePos.mutate(z: 4) // mutates a value in a struct
   monster.mutate(inventory: 6, at index: 0) // mutates a value in an Scalar array
 ~~~
 </div>
@@ -3252,7 +3279,7 @@ without any further work!
 
 Note that any `mutate` functions on a table will return a boolean, which is
 `false` if the field we're trying to set is not present in the buffer. Fields
-that are not present if they weren't set, or even if they happen to be equal to
+are not present if they weren't set, or even if they happen to be equal to
 the default value. For example, in the creation code above, the `mana`
 field is equal to `150`, which is the default value, so it was never stored in
 the buffer. Trying to call the corresponding `mutate` method for `mana` on such
@@ -3278,34 +3305,34 @@ as part of your compilation).
 
 #### JSON to binary representation
 
-Lets say you have a JSON file that describes your monster. In this example,
+Let's say you have a JSON file that describes your monster. In this example,
 we will use the file `flatbuffers/samples/monsterdata.json`.
 
 Here are the contents of the file:
 
 ~~~{.json}
 {
-  pos: {
-    x: 1.0,
-    y: 2.0,
-    z: 3.0
+  "pos": {
+    "x": 1.0,
+    "y": 2.0,
+    "z": 3.0
   },
-  hp: 300,
-  name: "Orc",
-  weapons: [
+  "hp": 300,
+  "name": "Orc",
+  "weapons": [
     {
-      name: "axe",
-      damage: 100
+      "name": "axe",
+      "damage": 100
     },
     {
-      name: "bow",
-      damage: 90
+      "name": "bow",
+      "damage": 90
     }
   ],
-  equipped_type: "Weapon",
-  equipped: {
-    name: "bow",
-    damage: 90
+  "equipped_type": "Weapon",
+  "equipped": {
+    "name": "bow",
+    "damage": 90
   }
 }
 ~~~
@@ -3314,7 +3341,7 @@ You can run this file through the `flatc` compiler with the `-b` flag and
 our `monster.fbs` schema to produce a FlatBuffer binary file.
 
 ~~~{.sh}
-./../flatc -b monster.fbs monsterdata.json
+./../flatc --binary monster.fbs monsterdata.json
 ~~~
 
 The output of this will be a file `monsterdata.bin`, which will contain the
@@ -3361,7 +3388,7 @@ on `--strict-json` so that identifiers are quoted properly.
 *Note: The resulting JSON file is not necessarily identical with the original JSON.
 If the binary representation contains floating point numbers, floats and doubles
 are rounded to 6 and 12 digits, respectively, in order to represent them as
-decimals in the JSON document. *
+decimals in the JSON document.*
 
 ## Advanced Features for Each Language
 

docs/source/TypeScriptUsage.md

@@ -17,7 +17,7 @@ documentation to build `flatc` and should be familiar with
 ## FlatBuffers TypeScript library code location
 
 The code for the FlatBuffers TypeScript library can be found at
-`flatbuffers/js` with typings available at `@types/flatbuffers`.
+https://www.npmjs.com/package/flatbuffers.
 
 ## Testing the FlatBuffers TypeScript library
 
@@ -43,7 +43,7 @@ First, include the library and generated code. Then read the file into an
 the ByteBuffer to the `getRootAsMonster` function.
 
 ~~~{.ts}
-  // note: import flatbuffers with your desired import method
+  import * as flatbuffers from 'flatbuffers';
 
   import { MyGame } from './monster_generated';
 
@@ -60,6 +60,36 @@ Now you can access values like this:
   let pos = monster.pos();
 ~~~
 
+## 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
+(requiring pre-order construction of all data, and making mutation harder).
+
+For times when efficiency is less important a more convenient object based API
+can be used (through `--gen-object-api`) that is able to unpack & pack a
+FlatBuffer into objects and standard TS types.
+
+To use:
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.ts}
+    // Autogenerated class from table Monster.
+    let monsterobj = new MonsterT();
+
+    // Deserialize from buffer into object.
+    Monster.getRootAsMonster(flatbuffer).unpackTo(monsterobj);
+    // or
+    let monsterobj = Monster.getRootAsMonster(flatbuffer).unpack();
+
+    // Update object directly like a regular TS class instance.
+    console.log(monsterobj.name);
+    monsterobj.name = "Bob";
+
+    // Serialize into new flatbuffer.
+    let fbb = new flatbuffers.Builder(1);
+    Monster.finishMonsterBuffer(fbb, monsterobj.pack(fbb));
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
 ## Text parsing FlatBuffers in TypeScript
 
 There currently is no support for parsing text (Schema's and JSON) directly

docs/source/doxyfile

@@ -753,7 +753,9 @@ INPUT = "FlatBuffers.md" \
         "CUsage.md" \
         "DartUsage.md" \
         "GoUsage.md" \
-        "JavaCsharpUsage.md" \
+        "JavaUsage.md" \
+        "CsharpUsage.md" \
+        "SwiftUsage.md" \
         "JavaScriptUsage.md" \
         "TypeScriptUsage.md" \
         "PHPUsage.md" \

docs/source/doxygen_layout.xml

@@ -49,6 +49,8 @@
           title="Use in Lobster"/>
       <tab type="user" url="@ref flatbuffers_guide_use_rust"
           title="Use in Rust"/>
+      <tab type="user" url="@ref flatbuffers_guide_use_swift"
+          title="Use in Swift"/>
       <tab type="user" url="@ref flexbuffers"
           title="FlexBuffers (Schema-less version)"/>
       <tab type="usergroup" url="" title="gRPC">

go/builder.go

@@ -22,6 +22,7 @@ type Builder struct {
 }
 
 const fileIdentifierLength = 4
+const sizePrefixLength = 4
 
 // NewBuilder initializes a Builder of size `initial_size`.
 // The internal buffer is grown as needed.
@@ -53,6 +54,12 @@ func (b *Builder) Reset() {
 		b.vtable = b.vtable[:0]
 	}
 
+	if b.sharedStrings != nil {
+		for key := range b.sharedStrings {
+			delete(b.sharedStrings, key)
+		}
+	}
+
 	b.head = UOffsetT(len(b.Bytes))
 	b.minalign = 1
 	b.nested = false
@@ -574,11 +581,53 @@ func (b *Builder) FinishWithFileIdentifier(rootTable UOffsetT, fid []byte) {
 	b.Finish(rootTable)
 }
 
+// FinishSizePrefixed finalizes a buffer, pointing to the given `rootTable`.
+// The buffer is prefixed with the size of the buffer, excluding the size
+// of the prefix itself.
+func (b *Builder) FinishSizePrefixed(rootTable UOffsetT) {
+	b.finish(rootTable, true)
+}
+
+// FinishSizePrefixedWithFileIdentifier finalizes a buffer, pointing to the given `rootTable`
+// and applies a file identifier. The buffer is prefixed with the size of the buffer,
+// excluding the size of the prefix itself.
+func (b *Builder) FinishSizePrefixedWithFileIdentifier(rootTable UOffsetT, fid []byte) {
+	if fid == nil || len(fid) != fileIdentifierLength {
+		panic("incorrect file identifier length")
+	}
+	// In order to add a file identifier and size prefix to the flatbuffer message,
+	// we need to prepare an alignment, a size prefix length, and file identifier length
+	b.Prep(b.minalign, SizeInt32+fileIdentifierLength+sizePrefixLength)
+	for i := fileIdentifierLength - 1; i >= 0; i-- {
+		// place the file identifier
+		b.PlaceByte(fid[i])
+	}
+	// finish
+	b.finish(rootTable, true)
+}
+
 // Finish finalizes a buffer, pointing to the given `rootTable`.
 func (b *Builder) Finish(rootTable UOffsetT) {
+	b.finish(rootTable, false)
+}
+
+// finish finalizes a buffer, pointing to the given `rootTable`
+// with an optional size prefix.
+func (b *Builder) finish(rootTable UOffsetT, sizePrefix bool) {
 	b.assertNotNested()
-	b.Prep(b.minalign, SizeUOffsetT)
+
+	if sizePrefix {
+		b.Prep(b.minalign, SizeUOffsetT+sizePrefixLength)
+	} else {
+		b.Prep(b.minalign, SizeUOffsetT)
+	}
+
 	b.PrependUOffsetT(rootTable)
+
+	if sizePrefix {
+		b.PlaceUint32(uint32(b.Offset()))
+	}
+
 	b.finished = true
 }
 

go/encode.go

@@ -118,7 +118,7 @@ func GetFloat64(buf []byte) float64 {
 
 // GetUOffsetT decodes a little-endian UOffsetT from a byte slice.
 func GetUOffsetT(buf []byte) UOffsetT {
-	return UOffsetT(GetInt32(buf))
+	return UOffsetT(GetUint32(buf))
 }
 
 // GetSOffsetT decodes a little-endian SOffsetT from a byte slice.

go/lib.go

@@ -11,3 +11,15 @@ func GetRootAs(buf []byte, offset UOffsetT, fb FlatBuffer) {
 	n := GetUOffsetT(buf[offset:])
 	fb.Init(buf, n+offset)
 }
+
+// GetSizePrefixedRootAs is a generic helper to initialize a FlatBuffer with the provided size-prefixed buffer
+// bytes and its data offset
+func GetSizePrefixedRootAs(buf []byte, offset UOffsetT, fb FlatBuffer) {
+	n := GetUOffsetT(buf[offset+sizePrefixLength:])
+	fb.Init(buf, n+offset+sizePrefixLength)
+}
+
+// GetSizePrefix reads the size from a size-prefixed flatbuffer
+func GetSizePrefix(buf []byte, offset UOffsetT) uint32 {
+	return GetUint32(buf[offset:])
+}

grpc/README.md

@@ -22,6 +22,12 @@ the GRPC libraries for this to compile. This test will build using the
 5. `cmake -DFLATBUFFERS_BUILD_GRPCTEST=ON -DGRPC_INSTALL_PATH=${GRPC_INSTALL_PATH} -DPROTOBUF_DOWNLOAD_PATH=${PROTOBUF_DOWNLOAD_PATH} ..`
 6. `make`
 
+For Bazel users:
+
+```shell
+$bazel test src/compiler/...
+```
+
 ## Running FlatBuffer gRPC tests
 
 ### Linux
@@ -29,3 +35,9 @@ the GRPC libraries for this to compile. This test will build using the
 1. `ln -s ${GRPC_INSTALL_PATH}/lib/libgrpc++_unsecure.so.6 ${GRPC_INSTALL_PATH}/lib/libgrpc++_unsecure.so.1`
 2. `export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${GRPC_INSTALL_PATH}/lib`
 3. `make test ARGS=-V` 
+
+For Bazel users:
+
+```shell
+$bazel test tests/...
+```

grpc/boringssl.patch

@@ -0,0 +1,13 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 1645a264a..12f8ca999 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -635,6 +635,8 @@ add_library(
+   src/ssl/tls_record.cc
+ )
+ 
++target_link_libraries(ssl crypto)
++
+ add_executable(
+   bssl
+ 

grpc/build_grpc.sh

@@ -1,14 +1,20 @@
 #!/bin/bash
 
-grpc_1_15_1_githash=1a60e6971f428323245a930031ad267bb3142ba4
+grpc_1_36_0_githash=736e3758351ced3cd842bad3ba4e2540f01bbc48
 
 function build_grpc () {
   git clone https://github.com/grpc/grpc.git google/grpc
   cd google/grpc
-  git checkout ${grpc_1_15_1_githash}
+  git checkout ${grpc_1_36_0_githash}
   git submodule update --init
-  make
-  make install prefix=`pwd`/install
+  # Apply boringssl build patch
+  cd third_party/boringssl-with-bazel
+  git apply ../../../../grpc/boringssl.patch
+  cd ../..
+  mkdir ../grpc_build
+  cd ../grpc_build
+  cmake ../grpc -DgRPC_INSTALL=ON -DgRPC_BUILD_TESTS=OFF -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX=`pwd`/../grpc/install
+  cmake --build . --target install ${JOBS:+-j$JOBS}
   if [ ! -f ${GRPC_INSTALL_PATH}/lib/libgrpc++_unsecure.so.1 ]; then
     ln -s ${GRPC_INSTALL_PATH}/lib/libgrpc++_unsecure.so.6 ${GRPC_INSTALL_PATH}/lib/libgrpc++_unsecure.so.1
   fi