[ { "path": ".bazelci/presubmit.yml", "content": "---\nbuildifier: latest\nmatrix:\n bazel:\n - 7.x\n - 8.x\ntasks:\n verify_ubuntu2004:\n platform: ubuntu2004\n bazel: ${{ bazel }}\n environment:\n CC: clang\n SWIFT_VERSION: \"5.10\"\n SWIFT_HOME: \"$HOME/swift-$SWIFT_VERSION\"\n PATH: \"$PATH:$SWIFT_HOME/usr/bin\"\n shell_commands:\n - \"echo --- Downloading and extracting Swift $SWIFT_VERSION to $SWIFT_HOME\"\n - \"mkdir $SWIFT_HOME\"\n - \"curl https://download.swift.org/swift-${SWIFT_VERSION}-release/ubuntu2004/swift-${SWIFT_VERSION}-RELEASE/swift-${SWIFT_VERSION}-RELEASE-ubuntu20.04.tar.gz | tar xvz --strip-components=1 -C $SWIFT_HOME\"\n build_targets:\n - \"//...\"\n test_targets:\n - \"//...\"\n verify_ubuntu2204:\n platform: ubuntu2204\n bazel: ${{ bazel }}\n environment:\n CC: clang\n SWIFT_VERSION: \"5.10\"\n SWIFT_HOME: \"$HOME/swift-$SWIFT_VERSION\"\n PATH: \"$PATH:$SWIFT_HOME/usr/bin\"\n shell_commands:\n - \"echo --- Downloading and extracting Swift $SWIFT_VERSION to $SWIFT_HOME\"\n - \"mkdir $SWIFT_HOME\"\n - \"curl https://download.swift.org/swift-${SWIFT_VERSION}-release/ubuntu2204/swift-${SWIFT_VERSION}-RELEASE/swift-${SWIFT_VERSION}-RELEASE-ubuntu22.04.tar.gz | tar xvz --strip-components=1 -C $SWIFT_HOME\"\n build_targets:\n - \"//...\"\n test_targets:\n - \"//...\"\n test_module_cpp:\n platform: ubuntu2204\n bazel: ${{ bazel }}\n working_directory: tests/bazel_repository_test_dir\n build_targets:\n - \"//...\"\n test_module_ts:\n platform: ubuntu2204\n bazel: ${{ bazel }}\n working_directory: tests/ts/bazel_repository_test_dir\n test_targets:\n - \"//...\"\n verify_macos:\n platform: macos\n bazel: ${{ bazel }}\n xcode_version: \"15.2\"\n build_targets:\n - \"//:flatbuffers\"\n - \"//:flatc\"\n test_targets:\n - \"//tests:flatbuffers_test\"\n" }, { "path": ".bazelignore", "content": "ts/node_modules\n\n# Test workspaces\ntests/bazel_repository_test_dir\ntests/ts/bazel_repository_test_dir\n" }, { "path": ".bazelrc", "content": "# We cannot use \"common\" here because the \"version\" command doesn't support\n# --deleted_packages. We need to specify it for both build and query instead.\nbuild --deleted_packages=tests/bazel_repository_test_dir,tests/ts/bazel_repository_test_dir\nquery --deleted_packages=tests/bazel_repository_test_dir,tests/ts/bazel_repository_test_dir\n# Point tools such as coursier (used in rules_jvm_external) to Bazel's internal JDK\n# suggested in https://github.com/bazelbuild/rules_jvm_external/issues/445\ncommon --repo_env=JAVA_HOME=../bazel_tools/jdk\ncommon --action_env=JAVA_HOME=../bazel_tools/jdk\n# Workaround \"Error: need --enable_runfiles on Windows for to support rules_js\"\ncommon:windows --enable_runfiles\n# Swift is not required on Windows\ncommon:windows --deleted_packages=swift\n# Ignore warnings in external dependencies\nbuild --per_file_copt=external/.*@-Wno-everything --host_per_file_copt=external/.*@-Wno-everything\n# Honor the setting of `skipLibCheck` in the tsconfig.json file.\ncommon --@aspect_rules_ts//ts:skipLibCheck=honor_tsconfig\n# Use \"tsc\" as the transpiler when ts_project has no `transpiler` set.\ncommon --@aspect_rules_ts//ts:default_to_tsc_transpiler\n" }, { "path": ".clang-format", "content": "---\nLanguage: Cpp\nBasedOnStyle: Google\n...\n\n" }, { "path": ".clang-tidy", "content": "---\nFormatStyle: \"file\"\nWarningsAsErrors: \"*\"\nHeaderFilterRegex: \".*\"\nChecks: \"google-build-explicit-make-pair,\n google-build-namespaces,\n google-build-using-namespace,\n google-default-arguments,\n google-explicit-constructor,\n google-global-names-in-headers,\n google-objc-avoid-nsobject-new,\n google-objc-avoid-throwing-exception,\n google-objc-function-naming,\n google-objc-global-variable-declaration,\n google-readability-avoid-underscore-in-googletest-name,\n google-readability-braces-around-statements,\n google-readability-casting,\n google-readability-function-size,\n google-readability-namespace-comments,\n google-runtime-int,\n google-runtime-operator,\n google-upgrade-googletest-case,\n clang-analyzer-apiModeling.StdCLibraryFunctions,\n clang-analyzer-apiModeling.TrustNonnull,\n clang-analyzer-apiModeling.google.GTest,\n clang-analyzer-apiModeling.llvm.CastValue,\n clang-analyzer-apiModeling.llvm.ReturnValue,\n clang-analyzer-core.CallAndMessage,\n clang-analyzer-core.CallAndMessageModeling,\n clang-analyzer-core.DivideZero,\n clang-analyzer-core.DynamicTypePropagation,\n clang-analyzer-core.NonNullParamChecker,\n clang-analyzer-core.NonnilStringConstants,\n clang-analyzer-core.NullDereference,\n clang-analyzer-core.StackAddrEscapeBase,\n clang-analyzer-core.StackAddressEscape,\n clang-analyzer-core.UndefinedBinaryOperatorResult,\n clang-analyzer-core.VLASize,\n clang-analyzer-core.builtin.BuiltinFunctions,\n clang-analyzer-core.builtin.NoReturnFunctions,\n clang-analyzer-core.uninitialized.ArraySubscript,\n clang-analyzer-core.uninitialized.Assign,\n clang-analyzer-core.uninitialized.Branch,\n clang-analyzer-core.uninitialized.CapturedBlockVariable,\n clang-analyzer-core.uninitialized.UndefReturn,\n clang-analyzer-cplusplus.InnerPointer,\n clang-analyzer-cplusplus.Move,\n clang-analyzer-cplusplus.NewDelete,\n clang-analyzer-cplusplus.NewDeleteLeaks,\n clang-analyzer-cplusplus.PlacementNew,\n clang-analyzer-cplusplus.PureVirtualCall,\n clang-analyzer-cplusplus.SelfAssignment,\n clang-analyzer-cplusplus.SmartPtrModeling,\n clang-analyzer-cplusplus.StringChecker,\n clang-analyzer-cplusplus.VirtualCallModeling,\n clang-analyzer-deadcode.DeadStores,\n clang-analyzer-fuchsia.HandleChecker,\n clang-analyzer-nullability.NullPassedToNonnull,\n clang-analyzer-nullability.NullReturnedFromNonnull,\n clang-analyzer-nullability.NullabilityBase,\n clang-analyzer-nullability.NullableDereferenced,\n clang-analyzer-nullability.NullablePassedToNonnull,\n clang-analyzer-nullability.NullableReturnedFromNonnull,\n clang-analyzer-optin.cplusplus.UninitializedObject,\n clang-analyzer-optin.cplusplus.VirtualCall,\n clang-analyzer-optin.mpi.MPI-Checker,\n clang-analyzer-optin.osx.OSObjectCStyleCast,\n clang-analyzer-optin.osx.cocoa.localizability.EmptyLocalizationContextChecker,\n clang-analyzer-optin.osx.cocoa.localizability.NonLocalizedStringChecker,\n clang-analyzer-optin.performance.GCDAntipattern,\n clang-analyzer-optin.performance.Padding,\n clang-analyzer-optin.portability.UnixAPI,\n clang-analyzer-osx.API,\n clang-analyzer-osx.MIG,\n clang-analyzer-osx.NSOrCFErrorDerefChecker,\n clang-analyzer-osx.NumberObjectConversion,\n clang-analyzer-osx.OSObjectRetainCount,\n clang-analyzer-osx.ObjCProperty,\n clang-analyzer-osx.SecKeychainAPI,\n clang-analyzer-osx.cocoa.AtSync,\n clang-analyzer-osx.cocoa.AutoreleaseWrite,\n clang-analyzer-osx.cocoa.ClassRelease,\n clang-analyzer-osx.cocoa.Dealloc,\n clang-analyzer-osx.cocoa.IncompatibleMethodTypes,\n clang-analyzer-osx.cocoa.Loops,\n clang-analyzer-osx.cocoa.MissingSuperCall,\n clang-analyzer-osx.cocoa.NSAutoreleasePool,\n clang-analyzer-osx.cocoa.NSError,\n clang-analyzer-osx.cocoa.NilArg,\n clang-analyzer-osx.cocoa.NonNilReturnValue,\n clang-analyzer-osx.cocoa.ObjCGenerics,\n clang-analyzer-osx.cocoa.RetainCount,\n clang-analyzer-osx.cocoa.RetainCountBase,\n clang-analyzer-osx.cocoa.RunLoopAutoreleaseLeak,\n clang-analyzer-osx.cocoa.SelfInit,\n clang-analyzer-osx.cocoa.SuperDealloc,\n clang-analyzer-osx.cocoa.UnusedIvars,\n clang-analyzer-osx.cocoa.VariadicMethodTypes,\n clang-analyzer-osx.coreFoundation.CFError,\n clang-analyzer-osx.coreFoundation.CFNumber,\n clang-analyzer-osx.coreFoundation.CFRetainRelease,\n clang-analyzer-osx.coreFoundation.containers.OutOfBounds,\n clang-analyzer-osx.coreFoundation.containers.PointerSizedValues,\n clang-analyzer-security.FloatLoopCounter,\n clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling,\n clang-analyzer-security.insecureAPI.SecuritySyntaxChecker,\n clang-analyzer-security.insecureAPI.UncheckedReturn,\n clang-analyzer-security.insecureAPI.bcmp,\n clang-analyzer-security.insecureAPI.bcopy,\n clang-analyzer-security.insecureAPI.bzero,\n clang-analyzer-security.insecureAPI.decodeValueOfObjCType,\n clang-analyzer-security.insecureAPI.getpw,\n clang-analyzer-security.insecureAPI.gets,\n clang-analyzer-security.insecureAPI.mkstemp,\n clang-analyzer-security.insecureAPI.mktemp,\n clang-analyzer-security.insecureAPI.rand,\n clang-analyzer-security.insecureAPI.strcpy,\n clang-analyzer-security.insecureAPI.vfork,\n clang-analyzer-unix.API,\n clang-analyzer-unix.DynamicMemoryModeling,\n clang-analyzer-unix.Malloc,\n clang-analyzer-unix.MallocSizeof,\n clang-analyzer-unix.MismatchedDeallocator,\n clang-analyzer-unix.Vfork,\n clang-analyzer-unix.cstring.BadSizeArg,\n clang-analyzer-unix.cstring.CStringModeling,\n clang-analyzer-unix.cstring.NullArg,\n clang-analyzer-valist.CopyToSelf,\n clang-analyzer-valist.Uninitialized,\n clang-analyzer-valist.Unterminated,\n clang-analyzer-valist.ValistBase,\n clang-analyzer-webkit.NoUncountedMemberChecker,\n clang-analyzer-webkit.RefCntblBaseVirtualDtor,\n clang-analyzer-webkit.UncountedLambdaCapturesChecker,\n\n################################################ Optional checks ################################################\n\n #google-readability-todo,\n #bugprone-argument-comment,\n #bugprone-assert-side-effect,\n #bugprone-bad-signal-to-kill-thread,\n #bugprone-bool-pointer-implicit-conversion,\n #bugprone-branch-clone,\n #bugprone-copy-constructor-init,\n #bugprone-dangling-handle,\n #bugprone-dynamic-static-initializers,\n #bugprone-easily-swappable-parameters,\n #bugprone-exception-escape,\n #bugprone-fold-init-type,\n #bugprone-forward-declaration-namespace,\n #bugprone-forwarding-reference-overload,\n #bugprone-implicit-widening-of-multiplication-result,\n #bugprone-inaccurate-erase,\n #bugprone-incorrect-roundings,\n #bugprone-infinite-loop,\n #bugprone-integer-division,\n #bugprone-lambda-function-name,\n #bugprone-macro-parentheses,\n #bugprone-macro-repeated-side-effects,\n #bugprone-misplaced-operator-in-strlen-in-alloc,\n #bugprone-misplaced-pointer-arithmetic-in-alloc,\n #bugprone-misplaced-widening-cast,\n #bugprone-move-forwarding-reference,\n #bugprone-multiple-statement-macro,\n #bugprone-narrowing-conversions,\n #bugprone-no-escape,\n #bugprone-not-null-terminated-result,\n #bugprone-parent-virtual-call,\n #bugprone-posix-return,\n #bugprone-redundant-branch-condition,\n #bugprone-reserved-identifier,\n #bugprone-signal-handler,\n #bugprone-signed-char-misuse,\n #bugprone-sizeof-container,\n #bugprone-sizeof-expression,\n #bugprone-spuriously-wake-up-functions,\n #bugprone-string-constructor,\n #bugprone-string-integer-assignment,\n #bugprone-string-literal-with-embedded-nul,\n #bugprone-stringview-nullptr,\n #bugprone-suspicious-enum-usage,\n #bugprone-suspicious-include,\n #bugprone-suspicious-memory-comparison,\n #bugprone-suspicious-memset-usage,\n #bugprone-suspicious-missing-comma,\n #bugprone-suspicious-semicolon,\n #bugprone-suspicious-string-compare,\n #bugprone-swapped-arguments,\n #bugprone-terminating-continue,\n #bugprone-throw-keyword-missing,\n #bugprone-too-small-loop-variable,\n #bugprone-undefined-memory-manipulation,\n #bugprone-undelegated-constructor,\n #bugprone-unhandled-exception-at-new,\n #bugprone-unhandled-self-assignment,\n #bugprone-unused-raii,\n #bugprone-unused-return-value,\n #bugprone-use-after-move,\n #bugprone-virtual-near-miss,\n #cppcoreguidelines-avoid-c-arrays,\n #cppcoreguidelines-avoid-goto,\n #cppcoreguidelines-avoid-magic-numbers,\n #cppcoreguidelines-avoid-non-const-global-variables,\n #cppcoreguidelines-c-copy-assignment-signature,\n #cppcoreguidelines-explicit-virtual-functions,\n #cppcoreguidelines-init-variables,\n #cppcoreguidelines-interfaces-global-init,\n #cppcoreguidelines-macro-usage,\n #cppcoreguidelines-narrowing-conversions,\n #cppcoreguidelines-no-malloc,\n #cppcoreguidelines-non-private-member-variables-in-classes,\n #cppcoreguidelines-owning-memory,\n #cppcoreguidelines-prefer-member-initializer,\n #cppcoreguidelines-pro-bounds-array-to-pointer-decay,\n #cppcoreguidelines-pro-bounds-constant-array-index,\n #cppcoreguidelines-pro-bounds-pointer-arithmetic,\n #cppcoreguidelines-pro-type-const-cast,\n #cppcoreguidelines-pro-type-cstyle-cast,\n #cppcoreguidelines-pro-type-member-init,\n #cppcoreguidelines-pro-type-reinterpret-cast,\n #cppcoreguidelines-pro-type-static-cast-downcast,\n #cppcoreguidelines-pro-type-union-access,\n #cppcoreguidelines-pro-type-vararg,\n #cppcoreguidelines-slicing,\n #cppcoreguidelines-special-member-functions,\n #cppcoreguidelines-virtual-class-destructor,\n #hicpp-avoid-c-arrays,\n #hicpp-avoid-goto,\n #hicpp-braces-around-statements,\n #hicpp-deprecated-headers,\n #hicpp-exception-baseclass,\n #hicpp-explicit-conversions,\n #hicpp-function-size,\n #hicpp-invalid-access-moved,\n #hicpp-member-init,\n #hicpp-move-const-arg,\n #hicpp-multiway-paths-covered,\n #hicpp-named-parameter,\n #hicpp-new-delete-operators,\n #hicpp-no-array-decay,\n #hicpp-no-assembler,\n #hicpp-no-malloc,\n #hicpp-noexcept-move,\n #hicpp-signed-bitwise,\n #hicpp-special-member-functions,\n #hicpp-static-assert,\n #hicpp-undelegated-constructor,\n #hicpp-uppercase-literal-suffix,\n #hicpp-use-auto,\n #hicpp-use-emplace,\n #hicpp-use-equals-default,\n #hicpp-use-equals-delete,\n #hicpp-use-noexcept,\n #hicpp-use-nullptr,\n #hicpp-use-override,\n #hicpp-vararg,\n #modernize-avoid-bind,\n #modernize-avoid-c-arrays,\n #modernize-concat-nested-namespaces,\n #modernize-deprecated-headers,\n #modernize-deprecated-ios-base-aliases,\n #modernize-loop-convert,\n #modernize-make-shared,\n #modernize-make-unique,\n #modernize-pass-by-value,\n #modernize-raw-string-literal,\n #modernize-redundant-void-arg,\n #modernize-replace-auto-ptr,\n #modernize-replace-disallow-copy-and-assign-macro,\n #modernize-replace-random-shuffle,\n #modernize-return-braced-init-list,\n #modernize-shrink-to-fit,\n #modernize-unary-static-assert,\n #modernize-use-auto,\n #modernize-use-bool-literals,\n #modernize-use-default-member-init,\n #modernize-use-emplace,\n #modernize-use-equals-default,\n #modernize-use-equals-delete,\n #modernize-use-nodiscard,\n #modernize-use-noexcept,\n #modernize-use-nullptr,\n #modernize-use-override,\n #modernize-use-trailing-return-type,\n #modernize-use-transparent-functors,\n #modernize-use-uncaught-exceptions,\n #modernize-use-using,\n #performance-faster-string-find,\n #performance-for-range-copy,\n #performance-implicit-conversion-in-loop,\n #performance-inefficient-algorithm,\n #performance-inefficient-string-concatenation,\n #performance-inefficient-vector-operation,\n #performance-move-const-arg,\n #performance-move-constructor-init,\n #performance-no-automatic-move,\n #performance-no-int-to-ptr,\n #performance-noexcept-move-constructor,\n #performance-trivially-destructible,\n #performance-type-promotion-in-math-fn,\n #performance-unnecessary-copy-initialization,\n #performance-unnecessary-value-param,\n #portability-restrict-system-includes,\n #portability-simd-intrinsics,\n #readability-avoid-const-params-in-decls,\n #readability-braces-around-statements,\n #readability-const-return-type,\n #readability-container-contains,\n #readability-container-data-pointer,\n #readability-container-size-empty,\n #readability-convert-member-functions-to-static,\n #readability-delete-null-pointer,\n #readability-duplicate-include,\n #readability-else-after-return,\n #readability-function-cognitive-complexity,\n #readability-function-size,\n #readability-identifier-length,\n #readability-identifier-naming,\n #readability-implicit-bool-conversion,\n #readability-inconsistent-declaration-parameter-name,\n #readability-isolate-declaration,\n #readability-magic-numbers,\n #readability-make-member-function-const,\n #readability-misleading-indentation,\n #readability-misplaced-array-index,\n #readability-named-parameter,\n #readability-non-const-parameter,\n #readability-qualified-auto,\n #readability-redundant-access-specifiers,\n #readability-redundant-control-flow,\n #readability-redundant-declaration,\n #readability-redundant-function-ptr-dereference,\n #readability-redundant-member-init,\n #readability-redundant-preprocessor,\n #readability-redundant-smartptr-get,\n #readability-redundant-string-cstr,\n #readability-redundant-string-init,\n #readability-simplify-boolean-expr,\n #readability-simplify-subscript-expr,\n #readability-static-accessed-through-instance,\n #readability-static-definition-in-anonymous-namespace,\n #readability-string-compare,\n #readability-suspicious-call-argument,\n #readability-uniqueptr-delete-release,\n #readability-uppercase-literal-suffix,\n #readability-use-anyofallof\n \"\n" }, { "path": ".editorconfig", "content": "root = true\n# Don't set line endings to avoid conflict with core.autocrlf flag.\n# Line endings on checkout/checkin are controlled by .gitattributes file.\n[*]\nindent_style = space\nindent_size = 2\ninsert_final_newline = true\ntrim_trailing_whitespace = true\n" }, { "path": ".gitattributes", "content": "# Set the default behavior, in case people don't have core.autocrlf set.\n* text=auto\n" }, { "path": ".github/CODEOWNERS", "content": "# Default owner\n* @dbaileychess derekbailey@google.com\n\n# Prevent modification of this file\n.github/CODEOWNERS @dbaileychess derekbailey@google.com\n" }, { "path": ".github/ISSUE_TEMPLATE/404-doc.md", "content": "---\nname: 404 Doc\nabout: To fix broken documentation links\ntitle: \"[Doc 404]\"\nlabels: documentation\nassignees: dbaileychess\n\n---\n\nTarget URL:\n[Optional] Source Site:\n" }, { "path": ".github/ISSUE_TEMPLATE.md", "content": "Thank you for submitting an issue!\n\nPlease make sure you include the names of the affected language(s), compiler version(s), operating system version(s), and FlatBuffers version(s) in your issue title.\n\nThis helps us get the correct maintainers to look at your issue. Here are examples of good titles:\n\n- Crash when accessing FlatBuffer [C++, gcc 4.8, OS X, master]\n- Flatc converts a protobuf 'bytes' field to 'string' in fbs schema file [all languages, FlatBuffers 1.4]\n\nInclude other details as appropriate.\n\nThanks!\n" }, { "path": ".github/PULL_REQUEST_TEMPLATE.md", "content": "Thank you for submitting a PR!\n\nPlease delete this standard text once you've created your own description.\n\nIf you make changes to any of the code generators (`src/idl_gen*`) be sure to\n[build](https://google.github.io/flatbuffers/flatbuffers_guide_building.html) your project, as it will generate code based on the changes. If necessary\nthe code generation script can be directly run (`scripts/generate_code.py`),\nrequires Python3. This allows us to better see the effect of the PR.\n\nIf your PR includes C++ code, please adhere to the\n[Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html),\nand don't forget we try to support older compilers (e.g. VS2010, GCC 4.6.3),\nso only some C++11 support is available.\n\nFor any C++ changes, please make sure to run `sh scripts/clang-format-git.sh`\n\nInclude other details as appropriate.\n\nThanks!\n" }, { "path": ".github/dependabot.yml", "content": "version: 2\nupdates:\n - package-ecosystem: \"github-actions\"\n directory: \"/\"\n schedule:\n interval: \"weekly\"\n" }, { "path": ".github/labeler.yml", "content": "# Configuration for Auto Labeler during pull request\n#\n# See https://github.com/actions/labeler for file format\n# and https://github.com/google/flatbuffers/labels for a list of valid labels\n#\n# See .github/workflows/label.yml for Github Action workflow script\n\n\"c#\":\n - changed-files:\n - any-glob-to-any-file:\n - '**/*.cs'\n - 'net/**/*'\n - 'tests/FlatBuffers.Test/**/*'\n - 'tests/FlatBuffers.Benchmarks/**/*'\n - 'src/idl_gen_csharp.cpp'\n\nswift:\n - changed-files:\n - any-glob-to-any-file:\n - '**/*.swift'\n - 'swift/**/*'\n - 'tests/swift/**'\n - 'src/idl_gen_swift.cpp'\n\nnim:\n - changed-files:\n - any-glob-to-any-file:\n - '**/*.nim'\n - 'nim/**/*'\n - 'src/idl_gen_nim.cpp'\n - 'src/bfbs_gen_nim.cpp'\n\njavascript:\n - changed-files:\n - any-glob-to-any-file:\n - '**/*.js'\n - 'src/idl_gen_ts.cpp'\n\ntypescript:\n - changed-files:\n - any-glob-to-any-file:\n - '**/*.ts'\n - 'src/idl_gen_ts.cpp'\n - 'grpc/flatbuffers-js-grpc/**/*.ts'\n\ngolang:\n - changed-files:\n - any-glob-to-any-file:\n - '**/*.go'\n - 'src/idl_gen_go.cpp'\n\npython:\n - changed-files:\n - any-glob-to-any-file:\n - '**/*.py'\n - 'src/idl_gen_python.cpp'\n\njava:\n - changed-files:\n - any-glob-to-any-file:\n - '**/*.java'\n - 'src/idl_gen_java.cpp'\n\nkotlin:\n - changed-files:\n - any-glob-to-any-file:\n - '**/*.kt'\n - 'src/idl_gen_kotlin.cpp'\n - 'src/idl_gen_kotlin_kmp.cpp'\n\nlua:\n - changed-files:\n - any-glob-to-any-file:\n - '**/*.lua'\n - 'lua/**/*'\n - 'src/bfbs_gen_lua.cpp'\n\nlobster:\n - changed-files:\n - any-glob-to-any-file:\n - '**/*.lobster'\n - 'src/idl_gen_lobster.cpp'\n\nphp:\n - changed-files:\n - any-glob-to-any-file:\n - '**/*.php'\n - 'src/idl_gen_php.cpp'\n\nrust:\n - changed-files:\n - any-glob-to-any-file:\n - '**/*.rs'\n - 'rust/**/*'\n - 'src/idl_gen_rust.cpp'\n\ndart:\n - changed-files:\n - any-glob-to-any-file:\n - '**/*.dart'\n - 'src/idl_gen_dart.cpp'\n\n\"c++\":\n - changed-files:\n - any-glob-to-any-file:\n - '**/*.cc'\n - '**/*.cpp'\n - '**/*.h'\n\njson:\n - changed-files:\n - any-glob-to-any-file:\n - '**/*.json'\n - 'src/idl_gen_json_schema.cpp'\n\ncodegen:\n - changed-files:\n - any-glob-to-any-file:\n - 'src/**/*'\n\ndocumentation:\n - changed-files:\n - any-glob-to-any-file:\n - 'docs/**/*'\n - '**/*.md'\n\nCI:\n - changed-files:\n - any-glob-to-any-file:\n - '.github/**/*'\n - '.bazelci/**/*'\n\ngrpc:\n - changed-files:\n - any-glob-to-any-file:\n - 'grpc/**/*'\n - 'src/idl_gen_grpc.cpp'\n" }, { "path": ".github/workflows/build.yml", "content": "name: CI\npermissions: read-all\n\non:\n # For manual tests.\n workflow_dispatch:\n push:\n tags:\n - \"*\" # new tag version, like `0.8.4` or else\n branches:\n - master\n pull_request:\n branches:\n - master\n schedule:\n # Run daily at 4:45 A.M. to catch dependencies that break us.\n - cron: '45 4 * * *'\n\njobs:\n build-linux:\n permissions:\n contents: write\n outputs:\n digests-gcc: ${{ steps.hash-gcc.outputs.hashes }}\n digests-clang: ${{ steps.hash-clang.outputs.hashes }}\n name: Build Linux\n runs-on: ubuntu-24.04\n strategy:\n matrix:\n cxx: [g++-13, clang++-18]\n fail-fast: false\n steps:\n - uses: actions/checkout@v6\n - name: cmake\n run: CXX=${{ matrix.cxx }} cmake -G \"Unix Makefiles\" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_STRICT_MODE=ON -DFLATBUFFERS_STATIC_FLATC=ON .\n - name: build\n run: make -j\n - name: test\n run: ./flattests\n - name: make flatc executable\n run: |\n chmod +x flatc\n ./flatc --version\n - name: upload build artifacts\n uses: actions/upload-artifact@v7\n with:\n name: Linux flatc binary ${{ matrix.cxx }}\n path: flatc\n # Below if only for release.\n - name: Zip file\n if: startsWith(github.ref, 'refs/tags/')\n run: zip Linux.flatc.binary.${{ matrix.cxx }}.zip flatc\n - name: Release zip file\n uses: softprops/action-gh-release@v2\n if: startsWith(github.ref, 'refs/tags/')\n with:\n files: Linux.flatc.binary.${{ matrix.cxx }}.zip\n - name: Generate SLSA subjects - clang\n if: matrix.cxx == 'clang++-18' && startsWith(github.ref, 'refs/tags/')\n id: hash-clang\n run: echo \"hashes=$(sha256sum Linux.flatc.binary.${{ matrix.cxx }}.zip | base64 -w0)\" >> $GITHUB_OUTPUT\n - name: Generate SLSA subjects - gcc\n if: matrix.cxx == 'g++-13' && startsWith(github.ref, 'refs/tags/')\n id: hash-gcc\n run: echo \"hashes=$(sha256sum Linux.flatc.binary.${{ matrix.cxx }}.zip | base64 -w0)\" >> $GITHUB_OUTPUT\n\n build-linux-no-file-tests:\n name: Build Linux with -DFLATBUFFERS_NO_FILE_TESTS\n runs-on: ubuntu-24.04\n steps:\n - uses: actions/checkout@v6\n - name: cmake\n run: CXX=clang++-18 cmake -G \"Unix Makefiles\" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_STRICT_MODE=ON -DFLATBUFFERS_CXX_FLAGS=\"-DFLATBUFFERS_NO_FILE_TESTS\" .\n - name: build\n run: make -j\n - name: test\n run: ./flattests\n\n build-linux-out-of-source:\n name: Build Linux with out-of-source build location\n runs-on: ubuntu-24.04\n steps:\n - uses: actions/checkout@v6\n - name: make build directory\n run: mkdir build\n - name: cmake\n working-directory: build\n run: >\n CXX=clang++-18 cmake .. -G \"Unix Makefiles\" -DFLATBUFFERS_STRICT_MODE=ON\n -DFLATBUFFERS_BUILD_CPP17=ON -DFLATBUFFERS_CPP_STD=17\n - name: build\n working-directory: build\n run: make -j\n - name: test\n working-directory: build\n run: pwd && ./flattests\n - name: test C++17\n working-directory: build\n run: ./flattests_cpp17\n\n build-linux-cpp-std:\n name: Build Linux C++\n runs-on: ubuntu-24.04\n strategy:\n fail-fast: false\n matrix:\n std: [11, 14, 17, 20, 23]\n cxx: [g++-13, clang++-18]\n exclude:\n # Clang++15 10.3.0 stdlibc++ doesn't fully support std 23\n - cxx: clang++-18\n std: 23\n\n steps:\n - uses: actions/checkout@v6\n - name: cmake\n run: >\n CXX=${{ matrix.cxx }} cmake -G \"Unix Makefiles\"\n -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_STRICT_MODE=ON\n -DFLATBUFFERS_CPP_STD=${{ matrix.std }}\n -DFLATBUFFERS_BUILD_CPP17=${{ matrix.std >= 17 && 'On' || 'Off'}}\n - name: build\n run: make -j\n - name: test\n run: ./flattests\n - name: test C++17\n if: matrix.std >= 17\n run: ./flattests_cpp17\n\n build-cpp-std:\n name: Build Windows C++\n runs-on: windows-2022\n strategy:\n matrix:\n std: [11, 14, 17, 20, 23]\n fail-fast: false\n steps:\n - uses: actions/checkout@v6\n - name: Add msbuild to PATH\n uses: microsoft/setup-msbuild@v2\n - name: cmake\n run: >\n cmake -G \"Visual Studio 17 2022\" -A x64 -DCMAKE_BUILD_TYPE=Release\n -DFLATBUFFERS_STRICT_MODE=ON\n -DFLATBUFFERS_CPP_STD=${{ matrix.std }}\n -DFLATBUFFERS_BUILD_CPP17=${{ matrix.std >= 17 && 'On' || 'Off'}}\n - name: build\n run: msbuild.exe FlatBuffers.sln /p:Configuration=Release /p:Platform=x64\n - name: test\n run: Release\\flattests.exe\n - name: test C++17\n if: matrix.std >= 17\n run: Release\\flattests_cpp17.exe\n\n build-windows:\n permissions:\n contents: write\n outputs:\n digests: ${{ steps.hash.outputs.hashes }}\n name: Build Windows 2022\n runs-on: windows-2022\n steps:\n - uses: actions/checkout@v6\n - name: Add msbuild to PATH\n uses: microsoft/setup-msbuild@v2\n - name: cmake\n run: cmake -G \"Visual Studio 17 2022\" -A x64 -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_CPP17=ON -DFLATBUFFERS_STRICT_MODE=ON .\n - name: build\n run: msbuild.exe FlatBuffers.sln /p:Configuration=Release /p:Platform=x64\n - name: test\n run: Release\\flattests.exe\n - name: upload build artifacts\n uses: actions/upload-artifact@v7\n with:\n name: Windows flatc binary\n path: Release\\flatc.exe\n # Below if only for release.\n - name: Zip file\n if: startsWith(github.ref, 'refs/tags/')\n run: move Release/flatc.exe . && Compress-Archive flatc.exe Windows.flatc.binary.zip\n - name: Release binary\n uses: softprops/action-gh-release@v2\n if: startsWith(github.ref, 'refs/tags/')\n with:\n files: Windows.flatc.binary.zip\n - name: Generate SLSA subjects\n if: startsWith(github.ref, 'refs/tags/')\n id: hash\n shell: bash\n run: echo \"hashes=$(sha256sum Windows.flatc.binary.zip | base64 -w0)\" >> $GITHUB_OUTPUT\n\n build-dotnet-windows:\n name: Build .NET Windows\n runs-on: windows-2022\n strategy:\n matrix:\n configuration: [\n '',\n '-p:UnsafeByteBuffer=true',\n '-p:EnableSpanT=true,UnsafeByteBuffer=true'\n ]\n steps:\n - uses: actions/checkout@v6\n - name: Setup .NET Core SDK\n uses: actions/setup-dotnet@v5\n with:\n dotnet-version: '8.0.x'\n - name: Build\n run: |\n cd tests\\FlatBuffers.Test\n dotnet new sln --force --name FlatBuffers.Test --format sln\n dotnet sln FlatBuffers.Test.sln add FlatBuffers.Test.csproj\n dotnet build -c Release ${{matrix.configuration}} FlatBuffers.Test.sln\n - name: Run net6.0\n run: |\n cd tests\\FlatBuffers.Test\\bin\\Release\\net6.0\n dir\n .\\FlatBuffers.Test.exe\n - name: Run net8.0\n run: |\n cd tests\\FlatBuffers.Test\\bin\\Release\\net8.0\n .\\FlatBuffers.Test.exe\n\n build-mac-intel:\n permissions:\n contents: write\n outputs:\n digests: ${{ steps.hash.outputs.hashes }}\n name: Build Mac (for Intel)\n runs-on: macos-15-intel\n steps:\n - uses: actions/checkout@v6\n - name: cmake\n run: cmake -G \"Xcode\" -DCMAKE_OSX_ARCHITECTURES=\"x86_64\" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_STRICT_MODE=ON .\n - name: build\n run: xcodebuild -toolchain clang -configuration Release -target flattests\n - name: check that the binary is x86_64\n run: |\n info=$(file Release/flatc)\n echo $info\n echo $info | grep \"Mach-O 64-bit executable x86_64\"\n - name: test\n run: Release/flattests\n - name: make flatc executable\n run: |\n chmod +x Release/flatc\n Release/flatc --version\n - name: upload build artifacts\n uses: actions/upload-artifact@v7\n with:\n name: Mac flatc binary Intel\n path: Release/flatc\n # Below if only for release.\n - name: Zip file\n if: startsWith(github.ref, 'refs/tags/')\n run: mv Release/flatc . && zip MacIntel.flatc.binary.zip flatc\n - name: Release binary\n uses: softprops/action-gh-release@v2\n if: startsWith(github.ref, 'refs/tags/')\n with:\n files: MacIntel.flatc.binary.zip\n - name: Generate SLSA subjects\n if: startsWith(github.ref, 'refs/tags/')\n id: hash\n run: echo \"hashes=$(shasum -a 256 MacIntel.flatc.binary.zip | base64)\" >> $GITHUB_OUTPUT\n\n build-mac-universal:\n permissions:\n contents: write\n outputs:\n digests: ${{ steps.hash.outputs.hashes }}\n name: Build Mac (universal build)\n runs-on: macos-latest\n steps:\n - uses: actions/checkout@v6\n - name: cmake\n run: cmake -G \"Xcode\" -DCMAKE_OSX_ARCHITECTURES=\"arm64;x86_64\" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_STRICT_MODE=ON .\n - name: build\n run: xcodebuild -toolchain clang -configuration Release -target flattests\n - name: check that the binary is \"universal\"\n run: |\n info=$(file Release/flatc)\n echo $info\n echo $info | grep \"Mach-O universal binary with 2 architectures\"\n - name: test\n run: Release/flattests\n - name: make flatc executable\n run: |\n chmod +x Release/flatc\n Release/flatc --version\n - name: upload build artifacts\n uses: actions/upload-artifact@v7\n with:\n name: Mac flatc binary Universal\n path: Release/flatc\n # Below if only for release.\n - name: Zip file\n if: startsWith(github.ref, 'refs/tags/')\n run: mv Release/flatc . && zip Mac.flatc.binary.zip flatc\n - name: Release binary\n uses: softprops/action-gh-release@v2\n if: startsWith(github.ref, 'refs/tags/')\n with:\n files: Mac.flatc.binary.zip\n - name: Generate SLSA subjects\n if: startsWith(github.ref, 'refs/tags/')\n id: hash\n run: echo \"hashes=$(shasum -a 256 Mac.flatc.binary.zip | base64)\" >> $GITHUB_OUTPUT\n\n build-android:\n name: Build Android (on Linux)\n if: false #disabled due to continual failure\n runs-on: ubuntu-24.04\n steps:\n - uses: actions/checkout@v6\n - name: set up Java\n uses: actions/setup-java@v5\n with:\n distribution: temurin\n java-version: 17\n - name: set up Gradle\n uses: gradle/actions/setup-gradle@v5\n - name: set up flatc\n run: |\n cmake -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF -DFLATBUFFERS_STRICT_MODE=ON .\n make -j\n echo \"${PWD}\" >> $GITHUB_PATH\n - name: build\n working-directory: android\n run: gradle clean build\n\n build-generator:\n name: Check Generated Code\n runs-on: ubuntu-24.04\n strategy:\n matrix:\n cxx: [g++-13, clang++-18]\n steps:\n - uses: actions/checkout@v6\n - name: cmake\n run: CXX=${{ matrix.cxx }} cmake -G \"Unix Makefiles\" -DFLATBUFFERS_BUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_STRICT_MODE=ON . && make -j\n - name: Generate\n run: scripts/check_generate_code.py\n - name: Generate gRPC\n run: scripts/check-grpc-generated-code.py\n\n build-generator-windows:\n name: Check Generated Code on Windows\n runs-on: windows-2022\n steps:\n - uses: actions/checkout@v6\n - name: Add msbuild to PATH\n uses: microsoft/setup-msbuild@v2\n - name: cmake\n run: cmake -G \"Visual Studio 17 2022\" -A x64 -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_CPP17=ON -DFLATBUFFERS_STRICT_MODE=ON .\n - name: build\n run: msbuild.exe FlatBuffers.sln /p:Configuration=Release /p:Platform=x64\n - name: Generate\n run: python3 scripts/check_generate_code.py --flatc Release\\flatc.exe\n - name: Generate gRPC\n run: python3 scripts/check-grpc-generated-code.py --flatc Release\\flatc.exe\n\n build-benchmarks:\n name: Build Benchmarks (on Linux)\n runs-on: ubuntu-24.04\n strategy:\n matrix:\n cxx: [g++-13]\n steps:\n - uses: actions/checkout@v6\n - name: cmake\n run: CXX=${{ matrix.cxx }} cmake -G \"Unix Makefiles\" -DFLATBUFFERS_CXX_FLAGS=\"-Wno-unused-parameter -fno-aligned-new\" -DFLATBUFFERS_BUILD_BENCHMARKS=ON -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_STRICT_MODE=ON . && make -j\n - name: Run benchmarks\n run: ./flatbenchmark --benchmark_repetitions=5 --benchmark_display_aggregates_only=true --benchmark_out_format=console --benchmark_out=benchmarks/results_${{matrix.cxx}}\n - name: Upload benchmarks results\n uses: actions/upload-artifact@v7\n with:\n name: Linux flatbenchmark results ${{matrix.cxx}}\n path: benchmarks/results_${{matrix.cxx}}\n\n build-java:\n name: Build Java\n runs-on: ubuntu-24.04\n steps:\n - uses: actions/checkout@v6\n - name: test\n working-directory: java\n run: mvn test\n\n build-kotlin-macos:\n name: Build Kotlin MacOS\n runs-on: macos-15\n steps:\n - name: Checkout\n uses: actions/checkout@v6\n - name: set up Java\n uses: actions/setup-java@v5\n with:\n distribution: temurin\n java-version: 17\n - name: set up Gradle\n uses: gradle/actions/setup-gradle@v5\n - name: Build flatc\n run: |\n cmake -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF .\n make -j\n echo \"${PWD}\" >> $GITHUB_PATH\n - name: Build\n working-directory: kotlin\n run: ./gradlew clean iosSimulatorArm64Test macosX64Test macosArm64Test\n\n build-kotlin-linux:\n name: Build Kotlin Linux\n if: false #disabled due to continual failure\n runs-on: ubuntu-24.04\n steps:\n - name: Checkout\n uses: actions/checkout@v6\n - name: set up Java\n uses: actions/setup-java@v5\n with:\n distribution: temurin\n java-version: 17\n - name: set up Gradle\n uses: gradle/actions/setup-gradle@v5\n - name: Build flatc\n run: |\n cmake -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF .\n make -j\n echo \"${PWD}\" >> $GITHUB_PATH\n - name: Build\n working-directory: kotlin\n # we are using docker's version of gradle\n # so no need for wrapper validation or user\n # gradlew\n run: gradle jvmMainClasses jvmTest jsTest jsBrowserTest\n\n build-rust-linux:\n name: Build Rust Linux\n runs-on: ubuntu-24.04\n steps:\n - uses: actions/checkout@v6\n - name: test\n working-directory: tests\n run: bash RustTest.sh\n\n build-rust-windows:\n name: Build Rust Windows\n runs-on: windows-2022\n steps:\n - uses: actions/checkout@v6\n - name: test\n working-directory: tests\n run: ./RustTest.bat\n\n build-python:\n name: Build Python\n runs-on: ubuntu-24.04\n steps:\n - uses: actions/checkout@v6\n - name: flatc\n # FIXME: make test script not rely on flatc\n run: cmake -G \"Unix Makefiles\" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_INSTALL=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF -DFLATBUFFERS_STRICT_MODE=ON . && make -j\n - name: test\n working-directory: tests\n run: bash PythonTest.sh\n\n build-go:\n name: Build Go\n runs-on: ubuntu-24.04\n steps:\n - uses: actions/checkout@v6\n - name: flatc\n # FIXME: make test script not rely on flatc\n run: cmake -G \"Unix Makefiles\" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_INSTALL=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF -DFLATBUFFERS_STRICT_MODE=ON . && make -j\n - name: test\n working-directory: tests\n run: bash GoTest.sh\n\n build-php:\n name: Build PHP\n runs-on: ubuntu-24.04\n steps:\n - uses: actions/checkout@v6\n - name: flatc\n # FIXME: make test script not rely on flatc\n run: cmake -G \"Unix Makefiles\" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_INSTALL=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF -DFLATBUFFERS_STRICT_MODE=ON . && make -j\n - name: test\n working-directory: tests\n run: |\n php phpTest.php\n sh phpUnionVectorTest.sh\n\n build-swift:\n name: Test Swift Linux\n strategy:\n matrix:\n swift: [\"5.10\", \"6.1\", \"6.2\"]\n runs-on: ubuntu-24.04\n steps:\n - uses: actions/checkout@v6\n - uses: swift-actions/setup-swift@v2\n with:\n swift-version: ${{ matrix.swift }}\n - name: Get swift version\n run: swift --version\n - name: test\n run: swift test\n\n build-swift-windows:\n name: Test swift windows\n runs-on: windows-latest\n steps:\n - uses: actions/checkout@v6\n - uses: SwiftyLab/setup-swift@latest\n with:\n swift-version: '6.1'\n - run: swift build\n - run: swift test\n\n build-swift-wasm:\n name: Test Swift Wasm\n runs-on: ubuntu-24.04\n steps:\n - uses: actions/checkout@v6\n - uses: swift-actions/setup-swift@v2\n with:\n swift-version: 6.2.1\n - uses: bytecodealliance/actions/wasmtime/setup@v1\n - name: Install Swift SDK\n run: swift sdk install https://download.swift.org/swift-6.2.1-release/wasm-sdk/swift-6.2.1-RELEASE/swift-6.2.1-RELEASE_wasm.artifactbundle.tar.gz --checksum 482b9f95462b87bedfafca94a092cf9ec4496671ca13b43745097122d20f18af\n - name: Test\n working-directory: tests/swift/Wasm.tests\n run: |\n swift sdk list\n swift build --build-tests --swift-sdk swift-6.2.1-RELEASE_wasm\n wasmtime --dir . .build/wasm32-unknown-wasip1/debug/FlatBuffers.Test.Swift.WasmPackageTests.xctest\n\n build-ts:\n name: Build TS\n runs-on: ubuntu-24.04\n steps:\n - uses: actions/checkout@v6\n - name: flatc\n # FIXME: make test script not rely on flatc\n 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 -j\n - name: pnpm\n run: npm install -g pnpm esbuild\n - name: deps\n run: pnpm i\n - name: compile\n run: pnpm compile\n - name: test\n working-directory: tests/ts\n run: |\n python3 TypeScriptTest.py\n\n build-dart:\n name: Build Dart\n runs-on: ubuntu-24.04\n steps:\n - uses: actions/checkout@v6\n - uses: dart-lang/setup-dart@v1\n with:\n sdk: stable\n - name: flatc\n # FIXME: make test script not rely on flatc\n run: cmake -G \"Unix Makefiles\" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_INSTALL=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF -DFLATBUFFERS_STRICT_MODE=ON . && make -j\n - name: test\n working-directory: tests\n run: bash DartTest.sh\n\n build-nim:\n name: Build Nim\n runs-on: ubuntu-24.04\n steps:\n - uses: actions/checkout@v6\n - name: flatc\n # FIXME: make test script not rely on flatc\n 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 -j\n - uses: jiro4989/setup-nim-action@v2\n - name: install library\n working-directory: nim\n run: nimble -y develop && nimble install\n - name: test\n working-directory: tests/nim\n run: python3 testnim.py\n\n bazel:\n name: Bazel\n runs-on: ubuntu-24.04\n steps:\n - uses: actions/checkout@v6\n # Explicitly use 8.5.1 until we can update or https://github.com/actions/runner-images/issues/13564 is fixed.\n - name: Set env\n run: >\n echo \"USE_BAZEL_VERSION=8.5.1\" >> $GITHUB_ENV\n - name: bazel build\n run: >\n bazel build\n //:flatc\n //:flatbuffers\n //tests:flatbuffers_test\n - name: bazel test\n run: >\n bazel test\n //tests:flatbuffers_test\n\n release-digests:\n if: startsWith(github.ref, 'refs/tags/')\n needs: [build-linux, build-windows, build-mac-intel, build-mac-universal]\n outputs:\n digests: ${{ steps.hash.outputs.digests }}\n runs-on: ubuntu-24.04\n steps:\n - name: Merge results\n id: hash\n env:\n LINUXGCC_DIGESTS: \"${{ needs.build-linux.outputs.digests-gcc }}\"\n LINUXCLANG_DIGESTS: \"${{ needs.build-linux.outputs.digests-clang }}\"\n MAC_DIGESTS: \"${{ needs.build-mac-universal.outputs.digests }}\"\n MACINTEL_DIGESTS: \"${{ needs.build-mac-intel.outputs.digests }}\"\n WINDOWS_DIGESTS: \"${{ needs.build-windows.outputs.digests }}\"\n run: |\n set -euo pipefail\n echo \"$LINUXGCC_DIGESTS\" | base64 -d > checksums.txt\n echo \"$LINUXCLANG_DIGESTS\" | base64 -d >> checksums.txt\n echo \"$MAC_DIGESTS\" | base64 -d >> checksums.txt\n echo \"$MACINTEL_DIGESTS\" | base64 -d >> checksums.txt\n echo \"$WINDOWS_DIGESTS\" | base64 -d >> checksums.txt\n echo \"digests=$(cat checksums.txt | base64 -w0)\" >> $GITHUB_OUTPUT\n\n provenance:\n if: startsWith(github.ref, 'refs/tags/')\n needs: [release-digests]\n permissions:\n actions: read # To read the workflow path.\n id-token: write # To sign the provenance.\n contents: write # To add assets to a release.\n uses: slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@v2.1.0\n with:\n base64-subjects: \"${{ needs.release-digests.outputs.digests }}\"\n upload-assets: true # Optional: Upload to a new release\n" }, { "path": ".github/workflows/docs.yml", "content": "name: docs\non:\n # For manual pushes.\n workflow_dispatch: \n\n # Pushes to main that touch the documentation directory.\n push:\n branches:\n - master\n paths:\n - 'docs/**'\n\npermissions:\n contents: write\njobs:\n deploy:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v6\n - name: Configure Git Credentials\n run: |\n git config user.name github-actions[bot]\n git config user.email 41898282+github-actions[bot]@users.noreply.github.com\n - uses: actions/setup-python@v6\n with:\n python-version: 3.x\n - run: echo \"cache_id=$(date --utc '+%V')\" >> $GITHUB_ENV \n - uses: actions/cache@v5\n with:\n key: mkdocs-material-${{ env.cache_id }}\n path: .cache\n restore-keys: |\n mkdocs-material-\n - run: pip install mkdocs-material \n - run: pip install mkdocs-redirects\n - run: mkdocs gh-deploy --force -f docs/mkdocs.yml\n" }, { "path": ".github/workflows/label.yml", "content": "# This workflow will triage pull requests and apply a label based on the\n# paths that are modified in the pull request.\n#\n# To use this workflow, you will need to set up a .github/labeler.yml\n# file with configuration. For more information, see:\n# https://github.com/actions/labeler\n\nname: Labeler\npermissions: read-all\n\non: [pull_request_target]\n\njobs:\n label:\n permissions:\n contents: read\n pull-requests: write\n \n runs-on: ubuntu-latest\n\n steps:\n - uses: actions/labeler@v6\n with:\n repo-token: \"${{ secrets.GITHUB_TOKEN }}\"\n" }, { "path": ".github/workflows/main.yml", "content": "name: OSS-Fuzz\npermissions: read-all\n\non:\n pull_request:\n branches:\n - master\n paths:\n - include/**\n - src/**\n - tests/**.cpp\n - tests/**.h\njobs:\n Fuzzing:\n runs-on: ubuntu-latest\n steps:\n - name: Build Fuzzers\n id: build\n uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master\n with:\n oss-fuzz-project-name: 'flatbuffers'\n language: c++\n - name: Run Fuzzers\n uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master\n with:\n oss-fuzz-project-name: 'flatbuffers'\n language: c++\n fuzz-seconds: 60\n - name: Upload Crash\n uses: actions/upload-artifact@v7\n if: failure() && steps.build.outcome == 'success'\n with:\n name: artifacts\n path: ./out/artifacts\n" }, { "path": ".github/workflows/release.yml", "content": "name: Release\npermissions: read-all\n\non:\n # For manual tests.\n workflow_dispatch:\n release:\n types: [published]\n\njobs:\n publish-npm:\n name: Publish NPM\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v6\n - uses: actions/setup-node@v6\n with:\n node-version: '20.x'\n registry-url: 'https://registry.npmjs.org'\n\n - run: npm publish\n env:\n NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}\n\n publish-pypi:\n name: Publish PyPi\n runs-on: ubuntu-latest\n defaults:\n run:\n working-directory: ./python\n steps:\n - uses: actions/checkout@v6\n - uses: actions/setup-python@v6\n with:\n python-version: '3.10'\n\n - name: Install Dependencies\n run: |\n python3 -m pip install --upgrade pip\n python3 -m pip install build twine\n\n - name: Build\n run: |\n python3 -m build .\n\n - name: Upload to PyPi\n run: |\n python3 -m twine upload dist/*\n env:\n TWINE_USERNAME: __token__\n TWINE_PASSWORD: ${{ secrets.TWINE_TOKEN }}\n\n publish-nuget:\n name: Publish NuGet\n runs-on: windows-latest\n defaults:\n run:\n working-directory: ./net/flatbuffers\n steps:\n - uses: actions/checkout@v6\n - uses: actions/setup-dotnet@v5\n with:\n dotnet-version: '8.0.x'\n - name: Build\n run: |\n dotnet build Google.FlatBuffers.csproj -c Release\n\n - name: Pack\n run: |\n dotnet pack Google.FlatBuffers.csproj -c Release\n\n - name: Upload to NuGet\n run: |\n dotnet nuget push .\\bin\\Release\\Google.FlatBuffers.*.nupkg -k ${{ secrets.NUGET_API_KEY }} -s https://api.nuget.org/v3/index.json\n\n publish-maven:\n name: Publish Maven\n runs-on: ubuntu-latest\n defaults:\n run:\n working-directory: ./java\n steps:\n - uses: actions/checkout@v6\n\n - name: Set up Maven Central Repository\n uses: actions/setup-java@v5\n with:\n java-version: '11'\n distribution: 'adopt'\n cache: 'maven'\n server-id: ossrh\n server-username: OSSRH_USERNAME\n server-password: OSSRH_PASSWORD\n gpg-private-key: ${{ secrets.MAVEN_GPG_PRIVATE_KEY }}\n gpg-passphrase: MAVEN_GPG_PASSPHRASE # this needs to be an env var\n\n - name: Publish Maven\n run: mvn --batch-mode clean deploy\n env:\n OSSRH_USERNAME: ${{ secrets.OSSRH_USER_V2 }}\n OSSRH_PASSWORD: ${{ secrets.OSSRH_TOKEN_V2 }}\n MAVEN_GPG_PASSPHRASE: ${{ secrets.MAVEN_GPG_PASSPHRASE }}\n \n publish-maven-kotlin:\n name: Publish Maven - Kotlin\n runs-on: ubuntu-latest\n defaults:\n run:\n working-directory: ./kotlin\n steps:\n - uses: actions/checkout@v6\n - name: Set up Maven Central Repository\n uses: actions/setup-java@v5\n with:\n java-version: '11'\n distribution: 'adopt'\n cache: 'maven'\n server-id: ossrh\n server-username: OSSRH_USERNAME\n server-password: OSSRH_PASSWORD\n gpg-private-key: ${{ secrets.MAVEN_GPG_PRIVATE_KEY }}\n gpg-passphrase: MAVEN_GPG_PASSPHRASE # this needs to be an env var\n\n - name: Publish Kotlin Library on Maven\n run: ./gradlew publishAllPublicationsToSonatypeRepository\n env:\n OSSRH_USERNAME: ${{ secrets.OSSRH_USER_V2 }}\n OSSRH_PASSWORD: ${{ secrets.OSSRH_TOKEN_V2 }}\n MAVEN_GPG_PASSPHRASE: ${{ secrets.MAVEN_GPG_PASSPHRASE }}\n\n\n publish-crates:\n name: Publish crates.io\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v6\n - uses: actions-rs/toolchain@v1\n with:\n toolchain: stable\n override: true\n \n - name: Publish Flatbuffers\n uses: katyo/publish-crates@v2\n with:\n path: ./rust/flatbuffers\n registry-token: ${{ secrets.CARGO_TOKEN }}\n\n - name: Publish Flexbuffers\n uses: katyo/publish-crates@v2\n with:\n path: ./rust/flexbuffers\n registry-token: ${{ secrets.CARGO_TOKEN }}\n" }, { "path": ".github/workflows/stale.yml", "content": "name: Mark stale issues and pull requests\npermissions:\n issues: write\n pull-requests: write\n\non:\n # For manual tests.\n workflow_dispatch:\n schedule:\n - cron: \"30 20 * * *\"\n\njobs:\n stale:\n\n runs-on: ubuntu-latest\n\n steps:\n - uses: actions/stale@v10\n with:\n repo-token: ${{ secrets.GITHUB_TOKEN }}\n operations-per-run: 500\n exempt-all-milestones: true\n remove-stale-when-updated: true\n \n stale-issue-message: 'This issue is stale because it has been open 6 months with no activity. Please comment or label `not-stale`, or this will be closed in 14 days.'\n close-issue-message: 'This issue was automatically closed due to no activity for 6 months plus the 14 day notice period.'\n days-before-issue-stale: 182 # 6 months\n days-before-issue-close: 14 # 2 weeks\n exempt-issue-labels: not-stale\n \n stale-pr-message: 'This pull request is stale because it has been open 6 months with no activity. Please comment or label `not-stale`, or this will be closed in 14 days.'\n close-pr-message: 'This pull request was automatically closed due to no activity for 6 months plus the 14 day notice period.'\n days-before-pr-stale: 182 # 6 months\n days-before-pr-close: 14 # 2 week\n exempt-pr-labels: not-stale\n exempt-draft-pr: false\n\n" }, { "path": ".gitignore", "content": "*_wire.txt\n*_wire.bin\n.DS_Store\n**/.build\nbuild\n**/Packages\n/*.xcodeproj\n**/xcuserdata/\n**/xcshareddata/\n**/.swiftpm/\n*.o\n*.o.d\n*.class\n*.a\n*.swp\n*~\n*.vcxproj\n*.vcxproj.filters\n*.vcxproj.user\n*.sln\n*.suo\n*.opendb\n*.keystore\n**/.vs/**\n**/bin/**\n!tests/rust_usage_test/bin/**\n**/gen/**\n**/libs/**\n**/obj/**\n**/*.dir/**\n**/CMakeFiles/**\n**/cmake_install.cmake\n**/install_manifest.txt\n**/CMakeCache.txt\n**/CMakeTestfile.cmake\n**/CPackConfig.cmake\n**/CPackSourceConfig.cmake\n**/compile_commands.json\n**/Debug/**\n**/Release/**\n**/RelWithDebInfo/**\n**/x64/ #build artifacts from VS\nbuild.xml\nlocal.properties\nproject.properties\nproguard-project.txt\nlinklint_results\nMakefile\nflatbenchmark\nflatbenchmark.exe\nflatc\nflatc.exe\nflathash\nflathash.exe\nflattests\nflattests.exe\nflattests_cpp17\nflattests_cpp17.exe\nflatsamplebinary\nflatsamplebinary.exe\nflatsampletext\nflatsampletext.exe\nflatsamplebfbs\nflatsamplebfbs.exe\ngrpctest\ngrpctest.exe\nsnapshot.sh\ntags\ntests/dart_gen\ntests/go_gen\ntests/monsterdata_java_wire.mon\ntests/monsterdata_java_wire_sp.mon\ntests/monsterdata_go_wire.mon\ntests/monsterdata_javascript_wire.mon\ntests/monsterdata_lobster_wire.mon\ntests/monsterdata_rust_wire.mon\ntests/php/\nCMakeLists.txt.user\nCMakeScripts/**\nCTestTestfile.cmake\nflatbuffers-config-version.cmake\nFlatBuffers.cbp\nbuild/Xcode/FlatBuffers.xcodeproj/project.xcworkspace/**\nbuild/Xcode/FlatBuffers.xcodeproj/xcuserdata/**\nFlatBuffers.xcodeproj/\njava/.idea\njava/*.iml\n.idea\n*.iml\ntarget\njava/target\n**/*.pyc\nbuild/VS2010/FlatBuffers.sdf\nbuild/VS2010/FlatBuffers.opensdf\nbuild/VS2010/ipch/**/*.ipch\n*.so\nTesting/Temporary\n.cproject\n.settings/\n.project\nnet/**/obj\nnode_modules/\nandroid/.externalNativeBuild/\nandroid/.gradle/\nandroid/build/\nsamples/android/.externalNativeBuild/\nsamples/android/.gradle/\nsamples/android/build/\njs/**/*.js\njs/**/*.d.ts\nmjs/**/*.js\nmjs/**/*.d.ts\n/bazel-bin\n/bazel-flatbuffers\n/bazel-genfiles\n/bazel-out\n/bazel-testlogs\n.ninja_deps\n.ninja_log\nbuild.ninja\nrules.ninja\n.vscode\ndart/.pub/\ndart/.packages\ndart/pubspec.lock\ndart/.dart_tool/\ndart/build/\ndart/doc/api/\nCargo.lock\n.corpus**\n.seed**\n.crash**\ngrpc/google/\n**/Package.resolved\n.clangd/**\npackage-lock.json\n/*.ilk\n/*.pdb\n.clwb\nyarn-error.log\n.cache/\n/flatbuffers.lib\n.cmake/\n**/dist\n**/vendor\n**/go.sum\nflatbuffers.pc\n**/FlatBuffers.Test.Swift.xcodeproj\n**/html/**\n**/latex/**\n# https://cmake.org/cmake/help/latest/module/FetchContent.html#variable:FETCHCONTENT_BASE_DIR\ncmake-build-debug/\n_deps/\n**/.gradle/**\nkotlin/**/generated\nMODULE.bazel.lock\n\n# Ignore the generated docs\ndocs/site\n\n# Ignore generated files\n*.fbs.h\n" }, { "path": ".npmrc", "content": "hoist=false\n" }, { "path": "BUILD.bazel", "content": "load(\"@rules_cc//cc:defs.bzl\", \"cc_binary\", \"cc_library\")\n\nlicenses([\"notice\"])\n\npackage(\n default_visibility = [\"//visibility:public\"],\n)\n\nexports_files([\n \"LICENSE\",\n \"tsconfig.json\",\n])\n\nconfig_setting(\n name = \"platform_freebsd\",\n constraint_values = [\n \"@platforms//os:freebsd\",\n ],\n)\n\nconfig_setting(\n name = \"platform_openbsd\",\n constraint_values = [\n \"@platforms//os:openbsd\",\n ],\n)\n\nfilegroup(\n name = \"distribution\",\n srcs = [\n \".bazelignore\",\n \".npmrc\",\n \"BUILD.bazel\",\n \"MODULE.bazel\",\n \"build_defs.bzl\",\n \"package.json\",\n \"pnpm-lock.yaml\",\n \"typescript.bzl\",\n \"//grpc/src/compiler:distribution\",\n \"//include/codegen:distribution\",\n \"//reflection:distribution\",\n \"//src:distribution\",\n \"//ts:distribution\",\n ] + glob([\n \"include/flatbuffers/*.h\",\n ]),\n visibility = [\"//visibility:public\"],\n)\n\n# Public flatc library to compile flatbuffer files at runtime.\ncc_library(\n name = \"flatbuffers\",\n hdrs = [\"//:public_headers\"],\n linkstatic = 1,\n strip_include_prefix = \"/include\",\n deps = [\"//src:flatbuffers\"],\n)\n\n# Public C++ headers for the Flatbuffers library.\nfilegroup(\n name = \"public_headers\",\n srcs = [\n \"include/flatbuffers/allocator.h\",\n \"include/flatbuffers/array.h\",\n \"include/flatbuffers/base.h\",\n \"include/flatbuffers/buffer.h\",\n \"include/flatbuffers/buffer_ref.h\",\n \"include/flatbuffers/code_generator.h\",\n \"include/flatbuffers/code_generators.h\",\n \"include/flatbuffers/default_allocator.h\",\n \"include/flatbuffers/detached_buffer.h\",\n \"include/flatbuffers/file_manager.h\",\n \"include/flatbuffers/flatbuffer_builder.h\",\n \"include/flatbuffers/flatbuffers.h\",\n \"include/flatbuffers/flex_flat_util.h\",\n \"include/flatbuffers/flexbuffers.h\",\n \"include/flatbuffers/grpc.h\",\n \"include/flatbuffers/hash.h\",\n \"include/flatbuffers/idl.h\",\n \"include/flatbuffers/minireflect.h\",\n \"include/flatbuffers/reflection.h\",\n \"include/flatbuffers/reflection_generated.h\",\n \"include/flatbuffers/registry.h\",\n \"include/flatbuffers/stl_emulation.h\",\n \"include/flatbuffers/string.h\",\n \"include/flatbuffers/struct.h\",\n \"include/flatbuffers/table.h\",\n \"include/flatbuffers/util.h\",\n \"include/flatbuffers/vector.h\",\n \"include/flatbuffers/vector_downward.h\",\n \"include/flatbuffers/verifier.h\",\n ],\n)\n\n# Public flatc compiler library.\ncc_library(\n name = \"flatc_library\",\n linkstatic = 1,\n deps = [\n \"//src:flatc_library\",\n ],\n)\n\n# Public flatc compiler.\ncc_binary(\n name = \"flatc\",\n data = [\"//reflection:reflection_fbs_schema\"],\n deps = [\n \"//src:flatc\",\n ],\n)\n\nfilegroup(\n name = \"flatc_headers\",\n srcs = [\n \"include/flatbuffers/flatc.h\",\n ],\n visibility = [\"//:__subpackages__\"],\n)\n\n# Library used by flatbuffer_cc_library rules.\ncc_library(\n name = \"runtime_cc\",\n hdrs = [\"//:public_headers\"],\n linkstatic = 1,\n strip_include_prefix = \"/include\",\n)\n" }, { "path": "CHANGELOG.md", "content": "# Flatbuffers Change Log\n\nAll major or breaking changes will be documented in this file, as well as any\nnew features that should be highlighted. Minor fixes or improvements are not\nnecessarily listed.\n\n## [25.12.19] (December 19 2025)(https://github.com/google/flatbuffers/releases/tag/v25.12.19)\n\n* [C++] Default emptry vector support (#8870)\n* [C++] Add --gen-absl-hash option (#8868)\n* [Kotlin] Upgrade to MacOS 15 (#8845)\n* [C++] Fix vector of table with naked ptrs (#8830)\n* [Python] Optimize Offset/Pad/Prep (#8808)\n* Implement `--file-names-only` (#8788)\n* [C++] Fix size verifer (#8740)\n\n## [25.9.23] (September 23 2025)(https://github.com/google/flatbuffers/releases/tag/v25.9.23)\n\n* flatc: `--grpc-callback-api` flag generates C++ gRPC Callback API server `CallbackService` skeletons AND client native callback/async stubs (unary + all streaming reactor forms) (opt-in, non-breaking, issue #8596).\n* Swift - Adds new API to reduce memory copying within swift (#8484)\n* Rust - Support Rust edition 2024 (#8638)\n* [C++] - Use the Google Style for clang-format without exceptions (#8706)\n\n## [25.2.10] (February 10 2025)(https://github.com/google/flatbuffers/releases/tag/v25.2.10)\n\n* Removed the old documentation pages. The new one is live at https://flatbuffers.dev\n* Swift version 6.0 support (#8414)\n\n## [25.1.24] (January 24 2025)(https://github.com/google/flatbuffers/releases/tag/v25.1.24)\n\n* Mostly related to bazel build support.\n* Min bazel supported is now 7 or higher, as WORKSPACE files are removed (#8509)\n* Minor C++ codegen fix removing extra semicolon (#8488)\n\n## [25.1.21] (January 21 2025)(https://github.com/google/flatbuffers/releases/tag/v25.1.21)\n\n* Rust Full Reflection (#8102)\n* Mostly documentation updates hosted at https://flatbuffers.dev\n\n## [24.3.25] (March 25 2024)(https://github.com/google/flatbuffers/releases/tag/v24.3.25)\n\n* Fixed license metadata parsing (#8253)\n* [C++] Allow string_view in `LookUpByKey` in addition to null-terminated c-style strings (#8203)\n\n## [24.3.7] (March 7 2024)(https://github.com/google/flatbuffers/releases/tag/v24.3.7)\n\n* Just to fix some of the CI build issues from the 24.3.6 release.\n\n## [24.3.6] (March 6 2024)(https://github.com/google/flatbuffers/releases/tag/v24.3.6)\n\n* Fix typescript object API to allow 0 values for null-default scalars (#7864)\n\n## [23.5.26 (May 26 2023)](https://github.com/google/flatbuffers/releases/tag/v23.5.26)\n\n* Mostly bug fixing for 64-bit support\n* Adds support for specifying underling type of unions in C++ and TS/JS (#7954)\n\n## [23.5.9 (May 9 2023)](https://github.com/google/flatbuffers/releases/tag/v23.5.9)\n\n* 64-bit support for C++ (#7935)\n\n## [23.5.8 (May 8 2023)](https://github.com/google/flatbuffers/releases/tag/v23.5.8)\n\n* add key_field to compiled tests\n* Add golden language directory\n* Rework cmake flatc codegeneration (#7938)\n* remove defining generated files in test srcs\n* Add binary schema reflection (#7932)\n* Migrate from rules_nodejs to rules_js/rules_ts (take 2) (#7928)\n* `flat_buffers.dart`: mark const variable finals for internal Dart linters\n* fixed some windows warnings (#7929)\n* inject no long for FBS generation to remove logs in flattests (#7926)\n* Revert \"Migrate from rules_nodejs to rules_js/rules_ts (#7923)\" (#7927)\n* Migrate from rules_nodejs to rules_js/rules_ts (#7923)\n* Only generate @kotlin.ExperimentalUnsigned annotation on create*Vector methods having an unsigned array type parameter. (#7881)\n* additional check for absl::string_view availability (#7897)\n* Optionally generate Python type annotations (#7858)\n* Replace deprecated command with environment file (#7921)\n* drop glibc from runtime dependencies (#7906)\n* Make JSON supporting advanced union features (#7869)\n* Allow to use functions from `BuildFlatBuffers.cmake` from a flatbuffers installation installed with CMake. (#7912)\n* TS/JS: Use TypeError instead of Error when appropriate (#7910)\n* Go: make generated code more compliant to \"go fmt\" (#7907)\n* Support file_identifier in Go (#7904)\n* Optionally generate type prefixes and suffixes for python code (#7857)\n* Go: add test for FinishWithFileIdentifier (#7905)\n* Fix go_sample.sh (#7903)\n* [TS/JS] Upgrade dependencies (#7889)\n* Add a FileWriter interface (#7821)\n* TS/JS: Use minvalue from enum if not found (#7888)\n* [CS] Verifier (#7850)\n* README.md: PyPI case typo (#7880)\n* Update go documentation link to point to root module (#7879)\n* use Bool for flatbuffers bool instead of Byte (#7876)\n* fix using null string in vector (#7872)\n* Add `flatbuffers-64` branch to CI for pushes\n* made changes to the rust docs so they would compile. new_with_capacity is deprecated should use with_capacity, get_root_as_monster should be root_as_monster (#7871)\n* Adding comment for code clarification (#7856)\n* ToCamelCase() when kLowerCamel now converts first char to lower. (#7838)\n* Fix help output for --java-checkerframework (#7854)\n* Update filename to README.md and improve formatting (#7855)\n* Update stale.yml\n* Updated remaining usages of LICENSE.txt\n\n## [23.3.3 (Mar 3 2023)](https://github.com/google/flatbuffers/releases/tag/v23.3.3)\n\n* Refactoring of `flatc` generators to use an interface (#7797).\n\n* Removed legacy cmake support and set min to 3.8 (#7801).\n\n## [23.1.21 (Jan 21 2023)](https://github.com/google/flatbuffers/releases/tag/v23.1.20)\n\n* Reworked entry points for Typescript/Javascript and compatibility for single\n file build (#7510)\n\n## [23.1.20 (Jan 20 2023)](https://github.com/google/flatbuffers/releases/tag/v23.1.20)\n\n* Removed go.mod files after some versioning issues were being report (#7780).\n\n## [23.1.4 (Jan 4 2023)](https://github.com/google/flatbuffers/releases/tag/v23.1.4)\n\n* Major release! Just kidding, we are continuing the\n [versioning scheme](https://github.com/google/flatbuffers/wiki/Versioning) of\n using a date to signify releases. This results in the first release of the new\n year to bump the tradition major version field.\n\n* Go minimum version is now 1.19 (#7720) with the addition of Go modules.\n\n* Added CI support for Big Endian regression testing (#7707).\n\n* Fixed `getFullyQualifiedName` in typescript to return name delimited by '.'\n instead of '_' (#7730).\n\n* Fixed the versioning scheme to not include leading zeros which are not\n consistently handled by every package manager. Only the last release\n (12.12.06) should have suffered from this.\n\n## [22.12.06 (Dec 06 2022)](https://github.com/google/flatbuffers/releases/tag/v22.12.06)\n\n* Bug fixing release, no major changes.\n\n## [22.10.25 (Oct 25 2022)](https://github.com/google/flatbuffers/releases/tag/v22.10.25)\n\n* Added Nim language support with generator and runtime libraries (#7534).\n\n## [22.9.29 (Sept 29 2022)](https://github.com/google/flatbuffers/releases/tag/v22.9.29)\n\n* Rust soundness fixes to avoid the crate from bing labelled unsafe (#7518).\n\n## [22.9.24 (Sept 24 2022)](https://github.com/google/flatbuffers/releases/tag/v22.9.24)\n\n* 20 Major releases in a row? Nope, we switched to a new\n [versioning scheme](https://github.com/google/flatbuffers/wiki/Versioning)\n that is based on date.\n\n* Python supports fixed size arrays now (#7529).\n\n* Behavior change in how C++ object API uses `UnPackTo`. The original intent of\n this was to reduce allocations by reusing an existing object to pack data\n into. At some point, this logic started to merge the states of the two objects\n instead of clearing the state of the packee. This change goes back to the\n original intention, the packed object is cleared when getting data packed into\n it (#7527).\n\n* Fixed a bug in C++ alignment that was using `sizeof()` instead of the intended\n `AlignOf()` for structs (#7520).\n\n* C# has an\n [official Nuget package](https://www.nuget.org/packages/Google.FlatBuffers)\n now (#7496).\n\n## 2.0.8 (Aug 29 2022)\n\n* Fix for `--keep-prefix` the was generating the wrong include statements for\n C++ (#7469). The bug was introduced in 2.0.7.\n\n* Added the `Verifier::Options` option struct to allow specifying runtime\n configuration settings for the verifier (#7489). This allows to skip verifying\n nested flatbuffers, a on-by-default change that was introduced in 2.0.7. This\n deprecates the existing `Verifier` constructor, which may be removed in a\n future version.\n\n* Refactor of `tests/test.cpp` that lead to ~10% speedup in compilation of the\n entire project (#7487).\n\n## 2.0.7 (Aug 22 2022)\n\n* This is the first version with an explicit change log, so all the previous\n features will not be listed.\n\n* Verifier now checks that buffers are at least the minimum size required to be\n a flatbuffers (12 bytes). This includes nested flatbuffers, which previously\n could be declared valid at size 0.\n\n* Annotated binaries. Given a flatbuffer binary and a schema (or binary schema)\n one can generate an annotated flatbuffer (.afb) to describe each byte in the\n binary with schema metadata and value.\n\n* First binary schema generator (Lua) to generate Lua code via a .bfbs file.\n This is mostly an implementation detail of flatc internals, but will be slowly\n applied to the other language generators.\n" }, { "path": "CMake/BuildFlatBuffers.cmake", "content": "# Copyright 2015 Google Inc. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n# General function to create FlatBuffer build rules for the given list of\n# schemas.\n#\n# flatbuffers_schemas: A list of flatbuffer schema files to process.\n#\n# schema_include_dirs: A list of schema file include directories, which will be\n# passed to flatc via the -I parameter.\n#\n# custom_target_name: The generated files will be added as dependencies for a\n# new custom target with this name. You should add that target as a dependency\n# for your main target to ensure these files are built. You can also retrieve\n# various properties from this target, such as GENERATED_INCLUDES_DIR,\n# BINARY_SCHEMAS_DIR, and COPY_TEXT_SCHEMAS_DIR.\n#\n# additional_dependencies: A list of additional dependencies that you'd like\n# all generated files to depend on. Pass in a blank string if you have none.\n#\n# generated_includes_dir: Where to generate the C++ header files for these\n# schemas. The generated includes directory will automatically be added to\n# CMake's include directories, and will be where generated header files are\n# placed. This parameter is optional; pass in empty string if you don't want to\n# generate include files for these schemas.\n#\n# binary_schemas_dir: If you specify an optional binary schema directory, binary\n# schemas will be generated for these schemas as well, and placed into the given\n# directory.\n#\n# copy_text_schemas_dir: If you want all text schemas (including schemas from\n# all schema include directories) copied into a directory (for example, if you\n# need them within your project to build JSON files), you can specify that\n# folder here. All text schemas will be copied to that folder.\n#\n# IMPORTANT: Make sure you quote all list arguments you pass to this function!\n# Otherwise CMake will only pass in the first element.\n# Example: build_flatbuffers(\"${fb_files}\" \"${include_dirs}\" target_name ...)\nfunction(build_flatbuffers flatbuffers_schemas\n schema_include_dirs\n custom_target_name\n additional_dependencies\n generated_includes_dir\n binary_schemas_dir\n copy_text_schemas_dir)\n\n # Test if including from FindFlatBuffers\n if(FLATBUFFERS_FLATC_EXECUTABLE)\n set(FLATC_TARGET \"\")\n set(FLATC ${FLATBUFFERS_FLATC_EXECUTABLE})\n elseif(TARGET flatbuffers::flatc)\n set(FLATC_TARGET flatbuffers::flatc)\n set(FLATC flatbuffers::flatc)\n else()\n set(FLATC_TARGET flatc)\n set(FLATC flatc)\n endif()\n set(FLATC_SCHEMA_ARGS --gen-mutable)\n if(FLATBUFFERS_FLATC_SCHEMA_EXTRA_ARGS)\n set(FLATC_SCHEMA_ARGS\n ${FLATBUFFERS_FLATC_SCHEMA_EXTRA_ARGS}\n ${FLATC_SCHEMA_ARGS}\n )\n endif()\n\n set(working_dir \"${CMAKE_CURRENT_SOURCE_DIR}\")\n\n set(schema_glob \"*.fbs\")\n # Generate the include files parameters.\n set(include_params \"\")\n set(all_generated_files \"\")\n foreach (include_dir ${schema_include_dirs})\n set(include_params -I ${include_dir} ${include_params})\n if (NOT ${copy_text_schemas_dir} STREQUAL \"\")\n # Copy text schemas from dependent folders.\n file(GLOB_RECURSE dependent_schemas ${include_dir}/${schema_glob})\n foreach (dependent_schema ${dependent_schemas})\n file(COPY ${dependent_schema} DESTINATION ${copy_text_schemas_dir})\n endforeach()\n endif()\n endforeach()\n\n foreach(schema ${flatbuffers_schemas})\n get_filename_component(filename ${schema} NAME_WE)\n # For each schema, do the things we requested.\n if (NOT ${generated_includes_dir} STREQUAL \"\")\n set(generated_include ${generated_includes_dir}/${filename}_generated.h)\n add_custom_command(\n OUTPUT ${generated_include}\n COMMAND ${FLATC} ${FLATC_SCHEMA_ARGS}\n -o ${generated_includes_dir}\n ${include_params}\n -c ${schema}\n DEPENDS ${FLATC_TARGET} ${schema} ${additional_dependencies}\n WORKING_DIRECTORY \"${working_dir}\")\n list(APPEND all_generated_files ${generated_include})\n endif()\n\n if (NOT ${binary_schemas_dir} STREQUAL \"\")\n set(binary_schema ${binary_schemas_dir}/${filename}.bfbs)\n add_custom_command(\n OUTPUT ${binary_schema}\n COMMAND ${FLATC} -b --schema\n -o ${binary_schemas_dir}\n ${include_params}\n ${schema}\n DEPENDS ${FLATC_TARGET} ${schema} ${additional_dependencies}\n WORKING_DIRECTORY \"${working_dir}\")\n list(APPEND all_generated_files ${binary_schema})\n endif()\n\n if (NOT ${copy_text_schemas_dir} STREQUAL \"\")\n file(COPY ${schema} DESTINATION ${copy_text_schemas_dir})\n endif()\n endforeach()\n\n # Create a custom target that depends on all the generated files.\n # This is the target that you can depend on to trigger all these\n # to be built.\n add_custom_target(${custom_target_name}\n DEPENDS ${all_generated_files} ${additional_dependencies})\n\n # Register the include directory we are using.\n if (NOT ${generated_includes_dir} STREQUAL \"\")\n include_directories(${generated_includes_dir})\n set_property(TARGET ${custom_target_name}\n PROPERTY GENERATED_INCLUDES_DIR\n ${generated_includes_dir})\n endif()\n\n # Register the binary schemas dir we are using.\n if (NOT ${binary_schemas_dir} STREQUAL \"\")\n set_property(TARGET ${custom_target_name}\n PROPERTY BINARY_SCHEMAS_DIR\n ${binary_schemas_dir})\n endif()\n\n # Register the text schema copy dir we are using.\n if (NOT ${copy_text_schemas_dir} STREQUAL \"\")\n set_property(TARGET ${custom_target_name}\n PROPERTY COPY_TEXT_SCHEMAS_DIR\n ${copy_text_schemas_dir})\n endif()\nendfunction()\n\n# Creates a target that can be linked against that generates flatbuffer headers.\n#\n# This function takes a target name and a list of schemas. You can also specify\n# other flagc flags using the FLAGS option to change the behavior of the flatc\n# tool.\n#\n# When the target_link_libraries is done within a different directory than\n# flatbuffers_generate_headers is called, then the target should also be dependent\n# the custom generation target called GENERATE_.\n#\n# Arguments:\n# TARGET: The name of the target to generate.\n# SCHEMAS: The list of schema files to generate code for.\n# BINARY_SCHEMAS_DIR: Optional. The directory in which to generate binary\n# schemas. Binary schemas will only be generated if a path is provided.\n# INCLUDE: Optional. Search for includes in the specified paths. (Use this\n# instead of \"-I \" and the FLAGS option so that CMake is aware of\n# the directories that need to be searched).\n# INCLUDE_PREFIX: Optional. The directory in which to place the generated\n# files. Use this instead of the --include-prefix option.\n# FLAGS: Optional. A list of any additional flags that you would like to pass\n# to flatc.\n#\n# Example:\n#\n# flatbuffers_generate_headers(\n# TARGET my_generated_headers_target\n# INCLUDE_PREFIX ${MY_INCLUDE_PREFIX}\"\n# SCHEMAS ${MY_SCHEMA_FILES}\n# BINARY_SCHEMAS_DIR \"${MY_BINARY_SCHEMA_DIRECTORY}\"\n# FLAGS --gen-object-api)\n#\n# target_link_libraries(MyExecutableTarget\n# PRIVATE my_generated_headers_target\n# )\n#\n# Optional (only needed within different directory):\n# add_dependencies(app GENERATE_my_generated_headers_target)\nfunction(flatbuffers_generate_headers)\n # Parse function arguments.\n set(options)\n set(one_value_args\n \"TARGET\"\n \"INCLUDE_PREFIX\"\n \"BINARY_SCHEMAS_DIR\")\n set(multi_value_args\n \"SCHEMAS\"\n \"INCLUDE\"\n \"FLAGS\")\n cmake_parse_arguments(\n PARSE_ARGV 0\n FLATBUFFERS_GENERATE_HEADERS\n \"${options}\"\n \"${one_value_args}\"\n \"${multi_value_args}\")\n\n # Test if including from FindFlatBuffers\n if(FLATBUFFERS_FLATC_EXECUTABLE)\n set(FLATC_TARGET \"\")\n set(FLATC ${FLATBUFFERS_FLATC_EXECUTABLE})\n elseif(TARGET flatbuffers::flatc)\n set(FLATC_TARGET flatbuffers::flatc)\n set(FLATC flatbuffers::flatc)\n else()\n set(FLATC_TARGET flatc)\n set(FLATC flatc)\n endif()\n\n set(working_dir \"${CMAKE_CURRENT_SOURCE_DIR}\")\n\n # Generate the include files parameters.\n set(include_params \"\")\n foreach (include_dir ${FLATBUFFERS_GENERATE_HEADERS_INCLUDE})\n set(include_params -I ${include_dir} ${include_params})\n endforeach()\n\n # Create a directory to place the generated code.\n set(generated_target_dir \"${CMAKE_CURRENT_BINARY_DIR}/${FLATBUFFERS_GENERATE_HEADERS_TARGET}\")\n set(generated_include_dir \"${generated_target_dir}\")\n if (NOT ${FLATBUFFERS_GENERATE_HEADERS_INCLUDE_PREFIX} STREQUAL \"\")\n set(generated_include_dir \"${generated_include_dir}/${FLATBUFFERS_GENERATE_HEADERS_INCLUDE_PREFIX}\")\n list(APPEND FLATBUFFERS_GENERATE_HEADERS_FLAGS \n \"--include-prefix\" ${FLATBUFFERS_GENERATE_HEADERS_INCLUDE_PREFIX})\n endif()\n\n set(generated_custom_commands)\n\n # Create rules to generate the code for each schema.\n foreach(schema ${FLATBUFFERS_GENERATE_HEADERS_SCHEMAS})\n get_filename_component(filename ${schema} NAME_WE)\n set(generated_include \"${generated_include_dir}/${filename}_generated.h\")\n\n # Generate files for grpc if needed\n set(generated_source_file)\n if(\"${FLATBUFFERS_GENERATE_HEADERS_FLAGS}\" MATCHES \"--grpc\")\n # Check if schema file contain a rpc_service definition\n file(STRINGS ${schema} has_grpc REGEX \"rpc_service\")\n if(has_grpc)\n list(APPEND generated_include \"${generated_include_dir}/${filename}.grpc.fb.h\")\n set(generated_source_file \"${generated_include_dir}/${filename}.grpc.fb.cc\")\n endif()\n endif()\n\n add_custom_command(\n OUTPUT ${generated_include} ${generated_source_file}\n COMMAND ${FLATC} ${FLATC_ARGS}\n -o ${generated_include_dir}\n ${include_params}\n -c ${schema}\n ${FLATBUFFERS_GENERATE_HEADERS_FLAGS}\n DEPENDS ${FLATC_TARGET} ${schema}\n WORKING_DIRECTORY \"${working_dir}\"\n COMMENT \"Building ${schema} flatbuffers...\")\n list(APPEND all_generated_header_files ${generated_include})\n list(APPEND all_generated_source_files ${generated_source_file})\n list(APPEND generated_custom_commands \"${generated_include}\" \"${generated_source_file}\")\n\n # Geneate the binary flatbuffers schemas if instructed to.\n if (NOT ${FLATBUFFERS_GENERATE_HEADERS_BINARY_SCHEMAS_DIR} STREQUAL \"\")\n set(binary_schema\n \"${FLATBUFFERS_GENERATE_HEADERS_BINARY_SCHEMAS_DIR}/${filename}.bfbs\")\n add_custom_command(\n OUTPUT ${binary_schema}\n COMMAND ${FLATC} -b --schema\n -o ${FLATBUFFERS_GENERATE_HEADERS_BINARY_SCHEMAS_DIR}\n ${include_params}\n ${schema}\n DEPENDS ${FLATC_TARGET} ${schema}\n WORKING_DIRECTORY \"${working_dir}\")\n list(APPEND generated_custom_commands \"${binary_schema}\")\n list(APPEND all_generated_binary_files ${binary_schema})\n endif()\n endforeach()\n\n # Create an additional target as add_custom_command scope is only within same directory (CMakeFile.txt)\n set(generate_target GENERATE_${FLATBUFFERS_GENERATE_HEADERS_TARGET})\n add_custom_target(${generate_target} ALL\n DEPENDS ${generated_custom_commands}\n COMMENT \"Generating flatbuffer target ${FLATBUFFERS_GENERATE_HEADERS_TARGET}\")\n\n # Set up interface library\n add_library(${FLATBUFFERS_GENERATE_HEADERS_TARGET} INTERFACE)\n target_sources(\n ${FLATBUFFERS_GENERATE_HEADERS_TARGET}\n INTERFACE\n ${all_generated_header_files}\n ${all_generated_binary_files}\n ${all_generated_source_files}\n ${FLATBUFFERS_GENERATE_HEADERS_SCHEMAS})\n add_dependencies(\n ${FLATBUFFERS_GENERATE_HEADERS_TARGET}\n ${FLATC_TARGET})\n target_include_directories(\n ${FLATBUFFERS_GENERATE_HEADERS_TARGET}\n INTERFACE ${generated_target_dir})\n\n # Organize file layout for IDEs.\n source_group(\n TREE \"${generated_target_dir}\"\n PREFIX \"Flatbuffers/Generated/Headers Files\"\n FILES ${all_generated_header_files})\n source_group(\n TREE \"${generated_target_dir}\"\n PREFIX \"Flatbuffers/Generated/Source Files\"\n FILES ${all_generated_source_files})\n source_group(\n TREE ${working_dir}\n PREFIX \"Flatbuffers/Schemas\"\n FILES ${FLATBUFFERS_GENERATE_HEADERS_SCHEMAS})\n if (NOT ${FLATBUFFERS_GENERATE_HEADERS_BINARY_SCHEMAS_DIR} STREQUAL \"\")\n source_group(\n TREE \"${FLATBUFFERS_GENERATE_HEADERS_BINARY_SCHEMAS_DIR}\"\n PREFIX \"Flatbuffers/Generated/Binary Schemas\"\n FILES ${all_generated_binary_files})\n endif()\nendfunction()\n\n# Creates a target that can be linked against that generates flatbuffer binaries\n# from json files.\n#\n# This function takes a target name and a list of schemas and Json files. You\n# can also specify other flagc flags and options to change the behavior of the\n# flatc compiler.\n#\n# Adding this target to your executable ensurses that the flatbuffer binaries\n# are compiled before your executable is run.\n#\n# Arguments:\n# TARGET: The name of the target to generate.\n# JSON_FILES: The list of json files to compile to flatbuffers binaries.\n# SCHEMA: The flatbuffers schema of the Json files to be compiled.\n# INCLUDE: Optional. Search for includes in the specified paths. (Use this \n# instead of \"-I \" and the FLAGS option so that CMake is aware of \n# the directories that need to be searched).\n# OUTPUT_DIR: The directly where the generated flatbuffers binaries should be\n# placed.\n# FLAGS: Optional. A list of any additional flags that you would like to pass\n# to flatc.\n#\n# Example:\n#\n# flatbuffers_generate_binary_files(\n# TARGET my_binary_data\n# SCHEMA \"${MY_SCHEMA_DIR}/my_example_schema.fbs\"\n# JSON_FILES ${MY_JSON_FILES}\n# OUTPUT_DIR \"${MY_BINARY_DATA_DIRECTORY}\"\n# FLAGS --strict-json)\n#\n# target_link_libraries(MyExecutableTarget\n# PRIVATE my_binary_data\n# )\nfunction(flatbuffers_generate_binary_files)\n # Parse function arguments.\n set(options)\n set(one_value_args\n \"TARGET\"\n \"SCHEMA\"\n \"OUTPUT_DIR\")\n set(multi_value_args\n \"JSON_FILES\"\n \"INCLUDE\"\n \"FLAGS\")\n cmake_parse_arguments(\n PARSE_ARGV 0\n FLATBUFFERS_GENERATE_BINARY_FILES\n \"${options}\"\n \"${one_value_args}\"\n \"${multi_value_args}\")\n\n # Test if including from FindFlatBuffers\n if(FLATBUFFERS_FLATC_EXECUTABLE)\n set(FLATC_TARGET \"\")\n set(FLATC ${FLATBUFFERS_FLATC_EXECUTABLE})\n elseif(TARGET flatbuffers::flatc)\n set(FLATC_TARGET flatbuffers::flatc)\n set(FLATC flatbuffers::flatc)\n else()\n set(FLATC_TARGET flatc)\n set(FLATC flatc)\n endif()\n\n set(working_dir \"${CMAKE_CURRENT_SOURCE_DIR}\")\n\n # Generate the include files parameters.\n set(include_params \"\")\n foreach (include_dir ${FLATBUFFERS_GENERATE_BINARY_FILES_INCLUDE})\n set(include_params -I ${include_dir} ${include_params})\n endforeach()\n\n # Create rules to generate the flatbuffers binary for each json file.\n foreach(json_file ${FLATBUFFERS_GENERATE_BINARY_FILES_JSON_FILES})\n get_filename_component(filename ${json_file} NAME_WE)\n set(generated_binary_file \"${FLATBUFFERS_GENERATE_BINARY_FILES_OUTPUT_DIR}/${filename}.bin\")\n add_custom_command(\n OUTPUT ${generated_binary_file}\n COMMAND ${FLATC} ${FLATC_ARGS}\n -o ${FLATBUFFERS_GENERATE_BINARY_FILES_OUTPUT_DIR}\n ${include_params}\n -b ${FLATBUFFERS_GENERATE_BINARY_FILES_SCHEMA} ${json_file}\n ${FLATBUFFERS_GENERATE_BINARY_FILES_FLAGS}\n DEPENDS ${FLATC_TARGET} ${json_file}\n WORKING_DIRECTORY \"${working_dir}\"\n COMMENT \"Building ${json_file} binary flatbuffers...\")\n list(APPEND all_generated_binary_files ${generated_binary_file})\n endforeach()\n\n # Set up interface library\n add_library(${FLATBUFFERS_GENERATE_BINARY_FILES_TARGET} INTERFACE)\n target_sources(\n ${FLATBUFFERS_GENERATE_BINARY_FILES_TARGET}\n INTERFACE\n ${all_generated_binary_files}\n ${FLATBUFFERS_GENERATE_BINARY_FILES_JSON_FILES}\n ${FLATBUFFERS_GENERATE_BINARY_FILES_SCHEMA})\n add_dependencies(\n ${FLATBUFFERS_GENERATE_BINARY_FILES_TARGET}\n ${FLATC})\n\n # Organize file layout for IDEs.\n source_group(\n TREE ${working_dir}\n PREFIX \"Flatbuffers/JSON Files\"\n FILES ${FLATBUFFERS_GENERATE_BINARY_FILES_JSON_FILES})\n source_group(\n TREE ${working_dir}\n PREFIX \"Flatbuffers/Schemas\"\n FILES ${FLATBUFFERS_GENERATE_BINARY_FILES_SCHEMA})\n source_group(\n TREE ${FLATBUFFERS_GENERATE_BINARY_FILES_OUTPUT_DIR}\n PREFIX \"Flatbuffers/Generated/Binary Files\"\n FILES ${all_generated_binary_files})\nendfunction()\n" }, { "path": "CMake/DESCRIPTION.txt", "content": "FlatBuffers is a cross platform serialization library architected for\nmaximum memory efficiency. It allows you to directly access serialized\ndata without parsing/unpacking it first, while still having great \nforwards/backwards compatibility.\n" }, { "path": "CMake/FindFlatBuffers.cmake", "content": "# Copyright 2014 Stefan.Eilemann@epfl.ch\n# Copyright 2014 Google Inc. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n# Find the flatbuffers schema compiler\n#\n# Output Variables:\n# * FLATBUFFERS_FLATC_EXECUTABLE the flatc compiler executable\n# * FLATBUFFERS_FOUND\n#\n# Provides:\n# * FLATBUFFERS_GENERATE_C_HEADERS(Name ) creates the C++ headers\n# for the given flatbuffer schema files.\n# Returns the header files in ${Name}_OUTPUTS\n\nset(FLATBUFFERS_CMAKE_DIR ${CMAKE_CURRENT_LIST_DIR})\n\nfind_program(FLATBUFFERS_FLATC_EXECUTABLE NAMES flatc)\nfind_path(FLATBUFFERS_INCLUDE_DIR NAMES flatbuffers/flatbuffers.h)\n\ninclude(FindPackageHandleStandardArgs)\nfind_package_handle_standard_args(FlatBuffers\n DEFAULT_MSG FLATBUFFERS_FLATC_EXECUTABLE FLATBUFFERS_INCLUDE_DIR)\n\nif(FLATBUFFERS_FOUND)\n function(FLATBUFFERS_GENERATE_C_HEADERS Name)\n set(FLATC_OUTPUTS)\n foreach(FILE ${ARGN})\n get_filename_component(FLATC_OUTPUT ${FILE} NAME_WE)\n set(FLATC_OUTPUT\n \"${CMAKE_CURRENT_BINARY_DIR}/${FLATC_OUTPUT}_generated.h\")\n list(APPEND FLATC_OUTPUTS ${FLATC_OUTPUT})\n\n add_custom_command(OUTPUT ${FLATC_OUTPUT}\n COMMAND ${FLATBUFFERS_FLATC_EXECUTABLE}\n ARGS -c -o \"${CMAKE_CURRENT_BINARY_DIR}/\" ${FILE}\n DEPENDS ${FILE}\n COMMENT \"Building C++ header for ${FILE}\"\n WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})\n endforeach()\n set(${Name}_OUTPUTS ${FLATC_OUTPUTS} PARENT_SCOPE)\n endfunction()\n\n set(FLATBUFFERS_INCLUDE_DIRS ${FLATBUFFERS_INCLUDE_DIR})\n include_directories(${CMAKE_BINARY_DIR})\nelse()\n set(FLATBUFFERS_INCLUDE_DIR)\nendif()\n\ninclude(\"${FLATBUFFERS_CMAKE_DIR}/BuildFlatBuffers.cmake\")\n" }, { "path": "CMake/PackageDebian.cmake", "content": "# ------------------- Debianization ---------------------\nif (UNIX)\n\n # Set build environment\n SET(CPACK_GENERATOR \"TGZ;DEB\")\n SET(CPACK_SOURCE_TGZ \"ON\")\n\n # Common package information\n SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY\n \"FlatBuffers is an efficient cross platform serialization library for C++, with support for Java, C# and Go. It was created at Google specifically for game development and other performance-critical applications.\")\n SET(CPACK_DEBIAN_PACKAGE_HOMEPAGE \"https://github.com/google/flatbuffers\")\n SET(CPACK_DEBIAN_PACKAGE_MAINTAINER \"Vitaly Isaev \")\n\n SET(CPACK_PACKAGE_VERSION_MAJOR ${VERSION_MAJOR})\n SET(CPACK_PACKAGE_VERSION_MINOR ${VERSION_MINOR})\n SET(CPACK_PACKAGE_VERSION_PATCH ${VERSION_PATCH})\n SET(CPACK_PACKAGE_VERSION \"${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}-${VERSION_COMMIT}\")\n SET(CPACK_DEBIAN_PACKAGE_VERSION \"${CPACK_PACKAGE_VERSION}\")\n\n # Package name\n SET(CPACK_DEBIAN_PACKAGE_NAME \"flatbuffers\")\n SET(CPACK_RESOURCE_FILE_LICENSE ${CMAKE_SOURCE_DIR}/LICENSE)\n set(CPACK_DEBIAN_FILE_NAME \"DEB-DEFAULT\")\n\nendif(UNIX)\n" }, { "path": "CMake/PackageRedhat.cmake", "content": "if (UNIX)\n set(CPACK_GENERATOR \"RPM\")\n set(CPACK_SOURCE_TGZ \"ON\")\n\n set(CPACK_PACKAGE_DESCRIPTION_SUMMARY \"FlatBuffers serialization library and schema compiler.\")\n \n set(CPACK_RPM_PACKAGE_HOMEPAGE \"https://github.com/google/flatbuffers\")\n set(CPACK_RPM_PACKAGE_MAINTAINER \"Marc Butler \")\n\n set(CPACK_PACKAGE_VERSION_MAJOR ${VERSION_MAJOR})\n set(CPACK_PACKAGE_VERSION_MINOR ${VERSION_MINOR})\n set(CPACK_PACKAGE_VERSION_PATCH ${VERSION_PATCH})\n set(CPACK_PACKAGE_VERSION \"${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}-${VERSION_COMMIT}\")\n set(CPACK_RPM_PACKAGE_VERSION \"${CPACK_PACKAGE_VERSION}\")\n\n set(CPACK_RPM_PACKAGE_NAME \"flatbuffers\")\n\n # Assume this is not a cross compilation build.\n if(NOT CPACK_RPM_PACKAGE_ARCHITECTURE)\n set(CPACK_RPM_PACKAGE_ARCHITECTURE \"${CMAKE_SYSTEM_PROCESSOR}\")\n endif(NOT CPACK_RPM_PACKAGE_ARCHITECTURE)\n\n set(CPACK_RPM_PACKAGE_VENDOR \"Google, Inc.\")\n set(CPACK_RPM_PACKAGE_LICENSE \"Apache 2.0\")\n set(CPACK_RESOURCE_FILE_LICENSE ${CMAKE_SOURCE_DIR}/LICENSE)\n set(CPACK_PACKAGE_DESCRIPTION_FILE ${CMAKE_SOURCE_DIR}/CMake/DESCRIPTION.txt)\n\n # This may reduce rpm compatiblity with very old systems.\n set(CPACK_RPM_COMPRESSION_TYPE lzma)\n \n set(CPACK_RPM_PACKAGE_NAME \"flatbuffers\")\n set(CPACK_PACKAGE_FILE_NAME\n \"${CPACK_RPM_PACKAGE_NAME}_${CPACK_RPM_PACKAGE_VERSION}_${CPACK_RPM_PACKAGE_ARCHITECTURE}\")\n if(NOT DEFINED ${CPACK_PACKAGING_INSTALL_PREFIX})\n # Default packaging install prefix on RedHat systems is /usr.\n # This is the assumed value when this variable is not defined.\n # There is currently a conflict with\n # /usr/${CMAKE_INSTALL_LIBDIR}/cmake which is installed by default\n # by other packages on RedHat (most notably cmake-filesystem). Ensure\n # that on these systems, flatbuffers does not package this path.\n # This patch is required for cmake pre-3.17.\n list(APPEND CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION \"/usr/${CMAKE_INSTALL_LIBDIR}/cmake\")\n endif()\nendif(UNIX)\n" }, { "path": "CMake/Version.cmake", "content": "set(VERSION_MAJOR 25)\nset(VERSION_MINOR 12)\nset(VERSION_PATCH 19)\nset(VERSION_COMMIT 0)\n\nif(EXISTS \"${CMAKE_CURRENT_SOURCE_DIR}/.git\")\n find_program(GIT git)\n if(GIT)\n execute_process(\n COMMAND ${GIT} describe --tags\n WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}\n OUTPUT_VARIABLE GIT_DESCRIBE_DIRTY\n OUTPUT_STRIP_TRAILING_WHITESPACE\n RESULT_VARIABLE GIT_DESCRIBE_RESULT\n )\n\n if(GIT_DESCRIBE_RESULT EQUAL 0)\n # Test if the most recent Git tag matches the pattern \"v..*\"\n if(GIT_DESCRIBE_DIRTY MATCHES \"^v[0-9]+\\\\.[0-9]+\\\\.[0-9]+.*\")\n string(REGEX REPLACE \"^v([0-9]+)\\\\..*\" \"\\\\1\" VERSION_MAJOR \"${GIT_DESCRIBE_DIRTY}\")\n string(REGEX REPLACE \"^v[0-9]+\\\\.([0-9]+).*\" \"\\\\1\" VERSION_MINOR \"${GIT_DESCRIBE_DIRTY}\")\n string(REGEX REPLACE \"^v[0-9]+\\\\.[0-9]+\\\\.([0-9]+).*\" \"\\\\1\" VERSION_PATCH \"${GIT_DESCRIBE_DIRTY}\")\n string(REGEX REPLACE \"^v[0-9]+\\\\.[0-9]+\\\\.[0-9]+\\\\-([0-9]+).*\" \"\\\\1\" VERSION_COMMIT \"${GIT_DESCRIBE_DIRTY}\")\n # If the tag points to the commit, then only the tag is shown in \"git describe\"\n if(VERSION_COMMIT STREQUAL GIT_DESCRIBE_DIRTY)\n set(VERSION_COMMIT 0)\n endif()\n else()\n message(WARNING \"\\\"${GIT_DESCRIBE_DIRTY}\\\" does not match pattern v..-\")\n endif()\n else()\n message(WARNING \"git describe failed with exit code: ${GIT_DESCRIBE_RESULT}\\nMake sure you cloned with tags or run 'git fetch --tags'.\")\n endif()\n else()\n message(WARNING \"git is not found\")\n endif()\nendif()\n\nmessage(STATUS \"Proceeding with version: ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}.${VERSION_COMMIT}\")\n" }, { "path": "CMake/flatbuffers-config-version.cmake.in", "content": "set(PACKAGE_VERSION \"@VERSION_MAJOR@.@VERSION_MINOR@.@VERSION_PATCH@\")\n\n# Check whether the requested PACKAGE_FIND_VERSION is compatible\nif(\"${PACKAGE_VERSION}\" VERSION_LESS \"${PACKAGE_FIND_VERSION}\")\n set(PACKAGE_VERSION_COMPATIBLE FALSE)\nelse()\n set(PACKAGE_VERSION_COMPATIBLE TRUE)\n if (\"${PACKAGE_VERSION}\" VERSION_EQUAL \"${PACKAGE_FIND_VERSION}\")\n set(PACKAGE_VERSION_EXACT TRUE)\n endif()\nendif()\n" }, { "path": "CMake/flatbuffers-config.cmake", "content": "include(\"${CMAKE_CURRENT_LIST_DIR}/FlatBuffersTargets.cmake\" OPTIONAL)\ninclude(\"${CMAKE_CURRENT_LIST_DIR}/FlatcTargets.cmake\" OPTIONAL)\ninclude(\"${CMAKE_CURRENT_LIST_DIR}/FlatBuffersSharedTargets.cmake\" OPTIONAL)\ninclude(\"${CMAKE_CURRENT_LIST_DIR}/BuildFlatBuffers.cmake\" OPTIONAL)" }, { "path": "CMake/flatbuffers.pc.in", "content": "libdir=@CMAKE_INSTALL_FULL_LIBDIR@\nincludedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@\n\nName: FlatBuffers\nDescription: Memory Efficient Serialization Library\nVersion: @VERSION_MAJOR@.@VERSION_MINOR@.@VERSION_PATCH@\n\nLibs: -L${libdir} -lflatbuffers\nCflags: -I${includedir}\n" }, { "path": "CMakeLists.txt", "content": "# This is the legacy minimum version flatbuffers supported for a while.\ncmake_minimum_required(VERSION 3.8...3.25.2)\n\n# Attempt to read the current version of flatbuffers by looking at the latest tag.\ninclude(CMake/Version.cmake)\n\nproject(FlatBuffers\n VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}\n LANGUAGES CXX)\n\n# generate compile_commands.json\nset(CMAKE_EXPORT_COMPILE_COMMANDS ON)\n\n# NOTE: Code coverage only works on Linux & OSX.\noption(FLATBUFFERS_CODE_COVERAGE \"Enable the code coverage build option.\" OFF)\noption(FLATBUFFERS_BUILD_TESTS \"Enable the build of tests and samples.\" ON)\noption(FLATBUFFERS_INSTALL \"Enable the installation of targets.\" ON)\noption(FLATBUFFERS_BUILD_FLATLIB \"Enable the build of the flatbuffers library\"\n ON)\noption(FLATBUFFERS_BUILD_FLATC \"Enable the build of the flatbuffers compiler\"\n ON)\noption(FLATBUFFERS_STATIC_FLATC \"Build flatbuffers compiler with -static flag\"\n OFF)\noption(FLATBUFFERS_BUILD_FLATHASH \"Enable the build of flathash\" OFF)\noption(FLATBUFFERS_BUILD_BENCHMARKS \"Enable the build of flatbenchmark.\"\n OFF)\noption(FLATBUFFERS_BUILD_GRPCTEST \"Enable the build of grpctest\" OFF)\noption(FLATBUFFERS_BUILD_SHAREDLIB\n \"Enable the build of the flatbuffers shared library\"\n OFF)\noption(FLATBUFFERS_LIBCXX_WITH_CLANG \"Force libc++ when using Clang\" ON)\n# NOTE: Sanitizer check only works on Linux & OSX (gcc & llvm).\noption(FLATBUFFERS_CODE_SANITIZE\n \"Add '-fsanitize' flags to 'flattests' and 'flatc' targets.\"\n OFF)\noption(FLATBUFFERS_PACKAGE_REDHAT\n \"Build an rpm using the 'package' target.\"\n OFF)\noption(FLATBUFFERS_PACKAGE_DEBIAN\n \"Build an deb using the 'package' target.\"\n OFF)\noption(FLATBUFFERS_BUILD_CPP17\n \"Enable the build of c++17 test target. \\\"\n Requirements: Clang6, GCC7, MSVC2017 (_MSC_VER >= 1914) or higher.\"\n OFF)\noption(FLATBUFFERS_BUILD_LEGACY\n \"Run C++ code generator with '--cpp-std c++0x' switch.\"\n OFF)\noption(FLATBUFFERS_ENABLE_PCH\n \"Enable precompile headers support for 'flatbuffers' and 'flatc'. \\\"\n Only work if CMake supports 'target_precompile_headers'. \\\"\n This can speed up compilation time.\"\n OFF)\noption(FLATBUFFERS_SKIP_MONSTER_EXTRA\n \"Skip generating monster_extra.fbs that contains non-supported numerical\\\"\n types.\" OFF)\noption(FLATBUFFERS_STRICT_MODE\n \"Build flatbuffers with all warnings as errors (-Werror or /WX).\"\n OFF)\n\nif(NOT DEFINED FLATBUFFERS_CPP_STD)\n set(FLATBUFFERS_CPP_STD 11)\nendif()\n\nset(MSVC_LIKE OFF)\nif(MSVC OR CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL \"MSVC\")\n set(MSVC_LIKE ON)\nendif()\n\nif(CMAKE_CXX_COMPILER_ID MATCHES \"Clang\")\n set(IS_CLANG ON)\nelse()\n set(IS_CLANG OFF)\nendif()\n\nif(DEFINED FLATBUFFERS_COMPILATION_TIMINGS)\n message(\"Recording Compilation Timings to ${FLATBUFFERS_COMPILATION_TIMINGS}\")\n file(REMOVE ${FLATBUFFERS_COMPILATION_TIMINGS})\n set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE \"time -f 'Wall: %E User: %U Sys: %S | %C' -q -a -o ${FLATBUFFERS_COMPILATION_TIMINGS}\")\n set_property(GLOBAL PROPERTY RULE_LAUNCH_CUSTOM \"time -f 'Wall: %E User: %U Sys: %S | %C' -q -a -o ${FLATBUFFERS_COMPILATION_TIMINGS}\")\n set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK \"time -f 'Wall: %E User: %U Sys: %S | %C' -q -a -o ${FLATBUFFERS_COMPILATION_TIMINGS}\")\nendif()\n\nif(NOT FLATBUFFERS_BUILD_FLATC AND FLATBUFFERS_BUILD_TESTS)\n message(WARNING\n \"Cannot build tests without building the compiler. Tests will be disabled.\")\n set(FLATBUFFERS_BUILD_TESTS OFF)\nendif()\n\nif(DEFINED FLATBUFFERS_MAX_PARSING_DEPTH)\n # Override the default recursion depth limit.\n add_definitions(-DFLATBUFFERS_MAX_PARSING_DEPTH=${FLATBUFFERS_MAX_PARSING_DEPTH})\n message(STATUS \"FLATBUFFERS_MAX_PARSING_DEPTH: ${FLATBUFFERS_MAX_PARSING_DEPTH}\")\nendif()\n\n# Auto-detect locale-narrow 'strtod_l' and 'strtoull_l' functions.\nif(NOT DEFINED FLATBUFFERS_LOCALE_INDEPENDENT)\n include(CheckCXXSymbolExists)\n\n set(FLATBUFFERS_LOCALE_INDEPENDENT 0)\n if(MSVC_LIKE)\n check_cxx_symbol_exists(_strtof_l stdlib.h FLATBUFFERS_HAS_STRTOF_L)\n check_cxx_symbol_exists(_strtoui64_l stdlib.h FLATBUFFERS_HAS_STRTOULL_L)\n else()\n check_cxx_symbol_exists(strtof_l stdlib.h FLATBUFFERS_HAS_STRTOF_L)\n check_cxx_symbol_exists(strtoull_l stdlib.h FLATBUFFERS_HAS_STRTOULL_L)\n endif()\n if(FLATBUFFERS_HAS_STRTOF_L AND FLATBUFFERS_HAS_STRTOULL_L)\n set(FLATBUFFERS_LOCALE_INDEPENDENT 1)\n endif()\nendif()\nadd_definitions(-DFLATBUFFERS_LOCALE_INDEPENDENT=$)\n\nif(NOT WIN32)\n include(CheckSymbolExists)\n check_symbol_exists(realpath \"stdlib.h\" HAVE_REALPATH)\n if(NOT HAVE_REALPATH)\n add_definitions(-DFLATBUFFERS_NO_ABSOLUTE_PATH_RESOLUTION)\n endif()\nendif()\n\nset(FlatBuffers_Library_SRCS\n include/flatbuffers/allocator.h\n include/flatbuffers/array.h\n include/flatbuffers/base.h\n include/flatbuffers/buffer.h\n include/flatbuffers/buffer_ref.h\n include/flatbuffers/default_allocator.h\n include/flatbuffers/detached_buffer.h\n include/flatbuffers/code_generator.h\n include/flatbuffers/file_manager.h\n include/flatbuffers/flatbuffer_builder.h\n include/flatbuffers/flatbuffers.h\n include/flatbuffers/flexbuffers.h\n include/flatbuffers/flex_flat_util.h\n include/flatbuffers/hash.h\n include/flatbuffers/idl.h\n include/flatbuffers/minireflect.h\n include/flatbuffers/reflection.h\n include/flatbuffers/reflection_generated.h\n include/flatbuffers/registry.h\n include/flatbuffers/stl_emulation.h\n include/flatbuffers/string.h\n include/flatbuffers/struct.h\n include/flatbuffers/table.h\n include/flatbuffers/util.h\n include/flatbuffers/vector.h\n include/flatbuffers/vector_downward.h\n include/flatbuffers/verifier.h\n src/file_manager.cpp\n src/file_name_manager.cpp\n src/idl_parser.cpp\n src/idl_gen_text.cpp\n src/reflection.cpp\n src/util.cpp\n)\n\nset(FlatBuffers_Compiler_SRCS\n ${FlatBuffers_Library_SRCS}\n src/idl_gen_binary.cpp\n src/idl_gen_text.cpp\n src/idl_gen_cpp.cpp\n src/idl_gen_csharp.cpp\n src/idl_gen_dart.cpp\n src/idl_gen_kotlin.cpp\n src/idl_gen_kotlin_kmp.cpp\n src/idl_gen_go.cpp\n src/idl_gen_java.cpp\n src/idl_gen_ts.cpp\n src/idl_gen_php.cpp\n src/idl_gen_python.cpp\n src/idl_gen_lobster.cpp\n src/idl_gen_rust.cpp\n src/idl_gen_fbs.cpp\n src/idl_gen_grpc.cpp\n src/idl_gen_json_schema.cpp\n src/idl_gen_swift.cpp\n src/idl_namer.h\n src/namer.h\n src/flatc.cpp\n src/flatc_main.cpp\n src/bfbs_gen.h\n src/bfbs_gen_lua.h\n src/bfbs_gen_nim.h\n src/bfbs_namer.h\n include/codegen/idl_namer.h\n include/codegen/namer.h\n include/codegen/python.h\n include/codegen/python.cc\n include/flatbuffers/code_generators.h\n src/binary_annotator.h\n src/binary_annotator.cpp\n src/annotated_binary_text_gen.h\n src/annotated_binary_text_gen.cpp\n src/bfbs_gen_lua.cpp\n src/bfbs_gen_nim.cpp\n src/code_generators.cpp\n grpc/src/compiler/schema_interface.h\n grpc/src/compiler/cpp_generator.h\n grpc/src/compiler/cpp_generator.cc\n grpc/src/compiler/go_generator.h\n grpc/src/compiler/go_generator.cc\n grpc/src/compiler/java_generator.h\n grpc/src/compiler/java_generator.cc\n grpc/src/compiler/python_generator.h\n grpc/src/compiler/python_generator.cc\n grpc/src/compiler/swift_generator.h\n grpc/src/compiler/swift_generator.cc\n grpc/src/compiler/ts_generator.h\n grpc/src/compiler/ts_generator.cc\n)\n\nset(FlatHash_SRCS\n include/flatbuffers/hash.h\n src/flathash.cpp\n)\n\nset(FlatBuffers_Tests_SRCS\n ${FlatBuffers_Library_SRCS}\n src/idl_gen_fbs.cpp\n tests/default_vectors_strings_test.cpp\n tests/default_vectors_strings_test.h\n tests/evolution_test.cpp\n tests/flexbuffers_test.cpp\n tests/fuzz_test.cpp\n tests/json_test.cpp\n tests/key_field_test.cpp\n tests/monster_test.cpp\n tests/optional_scalars_test.cpp\n tests/parser_test.cpp\n tests/proto_test.cpp\n tests/reflection_test.cpp\n tests/test.cpp\n tests/test_assert.h\n tests/test_assert.cpp\n tests/test_builder.h\n tests/test_builder.cpp\n tests/util_test.cpp\n tests/vector_table_naked_ptr_test.h\n tests/vector_table_naked_ptr_test.cpp\n tests/native_type_test_impl.h\n tests/native_type_test_impl.cpp\n tests/alignment_test.h\n tests/alignment_test.cpp\n tests/64bit/offset64_test.h\n tests/64bit/offset64_test.cpp\n include/flatbuffers/code_generators.h\n src/code_generators.cpp\n)\n\nset(FlatBuffers_Tests_CPP17_SRCS\n ${FlatBuffers_Library_SRCS}\n tests/test_assert.h\n tests/test_assert.cpp\n tests/cpp17/test_cpp17.cpp\n)\n\nset(FlatBuffers_Sample_Binary_SRCS\n samples/sample_binary.cpp\n)\n\nset(FlatBuffers_Sample_Text_SRCS\n ${FlatBuffers_Library_SRCS}\n samples/sample_text.cpp\n)\n\nset(FlatBuffers_Sample_BFBS_SRCS\n ${FlatBuffers_Library_SRCS}\n samples/sample_bfbs.cpp\n)\n\nset(FlatBuffers_GRPCTest_SRCS\n include/flatbuffers/flatbuffers.h\n include/flatbuffers/grpc.h\n include/flatbuffers/util.h\n src/util.cpp\n tests/monster_test.grpc.fb.h\n tests/test_assert.h\n tests/test_builder.h\n tests/monster_test.grpc.fb.cc\n tests/test_assert.cpp\n tests/test_builder.cpp\n grpc/tests/grpctest.cpp\n grpc/tests/message_builder_test.cpp\n grpc/tests/grpctest_callback_compile.cpp\n grpc/tests/grpctest_callback_client_compile.cpp\n)\n\n# TODO(dbaileychess): Figure out how this would now work. I posted a question on\n# https://stackoverflow.com/questions/71772330/override-target-compile-options-via-cmake-command-line.\n# Append FLATBUFFERS_CXX_FLAGS to CMAKE_CXX_FLAGS.\nif(DEFINED FLATBUFFERS_CXX_FLAGS)\n message(STATUS \"extend CXX_FLAGS with ${FLATBUFFERS_CXX_FLAGS}\")\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} ${FLATBUFFERS_CXX_FLAGS}\")\nendif()\nmessage(STATUS \"CMAKE_CXX_FLAGS: ${CMAKE_CXX_FLAGS}\")\n\nfunction(add_fsanitize_to_target _target _sanitizer)\n if(WIN32)\n target_compile_definitions(${_target} PRIVATE FLATBUFFERS_MEMORY_LEAK_TRACKING)\n message(STATUS \"Sanitizer MSVC::_CrtDumpMemoryLeaks added to ${_target}\")\n else()\n # FLATBUFFERS_CODE_SANITIZE: boolean {ON,OFF,YES,NO} or string with list of sanitizer.\n # List of sanitizer is string starts with '=': \"=address,undefined,thread,memory\".\n if(IS_CLANG OR (CMAKE_COMPILER_IS_GNUCXX AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 4.9))\n set(_sanitizer_flags \"=address,undefined\")\n if(_sanitizer MATCHES \"=.*\")\n # override default by user-defined sanitizer list\n set(_sanitizer_flags ${_sanitizer})\n endif()\n target_compile_options(${_target} PRIVATE\n -g -fsigned-char -fno-omit-frame-pointer\n \"-fsanitize${_sanitizer_flags}\")\n target_link_libraries(${_target} PRIVATE\n \"-fsanitize${_sanitizer_flags}\")\n set_target_properties(${_target} PROPERTIES POSITION_INDEPENDENT_CODE ON)\n message(STATUS \"Sanitizer ${_sanitizer_flags} added to ${_target}\")\n endif()\n endif()\nendfunction()\n\nfunction(add_pch_to_target _target _pch_header)\n # the command is available since cmake 3.16\n if(COMMAND target_precompile_headers)\n target_precompile_headers(${_target} PRIVATE ${_pch_header})\n if(NOT MSVC)\n set_source_files_properties(src/util.cpp PROPERTIES SKIP_PRECOMPILE_HEADERS ON)\n endif()\n endif()\nendfunction()\n\ninclude_directories(include)\ninclude_directories(grpc)\n\n# Creates an interface library that stores the configuration settings that each\n# target links too. This is a compromise between setting configuration globally\n# with add_compile_options() and the more targetted target_compile_options().\n# This way each target in this file can share settings and override them if\n# needed.\nadd_library(ProjectConfig INTERFACE)\ntarget_compile_features(ProjectConfig\n INTERFACE\n cxx_std_${FLATBUFFERS_CPP_STD}\n)\n\n# Force the standard to be met.\nset(CMAKE_CXX_STANDARD_REQUIRED ON)\n\n# We shouldn't rely on any compiler-extensions to make things work.\nset(CMAKE_CXX_EXTENSIONS OFF)\n\nif(MSVC_LIKE)\n target_compile_options(ProjectConfig\n INTERFACE\n /W4\n $<$:\n /WX # Treat all compiler warnings as errors\n >\n /wd4512 # C4512: assignment operator could not be generated\n /wd4316 # C4316: object allocated on the heap may not be aligned\n /wd4456 # C4456: hides previous local declaration\n $<$:\n /D_CRT_SECURE_NO_WARNINGS\n >\n )\nelse()\n target_compile_options(ProjectConfig\n INTERFACE\n -Wall\n $<$:\n -Werror # Treat all compiler warnings as errors\n\n -fno-rtti # Disable runtime type information\n\n $<$:\n # False positive string overflow\n # https://github.com/google/flatbuffers/issues/7366\n -Wno-error=stringop-overflow\n >\n >\n -pedantic\n -Wextra\n -Wno-unused-parameter\n -Wold-style-cast\n -fsigned-char\n -Wnon-virtual-dtor\n\n # This isn't working for some reason: $<$:\n $<$:\n -Wnewline-eof\n -Wno-unknown-warning-option\n -Wmissing-declarations\n -Wzero-as-null-pointer-constant\n $<$,3.8>:\n -Wimplicit-fallthrough\n -Wextra-semi\n $<$:\n -Werror=unused-private-field\n >\n >\n >\n\n $<$:\n $<$,4.4>:\n -Wunused-result\n -Wunused-parameter\n -Werror=unused-parameter\n -Wmissing-declarations\n >\n $<$,4.7>:\n -Wzero-as-null-pointer-constant\n >\n $<$,7.0>:\n -faligned-new\n $<$:\n -Werror=implicit-fallthrough=2\n >\n >\n $<$,8.0>:\n -Wextra-semi\n >\n >\n\n $<$:\n -g\n -fprofile-arcs\n -ftest-coverage\n >\n )\n\n if(FLATBUFFERS_CODE_COVERAGE)\n target_link_options(ProjectConfig\n INTERFACE\n -fprofile-arcs\n -ftest-coverage\n )\n endif()\nendif()\n\nif(FLATBUFFERS_BUILD_FLATLIB)\n add_library(flatbuffers STATIC ${FlatBuffers_Library_SRCS})\n\n # Attach header directory for when build via add_subdirectory().\n target_include_directories(flatbuffers\n INTERFACE\n $\n )\n target_link_libraries(flatbuffers PRIVATE $)\n\n if(FLATBUFFERS_ENABLE_PCH)\n add_pch_to_target(flatbuffers include/flatbuffers/pch/pch.h)\n endif()\nendif()\n\nif(FLATBUFFERS_BUILD_FLATC)\n add_executable(flatc ${FlatBuffers_Compiler_SRCS})\n if(FLATBUFFERS_ENABLE_PCH)\n add_pch_to_target(flatc include/flatbuffers/pch/flatc_pch.h)\n endif()\n\n target_link_libraries(flatc PRIVATE $)\n target_compile_options(flatc\n PRIVATE\n $<$,$>:\n /MT\n >\n )\n\n if(FLATBUFFERS_CODE_SANITIZE AND NOT WIN32)\n add_fsanitize_to_target(flatc ${FLATBUFFERS_CODE_SANITIZE})\n endif()\n if(NOT FLATBUFFERS_FLATC_EXECUTABLE)\n set(FLATBUFFERS_FLATC_EXECUTABLE $)\n endif()\n if(FLATBUFFERS_STATIC_FLATC AND NOT MSVC)\n target_link_libraries(flatc PRIVATE -static)\n endif()\nendif()\n\nif(FLATBUFFERS_BUILD_FLATHASH)\n add_executable(flathash ${FlatHash_SRCS})\n target_link_libraries(flathash PRIVATE $)\nendif()\n\nif(FLATBUFFERS_BUILD_SHAREDLIB)\n add_library(flatbuffers_shared SHARED ${FlatBuffers_Library_SRCS})\n target_link_libraries(flatbuffers_shared PRIVATE $)\n # FlatBuffers use calendar-based versioning and do not provide any ABI\n # stability guarantees. Therefore, always use the full version as SOVERSION\n # in order to avoid breaking reverse dependencies on upgrades.\n set(FlatBuffers_Library_SONAME_FULL \"${PROJECT_VERSION}\")\n set_target_properties(flatbuffers_shared PROPERTIES\n OUTPUT_NAME flatbuffers\n SOVERSION \"${FlatBuffers_Library_SONAME_FULL}\"\n VERSION \"${FlatBuffers_Library_SONAME_FULL}\")\n if(FLATBUFFERS_ENABLE_PCH)\n add_pch_to_target(flatbuffers_shared include/flatbuffers/pch/pch.h)\n endif()\nendif()\n\nfunction(compile_schema SRC_FBS OPT SUFFIX OUT_GEN_FILE) \n get_filename_component(SRC_FBS_DIR ${SRC_FBS} PATH)\n string(REGEX REPLACE \"\\\\.fbs$\" \"${SUFFIX}.h\" GEN_HEADER ${SRC_FBS})\n add_custom_command(\n OUTPUT ${GEN_HEADER}\n COMMAND \"${FLATBUFFERS_FLATC_EXECUTABLE}\"\n ${OPT}\n --filename-suffix ${SUFFIX}\n -o \"${SRC_FBS_DIR}\"\n \"${CMAKE_CURRENT_SOURCE_DIR}/${SRC_FBS}\"\n DEPENDS flatc ${SRC_FBS}\n COMMENT \"flatc generation: `${SRC_FBS}` -> `${GEN_HEADER}`\"\n )\n set(${OUT_GEN_FILE} ${GEN_HEADER} PARENT_SCOPE)\nendfunction()\n\nfunction(compile_schema_for_test SRC_FBS OPT)\n compile_schema(\"${SRC_FBS}\" \"${OPT}\" \"_generated\" GEN_FILE)\n target_sources(flattests PRIVATE ${GEN_FILE})\nendfunction()\n\nfunction(compile_schema_for_test_fbsh SRC_FBS OPT)\n compile_schema(\"${SRC_FBS}\" \"${OPT}\" \".fbs\" GEN_FILE)\n target_sources(flattests PRIVATE ${GEN_FILE})\nendfunction()\n\nfunction(compile_schema_for_samples SRC_FBS OPT)\n compile_schema(\"${SRC_FBS}\" \"${OPT}\" \"_generated\" GEN_FILE)\n target_sources(flatsample PRIVATE ${GEN_FILE})\nendfunction()\n\nif(FLATBUFFERS_BUILD_TESTS)\n add_executable(flattests ${FlatBuffers_Tests_SRCS})\n target_link_libraries(flattests PRIVATE $)\n target_include_directories(flattests PUBLIC \n # Ideally everything is fully qualified from the root directories\n ${CMAKE_CURRENT_SOURCE_DIR}\n ${CMAKE_CURRENT_BINARY_DIR}\n # TODO(derekbailey): update includes to fully qualify src/ and tests/\n src \n tests \n ${CMAKE_CURRENT_BINARY_DIR}/tests \n )\n\n # Have tests load data from the source directory, not the build directory.\n add_definitions(-DFLATBUFFERS_TEST_PATH_PREFIX=${CMAKE_CURRENT_SOURCE_DIR}/)\n\n # The flattest target needs some generated files\n SET(FLATC_OPT_COMP --cpp --gen-compare --gen-mutable --gen-object-api --reflect-names)\n SET(FLATC_OPT_SCOPED_ENUMS ${FLATC_OPT_COMP};--scoped-enums)\n\n compile_schema_for_test(tests/alignment_test.fbs \"${FLATC_OPT_COMP}\")\n compile_schema_for_test_fbsh(tests/default_vectors_strings_test.fbs \"${FLATC_OPT_COMP}\")\n compile_schema_for_test(tests/arrays_test.fbs \"${FLATC_OPT_SCOPED_ENUMS}\")\n compile_schema_for_test(tests/native_inline_table_test.fbs \"${FLATC_OPT_COMP}\")\n compile_schema_for_test(tests/native_type_test.fbs \"${FLATC_OPT_COMP}\")\n compile_schema_for_test(tests/key_field/key_field_sample.fbs \"${FLATC_OPT_COMP}\")\n compile_schema_for_test(tests/64bit/test_64bit.fbs \"${FLATC_OPT_COMP};--bfbs-gen-embed\")\n compile_schema_for_test(tests/64bit/evolution/v1.fbs \"${FLATC_OPT_COMP}\")\n compile_schema_for_test(tests/64bit/evolution/v2.fbs \"${FLATC_OPT_COMP}\")\n compile_schema_for_test(tests/union_underlying_type_test.fbs \"${FLATC_OPT_SCOPED_ENUMS}\")\n compile_schema_for_test(tests/cross_namespace_pack_test.fbs \"${FLATC_OPT_COMP}\")\n\n if(FLATBUFFERS_CODE_SANITIZE)\n add_fsanitize_to_target(flattests ${FLATBUFFERS_CODE_SANITIZE})\n endif()\n \n include_directories(${CMAKE_CURRENT_BINARY_DIR}/samples)\n\n add_executable(flatsamplebinary ${FlatBuffers_Sample_Binary_SRCS})\n add_executable(flatsampletext ${FlatBuffers_Sample_Text_SRCS})\n add_executable(flatsamplebfbs ${FlatBuffers_Sample_BFBS_SRCS})\n\n # Add a library so there is a single target that the generated samples can \n # link too.\n if(MSVC OR ${CMAKE_VERSION} VERSION_GREATER_EQUAL \"3.20.0\")\n add_library(flatsample INTERFACE)\n else()\n add_library(flatsample STATIC)\n endif()\n\n # Since flatsample has no sources, we have to explicitly set the linker lang.\n set_target_properties(flatsample PROPERTIES LINKER_LANGUAGE CXX)\n\n target_link_libraries(flatsamplebinary PRIVATE $ flatsample)\n target_link_libraries(flatsampletext PRIVATE $ flatsample)\n target_link_libraries(flatsamplebfbs PRIVATE $ flatsample)\n\n if(FLATBUFFERS_BUILD_CPP17)\n add_executable(flattests_cpp17 ${FlatBuffers_Tests_CPP17_SRCS})\n target_link_libraries(flattests_cpp17 PRIVATE $)\n target_include_directories(flattests_cpp17 PUBLIC src tests)\n target_compile_features(flattests_cpp17 PRIVATE cxx_std_17) # requires cmake 3.8\n\n if(FLATBUFFERS_CODE_SANITIZE)\n add_fsanitize_to_target(flattests_cpp17 ${FLATBUFFERS_CODE_SANITIZE})\n endif()\n endif(FLATBUFFERS_BUILD_CPP17)\nendif()\n\nif(FLATBUFFERS_BUILD_GRPCTEST)\n if(NOT GRPC_INSTALL_PATH)\n message(SEND_ERROR \"GRPC_INSTALL_PATH variable is not defined. See grpc/README.md\")\n endif()\n if(NOT PROTOBUF_DOWNLOAD_PATH)\n message(SEND_ERROR \"PROTOBUF_DOWNLOAD_PATH variable is not defined. See grpc/README.md\")\n endif()\n INCLUDE_DIRECTORIES(${GRPC_INSTALL_PATH}/include)\n INCLUDE_DIRECTORIES(${PROTOBUF_DOWNLOAD_PATH}/src)\n find_package(Threads REQUIRED)\n list(APPEND CMAKE_PREFIX_PATH ${GRPC_INSTALL_PATH})\n find_package(absl CONFIG REQUIRED)\n find_package(protobuf CONFIG REQUIRED)\n find_package(gRPC CONFIG REQUIRED)\n add_executable(grpctest ${FlatBuffers_GRPCTest_SRCS})\n target_link_libraries(grpctest\n PRIVATE\n $\n gRPC::grpc++_unsecure\n gRPC::gpr\n pthread\n dl\n )\nendif()\n\nif(FLATBUFFERS_INSTALL)\n include(GNUInstallDirs)\n\n install(DIRECTORY include/flatbuffers DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})\n\n set(FB_CMAKE_DIR \"${CMAKE_INSTALL_LIBDIR}/cmake/flatbuffers\")\n\n configure_file(CMake/flatbuffers-config-version.cmake.in flatbuffers-config-version.cmake @ONLY)\n install(\n FILES\n \"CMake/flatbuffers-config.cmake\"\n \"CMake/BuildFlatBuffers.cmake\"\n \"${CMAKE_CURRENT_BINARY_DIR}/flatbuffers-config-version.cmake\"\n DESTINATION ${FB_CMAKE_DIR}\n )\n\n if(FLATBUFFERS_BUILD_FLATLIB)\n install(\n TARGETS flatbuffers EXPORT FlatBuffersTargets\n ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}\n INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}\n )\n\n install(EXPORT FlatBuffersTargets\n FILE FlatBuffersTargets.cmake\n NAMESPACE flatbuffers::\n DESTINATION ${FB_CMAKE_DIR}\n )\n endif()\n\n if(FLATBUFFERS_BUILD_FLATC)\n install(\n TARGETS flatc EXPORT FlatcTargets\n RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}\n )\n\n install(\n EXPORT FlatcTargets\n FILE FlatcTargets.cmake\n NAMESPACE flatbuffers::\n DESTINATION ${FB_CMAKE_DIR}\n )\n endif()\n\n if(FLATBUFFERS_BUILD_SHAREDLIB)\n install(\n TARGETS flatbuffers_shared EXPORT FlatBuffersSharedTargets\n ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}\n RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR}\n LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}\n INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}\n )\n\n install(\n EXPORT FlatBuffersSharedTargets\n FILE FlatBuffersSharedTargets.cmake\n NAMESPACE flatbuffers::\n DESTINATION ${FB_CMAKE_DIR}\n )\n endif()\n\n if(FLATBUFFERS_BUILD_SHAREDLIB OR FLATBUFFERS_BUILD_FLATLIB)\n configure_file(CMake/flatbuffers.pc.in flatbuffers.pc @ONLY)\n install(\n FILES \"${CMAKE_CURRENT_BINARY_DIR}/flatbuffers.pc\"\n DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig\n )\n endif()\nendif()\n\nif(FLATBUFFERS_BUILD_TESTS)\n enable_testing()\n\n add_test(NAME flattests COMMAND flattests)\n if(FLATBUFFERS_BUILD_CPP17)\n add_test(NAME flattests_cpp17 COMMAND flattests_cpp17)\n endif()\n if(FLATBUFFERS_BUILD_GRPCTEST)\n add_test(NAME grpctest COMMAND grpctest)\n endif()\nendif()\n\ninclude(CMake/BuildFlatBuffers.cmake)\n\nif(UNIX)\n # Use of CPack only supported on Linux systems.\n if(FLATBUFFERS_PACKAGE_DEBIAN)\n include(CMake/PackageDebian.cmake)\n include(CPack)\n endif()\n if (FLATBUFFERS_PACKAGE_REDHAT)\n include(CMake/PackageRedhat.cmake)\n include(CPack)\n endif()\nendif()\n\n# Include for running Google Benchmarks.\nif(FLATBUFFERS_BUILD_BENCHMARKS)\n add_subdirectory(benchmarks)\nendif()\n\n# Add FlatBuffers::FlatBuffers interface, needed for FetchContent_Declare\nadd_library(FlatBuffers INTERFACE)\nadd_library(FlatBuffers::FlatBuffers ALIAS FlatBuffers)\ntarget_include_directories(\n FlatBuffers\n INTERFACE $\n $)\n" }, { "path": "CONTRIBUTING.md", "content": "Contributing {#contributing}\n============\n\nWant to contribute? Great! First, read this page (including the small print at\nthe end).\n\n# Before you contribute\nBefore we can use your code, you must sign the\n[Google Individual Contributor License Agreement](https://developers.google.com/open-source/cla/individual?csw=1)\n(CLA), which you can do online. The CLA is necessary mainly because you own the\ncopyright to your changes, even after your contribution becomes part of our\ncodebase, so we need your permission to use and distribute your code. We also\nneed to be sure of various other things—for instance that you'll tell us if you\nknow that your code infringes on other people's patents. You don't have to sign\nthe CLA until after you've submitted your code for review and a member has\napproved it, but you must do it before we can put your code into our codebase.\nBefore you start working on a larger contribution, you should get in touch with\nus first through the issue tracker with your idea so that we can help out and\npossibly guide you. Coordinating up front makes it much easier to avoid\nfrustration later on.\n\n# Code reviews\nAll submissions, including submissions by project members, require review. We\nuse Github pull requests for this purpose.\n\nSome tips for good pull requests:\n* Use our code\n [style guide](https://google.github.io/styleguide/cppguide.html).\n When in doubt, try to stay true to the existing code of the project.\n* Write a descriptive commit message. What problem are you solving and what\n are the consequences? Where and what did you test? Some good tips:\n [here](http://robots.thoughtbot.com/5-useful-tips-for-a-better-commit-message)\n and [here](https://www.kernel.org/doc/Documentation/process/submitting-patches.rst).\n* If your PR consists of multiple commits which are successive improvements /\n fixes to your first commit, consider squashing them into a single commit\n (`git rebase -i`) such that your PR is a single commit on top of the current\n HEAD. This make reviewing the code so much easier, and our history more\n readable.\n\n# The small print\nContributions made by corporations are covered by a different agreement than\nthe one above, the Software Grant and Corporate Contributor License Agreement.\n\n# Code\n\nTL/DR\n\nSee [how to build flatc](https://flatbuffers.dev/building/).\n\nWhen making changes, build `flatc` and then re-generate the goldens files to see the effect of your changes:\n\n```\n$ cp build/flatc .\n$ goldens/generate_goldens.py\n```\n\nRe-generate other code files to see the effects of the changes:\n\n```\n$ scripts/generate_code.py\n```\n\nRun tests with [TestAll.sh](tests/TestAll.sh) in [tests](tests), or directly any of the sub-scripts run by it.\n\n[Format the code](Formatters.md) before submitting a PR.\n" }, { "path": "FlatBuffers.podspec", "content": "Pod::Spec.new do |s|\n s.name = 'FlatBuffers'\n s.version = '25.12.19'\n s.summary = 'FlatBuffers: Memory Efficient Serialization Library'\n\n s.description = \"FlatBuffers is a cross platform serialization library architected for\n maximum memory efficiency. It allows you to directly access serialized\n data without parsing/unpacking it first, while still having great \n forwards/backwards compatibility.\"\n\n s.homepage = 'https://github.com/google/flatbuffers'\n s.license = { :type => 'Apache2.0', :file => 'LICENSE' }\n s.author = { 'mustii' => 'me@mustiikhalil.se' }\n s.source = { :git => 'https://github.com/google/flatbuffers.git', :tag => \"v\" + s.version.to_s, :submodules => true }\n\n s.ios.deployment_target = '11.0'\n s.osx.deployment_target = '10.14'\n\n s.swift_version = '5.10'\n s.source_files = 'swift/Sources/Flatbuffers/*.swift'\n s.pod_target_xcconfig = {\n 'BUILD_LIBRARY_FOR_DISTRIBUTION' => 'YES'\n }\nend\n" }, { "path": "Formatters.md", "content": "# Format Guidelines\n\nIf 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.\n\n# Notes\n\n- Run the linter on the language you are working on before making a Pull Request.\n- DONT format/lint the generated code.\n\n# Languages\n\n## C++\n\nC++ uses `clang-format` as it's formatter. Run the following script `sh scripts/clang-format-git.sh`, and it should style the C++ code according to [google style guide](https://google.github.io/styleguide/cppguide.html).\n\n## Swift\n\nSwift 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\n\n## Typescript\n\nTypescript 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\n" }, { "path": "LICENSE", "content": "\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n" }, { "path": "MODULE.bazel", "content": "module(\n name = \"flatbuffers\",\n version = \"25.12.19\",\n compatibility_level = 1,\n repo_name = \"com_github_google_flatbuffers\",\n)\n\nbazel_dep(\n name = \"aspect_bazel_lib\",\n version = \"2.14.0\",\n)\nbazel_dep(\n name = \"aspect_rules_esbuild\",\n version = \"0.21.0\",\n)\nbazel_dep(\n name = \"aspect_rules_js\",\n version = \"2.3.8\",\n)\nbazel_dep(\n name = \"aspect_rules_ts\",\n version = \"3.6.0\",\n)\nbazel_dep(\n name = \"grpc\",\n version = \"1.76.0\",\n repo_name = \"com_github_grpc_grpc\",\n)\nbazel_dep(\n name = \"platforms\",\n version = \"0.0.11\",\n)\nbazel_dep(\n name = \"rules_cc\",\n version = \"0.1.1\",\n)\nbazel_dep(\n name = \"rules_go\",\n version = \"0.50.1\",\n repo_name = \"io_bazel_rules_go\",\n)\nbazel_dep(\n name = \"rules_nodejs\",\n version = \"6.3.3\",\n)\nbazel_dep(\n name = \"rules_shell\",\n version = \"0.3.0\",\n)\nbazel_dep(\n name = \"rules_swift\",\n version = \"3.1.2\",\n max_compatibility_level = 3,\n repo_name = \"build_bazel_rules_swift\",\n)\nbazel_dep(\n name = \"bazel_skylib\",\n version = \"1.7.1\",\n)\n\nnpm = use_extension(\"@aspect_rules_js//npm:extensions.bzl\", \"npm\")\nnpm.npm_translate_lock(\n name = \"flatbuffers_npm\",\n npmrc = \"//:.npmrc\",\n pnpm_lock = \"//ts:pnpm-lock.yaml\",\n verify_node_modules_ignored = \"//:.bazelignore\",\n)\nuse_repo(npm, \"flatbuffers_npm\")\n\nnode = use_extension(\"@rules_nodejs//nodejs:extensions.bzl\", \"node\")\nuse_repo(node, \"nodejs_linux_amd64\")\n\nrules_ts_ext = use_extension(\"@aspect_rules_ts//ts:extensions.bzl\", \"ext\", dev_dependency = True)\nrules_ts_ext.deps()\nuse_repo(rules_ts_ext, \"npm_typescript\")\n" }, { "path": "Package.swift", "content": "// swift-tools-version:5.10\n/*\n * Copyright 2020 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport PackageDescription\n\nlet package = Package(\n name: \"FlatBuffers\",\n platforms: [\n .iOS(.v12),\n .macOS(.v10_14),\n ],\n products: [\n .library(\n name: \"FlatBuffers\",\n targets: [\"FlatBuffers\"]),\n .library(\n name: \"FlexBuffers\",\n targets: [\"FlexBuffers\"]),\n ],\n dependencies: .dependencies,\n targets: [\n .target(\n name: \"FlatBuffers\",\n dependencies: [\"Common\"],\n path: \"swift/Sources/FlatBuffers\"),\n .target(\n name: \"FlexBuffers\",\n dependencies: [\"Common\"],\n path: \"swift/Sources/FlexBuffers\"),\n .target(\n name: \"Common\",\n path: \"swift/Sources/Common\"),\n .testTarget(\n name: \"FlatbuffersTests\",\n dependencies: .dependencies,\n path: \"tests/swift/Tests/Flatbuffers\"),\n .testTarget(\n name: \"FlexbuffersTests\",\n dependencies: [\"FlexBuffers\"],\n path: \"tests/swift/Tests/Flexbuffers\"),\n ])\n\nextension Array where Element == Package.Dependency {\n static var dependencies: [Package.Dependency] {\n #if os(Windows)\n []\n #else\n // Test only Dependency\n [.package(url: \"https://github.com/grpc/grpc-swift.git\", from: \"1.4.1\")]\n #endif\n }\n}\n\nextension Array where Element == PackageDescription.Target.Dependency {\n static var dependencies: [PackageDescription.Target.Dependency] {\n #if os(Windows)\n [\"FlatBuffers\"]\n #else\n // Test only Dependency\n [\n .product(name: \"GRPC\", package: \"grpc-swift\"),\n \"FlatBuffers\",\n ]\n #endif\n }\n}\n" }, { "path": "README.md", "content": "![logo](https://flatbuffers.dev/assets/flatbuffers_logo.svg) FlatBuffers\n===========\n\n![Build status](https://github.com/google/flatbuffers/actions/workflows/build.yml/badge.svg?branch=master)\n[![BuildKite status](https://badge.buildkite.com/7979d93bc6279aa539971f271253c65d5e8fe2fe43c90bbb25.svg)](https://buildkite.com/bazel/flatbuffers)\n[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/flatbuffers.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:flatbuffers)\n[![Discord Chat](https://img.shields.io/discord/656202785926152206.svg)](https:///discord.gg/6qgKs3R)\n[![Twitter Follow](https://img.shields.io/twitter/follow/wvo.svg?style=social)](https://twitter.com/wvo)\n[![Twitter Follow](https://img.shields.io/twitter/follow/dbaileychess.svg?style=social)](https://twitter.com/dbaileychess)\n\n\n**FlatBuffers** is a cross platform serialization library architected for\nmaximum memory efficiency. It allows you to directly access serialized data without parsing/unpacking it first, while still having great forwards/backwards compatibility.\n\n## Quick Start\n\n1. Build the compiler for flatbuffers (`flatc`)\n\n Use `cmake` to create the build files for your platform and then perform the compilation (Linux example).\n\n ```\n cmake -G \"Unix Makefiles\"\n make -j\n ```\n\n2. Define your flatbuffer schema (`.fbs`)\n\n Write the [schema](https://flatbuffers.dev/flatbuffers_guide_writing_schema.html) to define the data you want to serialize. See [monster.fbs](https://github.com/google/flatbuffers/blob/master/samples/monster.fbs) for an example.\n\n3. Generate code for your language(s)\n\n Use the `flatc` compiler to take your schema and generate language-specific code:\n\n ```\n ./flatc --cpp --rust monster.fbs\n ```\n\n Which generates `monster_generated.h` and `monster_generated.rs` files.\n\n4. Serialize data\n\n Use the generated code, as well as the `FlatBufferBuilder` to construct your serialized buffer. ([`C++` example](https://github.com/google/flatbuffers/blob/master/samples/sample_binary.cpp#L24-L56))\n\n5. Transmit/store/save Buffer\n\n Use your serialized buffer however you want. Send it to someone, save it for later, etc...\n\n6. Read the data\n\n Use the generated accessors to read the data from the serialized buffer.\n\n It doesn't need to be the same language/schema version, FlatBuffers ensures the data is readable across languages and schema versions. See the [`Rust` example](https://github.com/google/flatbuffers/blob/master/samples/sample_binary.rs#L92-L106) reading the data written by `C++`.\n\n## Documentation\n\n**Go to our [landing page][] to browse our documentation.**\n\n## Supported operating systems\n- Windows\n- macOS\n- Linux\n- Android\n- And any others with a recent C++ compiler (C++ 11 and newer)\n\n## Supported programming languages\n\nCode generation and runtime libraries for many popular languages.\n\n1. C\n1. C++ - [snapcraft.io](https://snapcraft.io/flatbuffers)\n1. C# - [nuget.org](https://www.nuget.org/packages/Google.FlatBuffers)\n1. Dart - [pub.dev](https://pub.dev/packages/flat_buffers)\n1. Go - [go.dev](https://pkg.go.dev/github.com/google/flatbuffers)\n1. Java - [Maven](https://search.maven.org/artifact/com.google.flatbuffers/flatbuffers-java)\n1. JavaScript - [NPM](https://www.npmjs.com/package/flatbuffers)\n1. Kotlin\n1. Lobster\n1. Lua\n1. PHP\n1. Python - [PyPI](https://pypi.org/project/flatbuffers/)\n1. Rust - [crates.io](https://crates.io/crates/flatbuffers)\n1. Swift - [swiftpackageindex](https://swiftpackageindex.com/google/flatbuffers)\n1. TypeScript - [NPM](https://www.npmjs.com/package/flatbuffers)\n1. Nim\n\n## Versioning\n\nFlatBuffers does not follow traditional SemVer versioning (see [rationale](https://github.com/google/flatbuffers/wiki/Versioning)) but rather uses a format of the date of the release.\n\n## Contribution\n\n* [FlatBuffers Issues Tracker][] to submit an issue.\n* [stackoverflow.com][] with [`flatbuffers` tag][] for any questions regarding FlatBuffers.\n\n*To contribute to this project,* see [CONTRIBUTING][].\n\n## Community\n\n* [Discord Server](https:///discord.gg/6qgKs3R)\n\n## Security\n\nPlease see our [Security Policy](SECURITY.md) for reporting vulnerabilities.\n\n## Licensing\n*Flatbuffers* is licensed under the Apache License, Version 2.0. See [LICENSE][] for the full license text.\n\n
\n\n [CONTRIBUTING]: http://github.com/google/flatbuffers/blob/master/CONTRIBUTING.md\n [`flatbuffers` tag]: https://stackoverflow.com/questions/tagged/flatbuffers\n [FlatBuffers Google Group]: https://groups.google.com/forum/#!forum/flatbuffers\n [FlatBuffers Issues Tracker]: http://github.com/google/flatbuffers/issues\n [stackoverflow.com]: http://stackoverflow.com/search?q=flatbuffers\n [landing page]: https://google.github.io/flatbuffers\n [LICENSE]: https://github.com/google/flatbuffers/blob/master/LICENSE\n" }, { "path": "SECURITY.md", "content": "# Security Policy\n\n## Reporting a Vulnerability\n\nTo report a security issue, please use http://g.co/vulnz. We use\nhttp://g.co/vulnz for our intake, and do coordination and disclosure here on\nGitHub (including using GitHub Security Advisory). The Google Security Team will\nrespond within 5 working days of your report on g.co/vulnz.\n\nSelect the `I want to report a technical security or an abuse risk related bug\nin a Google product (SQLi, XSS, etc.)` option and complete the form.\n" }, { "path": "android/AndroidManifest.xml", "content": "\n\n\n\n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n\n\n\n" }, { "path": "android/app/.gitignore", "content": "/build\n" }, { "path": "android/app/build.gradle", "content": "apply plugin: 'com.android.application'\napply plugin: 'kotlin-android'\n\nandroid {\n compileSdk 33\n\n defaultConfig {\n applicationId \"com.flatbuffers.app\"\n minSdkVersion 26\n targetSdkVersion 33\n versionCode 1\n versionName \"1.0\"\n\n compileOptions {\n sourceCompatibility JavaVersion.VERSION_1_8\n targetCompatibility JavaVersion.VERSION_1_8\n }\n\n sourceSets {\n main {\n java {\n srcDir '../../java/src/main/java/'\n }\n }\n }\n\n ndk {\n abiFilters 'arm64-v8a', 'armeabi-v7a'\n }\n \n testInstrumentationRunner \"androidx.test.runner.AndroidJUnitRunner\"\n externalNativeBuild {\n cmake {\n arguments \"-DFLATBUFFERS_SRC=${rootProject.projectDir}/..\"\n }\n }\n }\n\n buildTypes {\n release {\n minifyEnabled false\n proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'\n }\n }\n\n externalNativeBuild {\n cmake {\n path \"src/main/cpp/CMakeLists.txt\"\n }\n }\n\n task generateFbsCpp(type: Exec) {\n def inputDir = file(\"$projectDir/src/main/fbs\")\n def outputCppDir = file(\"$projectDir/src/main/cpp/generated/\")\n def fbsFiles = layout.files { file(inputDir).listFiles() }.filter { File f -> f.name.endsWith(\".fbs\") }.toList()\n ignoreExitValue(true)\n\n standardOutput = new ByteArrayOutputStream()\n errorOutput = new ByteArrayOutputStream()\n def commandLineArgs = ['flatc', '-o', outputCppDir, '--cpp']\n fbsFiles.forEach{\n commandLineArgs.add(it.path)\n }\n\n commandLine commandLineArgs\n\n doFirst {\n delete \"$outputCppDir/\"\n mkdir \"$outputCppDir/\"\n }\n\n doLast {\n if (executionResult.get().exitValue != 0) {\n throw new GradleException(\"flatc failed with: ${executionResult.get().toString()}\")\n }\n }\n }\n\n task generateFbsKotlin(type: Exec) {\n def inputDir = file(\"$projectDir/src/main/fbs\")\n def outputKotlinDir = file(\"$projectDir/src/main/java/generated/\")\n def fbsFiles = layout.files { file(inputDir).listFiles() }.filter { File f -> f.name.endsWith(\".fbs\") }.toList()\n ignoreExitValue(true)\n\n standardOutput = new ByteArrayOutputStream()\n errorOutput = new ByteArrayOutputStream()\n\n setErrorOutput(errorOutput)\n setStandardOutput(standardOutput)\n\n def commandLineArgs = ['flatc', '-o', outputKotlinDir, '--kotlin']\n fbsFiles.forEach{\n commandLineArgs.add(it.path)\n }\n commandLine commandLineArgs\n\n doFirst {\n delete \"$outputKotlinDir/\"\n mkdir \"$outputKotlinDir/\"\n }\n doLast {\n if (executionResult.get().exitValue != 0) {\n throw new GradleException(\"flatc failed with: ${executionResult.get().toString()}\")\n }\n }\n }\n\n afterEvaluate {\n tasks.named(\"preBuild\") {\n dependsOn(generateFbsKotlin)\n dependsOn(generateFbsCpp)\n }\n }\n namespace 'com.flatbuffers.app'\n}\n\ndependencies {\n implementation fileTree(dir: \"libs\", include: [\"*.jar\"])\n implementation \"org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version\"\n implementation 'androidx.appcompat:appcompat:1.6.1'\n\n // If you using java runtime you can add its dependency as the example below\n // implementation 'com.google.flatbuffers:flatbuffers-java:$latest_version'\n\n}\n" }, { "path": "android/app/src/main/AndroidManifest.xml", "content": "\n\n\n \n \n \n \n\n \n \n \n \n\n\n" }, { "path": "android/app/src/main/cpp/CMakeLists.txt", "content": "# For more information about using CMake with Android Studio, read the\n# documentation: https://d.android.com/studio/projects/add-native-code.html\n\n# Sets the minimum version of CMake required to build the native library.\n\ncmake_minimum_required(VERSION 3.4.1)\n\n# Creates and names a library, sets it as either STATIC\n# or SHARED, and provides the relative paths to its source code.\n# You can define multiple libraries, and CMake builds them for you.\n# Gradle automatically packages shared libraries with your APK.\n\ninclude_directories(${FLATBUFFERS_SRC}/include)\n\nadd_subdirectory(flatbuffers)\n\nFILE(GLOB Generated_SRCS generated/*.h)\n\nadd_library( # Sets the name of the library.\n native-lib\n\n # Sets the library as a shared library.\n SHARED\n\n # Provides a relative path to your source file(s).\n animals.cpp\n ${Generated_SRCS}\n\n)\n\n# Searches for a specified prebuilt library and stores the path as a\n# variable. Because CMake includes system libraries in the search path by\n# default, you only need to specify the name of the public NDK library\n# you want to add. CMake verifies that the library exists before\n# completing its build.\n\nfind_library( # Sets the name of the path variable.\n log-lib\n\n # Specifies the name of the NDK library that\n # you want CMake to locate.\n log )\n\n# Specifies libraries CMake should link to your target library. You\n# can link multiple libraries, such as libraries you define in this\n# build script, prebuilt third-party libraries, or system libraries.\n\ntarget_link_libraries( # Specifies the target library.\n native-lib\n flatbuffers\n # Links the target library to the log library\n # included in the NDK.\n ${log-lib} )\n" }, { "path": "android/app/src/main/cpp/animals.cpp", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n\n#include \n\n#include \"generated/animal_generated.h\"\n\nusing namespace com::fbs::app;\nusing namespace flatbuffers;\n\nextern \"C\" JNIEXPORT jbyteArray JNICALL\nJava_com_flatbuffers_app_MainActivity_createAnimalFromJNI(JNIEnv* env,\n jobject /* this */) {\n // create a new animal flatbuffers\n auto fb = FlatBufferBuilder(1024);\n auto tiger = CreateAnimalDirect(fb, \"Tiger\", \"Roar\", 300);\n fb.Finish(tiger);\n\n // copies it to a Java byte array.\n auto buf = reinterpret_cast(fb.GetBufferPointer());\n int size = fb.GetSize();\n auto ret = env->NewByteArray(size);\n env->SetByteArrayRegion(ret, 0, fb.GetSize(), buf);\n return ret;\n}\n" }, { "path": "android/app/src/main/cpp/flatbuffers/CMakeLists.txt", "content": "# For more information about using CMake with Android Studio, read the\n# documentation: https://d.android.com/studio/projects/add-native-code.html\n\n# Sets the minimum version of CMake required to build the native library.\n\ncmake_minimum_required(VERSION 3.4.1)\n\ninclude_directories(${FLATBUFFERS_SRC}/include)\n\nset(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -std=gnu++11 -fexceptions -Wall -DFLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE\")\n\n# Certain platforms such as ARM do not use signed chars by default\n# which causes issues with certain bounds checks.\nset(CMAKE_CXX_FLAGS\n \"${CMAKE_CXX_FLAGS} -fsigned-char\")\n\nset(FlatBuffers_Library_SRCS\n ${FLATBUFFERS_SRC}/include/flatbuffers/allocator.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/array.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/base.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/buffer.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/buffer_ref.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/default_allocator.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/detached_buffer.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/flatbuffer_builder.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/flatbuffers.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/flexbuffers.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/flex_flat_util.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/hash.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/idl.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/minireflect.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/reflection.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/reflection_generated.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/registry.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/stl_emulation.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/string.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/struct.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/table.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/util.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/vector.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/vector_downward.h\n ${FLATBUFFERS_SRC}/include/flatbuffers/verifier.h\n ${FLATBUFFERS_SRC}/src/idl_parser.cpp\n ${FLATBUFFERS_SRC}/src/idl_gen_text.cpp\n ${FLATBUFFERS_SRC}/src/reflection.cpp\n ${FLATBUFFERS_SRC}/src/util.cpp\n ${FLATBUFFERS_SRC}/src/idl_gen_fbs.cpp\n ${FLATBUFFERS_SRC}/src/code_generators.cpp\n )\n\nadd_library( # Sets the name of the library.\n flatbuffers\n\n ${FlatBuffers_Library_SRCS}\n ${Generated_SRCS}\n)\n" }, { "path": "android/app/src/main/cpp/generated/animal_generated.h", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n\n#ifndef FLATBUFFERS_GENERATED_ANIMAL_COM_FBS_APP_H_\n#define FLATBUFFERS_GENERATED_ANIMAL_COM_FBS_APP_H_\n\n#include \"flatbuffers/flatbuffers.h\"\n\n// Ensure the included flatbuffers.h is the same version as when this file was\n// generated, otherwise it may not be compatible.\nstatic_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&\n FLATBUFFERS_VERSION_MINOR == 12 &&\n FLATBUFFERS_VERSION_REVISION == 23,\n \"Non-compatible flatbuffers version included\");\n\nnamespace com {\nnamespace fbs {\nnamespace app {\n\nstruct Animal;\nstruct AnimalBuilder;\n\nstruct Animal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {\n typedef AnimalBuilder Builder;\n enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {\n VT_NAME = 4,\n VT_SOUND = 6,\n VT_WEIGHT = 8\n };\n const ::flatbuffers::String* name() const {\n return GetPointer(VT_NAME);\n }\n const ::flatbuffers::String* sound() const {\n return GetPointer(VT_SOUND);\n }\n uint16_t weight() const { return GetField(VT_WEIGHT, 0); }\n bool Verify(::flatbuffers::Verifier& verifier) const {\n return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NAME) &&\n verifier.VerifyString(name()) && VerifyOffset(verifier, VT_SOUND) &&\n verifier.VerifyString(sound()) &&\n VerifyField(verifier, VT_WEIGHT, 2) && verifier.EndTable();\n }\n};\n\nstruct AnimalBuilder {\n typedef Animal Table;\n ::flatbuffers::FlatBufferBuilder& fbb_;\n ::flatbuffers::uoffset_t start_;\n void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {\n fbb_.AddOffset(Animal::VT_NAME, name);\n }\n void add_sound(::flatbuffers::Offset<::flatbuffers::String> sound) {\n fbb_.AddOffset(Animal::VT_SOUND, sound);\n }\n void add_weight(uint16_t weight) {\n fbb_.AddElement(Animal::VT_WEIGHT, weight, 0);\n }\n explicit AnimalBuilder(::flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {\n start_ = fbb_.StartTable();\n }\n ::flatbuffers::Offset Finish() {\n const auto end = fbb_.EndTable(start_);\n auto o = ::flatbuffers::Offset(end);\n return o;\n }\n};\n\ninline ::flatbuffers::Offset CreateAnimal(\n ::flatbuffers::FlatBufferBuilder& _fbb,\n ::flatbuffers::Offset<::flatbuffers::String> name = 0,\n ::flatbuffers::Offset<::flatbuffers::String> sound = 0,\n uint16_t weight = 0) {\n AnimalBuilder builder_(_fbb);\n builder_.add_sound(sound);\n builder_.add_name(name);\n builder_.add_weight(weight);\n return builder_.Finish();\n}\n\ninline ::flatbuffers::Offset CreateAnimalDirect(\n ::flatbuffers::FlatBufferBuilder& _fbb, const char* name = nullptr,\n const char* sound = nullptr, uint16_t weight = 0) {\n auto name__ = name ? _fbb.CreateString(name) : 0;\n auto sound__ = sound ? _fbb.CreateString(sound) : 0;\n return com::fbs::app::CreateAnimal(_fbb, name__, sound__, weight);\n}\n\ninline const com::fbs::app::Animal* GetAnimal(const void* buf) {\n return ::flatbuffers::GetRoot(buf);\n}\n\ninline const com::fbs::app::Animal* GetSizePrefixedAnimal(const void* buf) {\n return ::flatbuffers::GetSizePrefixedRoot(buf);\n}\n\ninline bool VerifyAnimalBuffer(::flatbuffers::Verifier& verifier) {\n return verifier.VerifyBuffer(nullptr);\n}\n\ninline bool VerifySizePrefixedAnimalBuffer(::flatbuffers::Verifier& verifier) {\n return verifier.VerifySizePrefixedBuffer(nullptr);\n}\n\ninline void FinishAnimalBuffer(\n ::flatbuffers::FlatBufferBuilder& fbb,\n ::flatbuffers::Offset root) {\n fbb.Finish(root);\n}\n\ninline void FinishSizePrefixedAnimalBuffer(\n ::flatbuffers::FlatBufferBuilder& fbb,\n ::flatbuffers::Offset root) {\n fbb.FinishSizePrefixed(root);\n}\n\n} // namespace app\n} // namespace fbs\n} // namespace com\n\n#endif // FLATBUFFERS_GENERATED_ANIMAL_COM_FBS_APP_H_\n" }, { "path": "android/app/src/main/fbs/animal.fbs", "content": "// Copyright 2015 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nnamespace com.fbs.app;\n\ntable Animal {\n name:string;\n sound:string;\n weight: uint16;\n}\n\nroot_type Animal;\n" }, { "path": "android/app/src/main/java/com/flatbuffers/app/MainActivity.kt", "content": "package com.flatbuffers.app\n\nimport android.annotation.SuppressLint\nimport android.os.Bundle\nimport android.widget.TextView\nimport androidx.appcompat.app.AppCompatActivity\nimport com.fbs.app.Animal\nimport com.google.flatbuffers.FlatBufferBuilder\nimport java.nio.ByteBuffer\n\n@ExperimentalUnsignedTypes\nclass MainActivity : AppCompatActivity() {\n\n @SuppressLint(\"SetTextI18n\")\n override fun onCreate(savedInstanceState: Bundle?) {\n super.onCreate(savedInstanceState)\n setContentView(R.layout.activity_main)\n\n val tiger = Animal.getRootAsAnimal(ByteBuffer.wrap(createAnimalFromJNI()))\n findViewById(R.id.tv_animal_one).text = animalInfo(tiger)\n\n findViewById(R.id.tv_animal_two).text = animalInfo(createAnimalFromKotlin())\n }\n\n // This function is a sample of communicating FlatBuffers between JNI (native C++) and Java.\n // Implementation can be found on animals.cpp file.\n private external fun createAnimalFromJNI(): ByteArray\n\n // Create a \"Cow\" Animal flatbuffers from Kotlin\n private fun createAnimalFromKotlin(): Animal {\n val fb = FlatBufferBuilder(100)\n val cowOffset =\n Animal.createAnimal(\n builder = fb,\n nameOffset = fb.createString(\"Cow\"),\n soundOffset = fb.createString(\"Moo\"),\n weight = 720u,\n )\n fb.finish(cowOffset)\n return Animal.getRootAsAnimal(fb.dataBuffer())\n }\n\n private fun animalInfo(animal: Animal): String =\n \"The ${animal.name} sound is ${animal.sound} and it weights ${animal.weight}kg.\"\n\n companion object {\n // Used to load the 'native-lib' library on application startup.\n init {\n System.loadLibrary(\"native-lib\")\n }\n }\n}\n" }, { "path": "android/app/src/main/java/generated/com/fbs/app/Animal.kt", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n\npackage com.fbs.app\n\nimport com.google.flatbuffers.Constants\nimport com.google.flatbuffers.FlatBufferBuilder\nimport com.google.flatbuffers.Table\nimport java.nio.ByteBuffer\nimport java.nio.ByteOrder\n\n@Suppress(\"unused\")\n@kotlin.ExperimentalUnsignedTypes\nclass Animal : Table() {\n\n fun __init(_i: Int, _bb: ByteBuffer) {\n __reset(_i, _bb)\n }\n\n fun __assign(_i: Int, _bb: ByteBuffer): Animal {\n __init(_i, _bb)\n return this\n }\n\n val name: String?\n get() {\n val o = __offset(4)\n return if (o != 0) {\n __string(o + bb_pos)\n } else {\n null\n }\n }\n\n val nameAsByteBuffer: ByteBuffer\n get() = __vector_as_bytebuffer(4, 1)\n\n fun nameInByteBuffer(_bb: ByteBuffer): ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1)\n\n val sound: String?\n get() {\n val o = __offset(6)\n return if (o != 0) {\n __string(o + bb_pos)\n } else {\n null\n }\n }\n\n val soundAsByteBuffer: ByteBuffer\n get() = __vector_as_bytebuffer(6, 1)\n\n fun soundInByteBuffer(_bb: ByteBuffer): ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1)\n\n val weight: UShort\n get() {\n val o = __offset(8)\n return if (o != 0) bb.getShort(o + bb_pos).toUShort() else 0u\n }\n\n companion object {\n fun validateVersion() = Constants.FLATBUFFERS_25_12_19()\n\n fun getRootAsAnimal(_bb: ByteBuffer): Animal = getRootAsAnimal(_bb, Animal())\n\n fun getRootAsAnimal(_bb: ByteBuffer, obj: Animal): Animal {\n _bb.order(ByteOrder.LITTLE_ENDIAN)\n return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))\n }\n\n fun createAnimal(\n builder: FlatBufferBuilder,\n nameOffset: Int,\n soundOffset: Int,\n weight: UShort,\n ): Int {\n builder.startTable(3)\n addSound(builder, soundOffset)\n addName(builder, nameOffset)\n addWeight(builder, weight)\n return endAnimal(builder)\n }\n\n fun startAnimal(builder: FlatBufferBuilder) = builder.startTable(3)\n\n fun addName(builder: FlatBufferBuilder, name: Int) = builder.addOffset(0, name, 0)\n\n fun addSound(builder: FlatBufferBuilder, sound: Int) = builder.addOffset(1, sound, 0)\n\n fun addWeight(builder: FlatBufferBuilder, weight: UShort) =\n builder.addShort(2, weight.toShort(), 0)\n\n fun endAnimal(builder: FlatBufferBuilder): Int {\n val o = builder.endTable()\n return o\n }\n\n fun finishAnimalBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finish(offset)\n\n fun finishSizePrefixedAnimalBuffer(builder: FlatBufferBuilder, offset: Int) =\n builder.finishSizePrefixed(offset)\n }\n}\n" }, { "path": "android/app/src/main/res/drawable/ic_launcher_background.xml", "content": "\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n" }, { "path": "android/app/src/main/res/drawable-v24/ic_launcher_foreground.xml", "content": "\n \n \n \n \n \n \n \n \n \n\n" }, { "path": "android/app/src/main/res/layout/activity_main.xml", "content": "\n\n\n \n\n \n\n\n" }, { "path": "android/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml", "content": "\n\n \n \n\n" }, { "path": "android/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml", "content": "\n\n \n \n\n" }, { "path": "android/app/src/main/res/values/colors.xml", "content": "\n\n #6200EE\n #3700B3\n #03DAC5\n\n" }, { "path": "android/app/src/main/res/values/strings.xml", "content": "\n FlatbuffersTestApp\n\n" }, { "path": "android/app/src/main/res/values/styles.xml", "content": "\n \n \n\n\n" }, { "path": "android/build.gradle", "content": "// Top-level build file where you can add configuration options common to all sub-projects/modules.\nbuildscript {\n ext.kotlin_version = \"1.7.21\"\n repositories {\n google()\n mavenCentral()\n }\n dependencies {\n classpath 'com.android.tools.build:gradle:7.4.1'\n classpath \"org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version\"\n\n // NOTE: Do not place your application dependencies here; they belong\n // in the individual module build.gradle files\n }\n}\n\nallprojects {\n repositories {\n google()\n mavenCentral()\n }\n}\n\ntasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {\n sourceCompatibility = JavaVersion.VERSION_1_8\n targetCompatibility = JavaVersion.VERSION_1_8\n\n compileKotlin {\n dependsOn flatbuffer\n }\n}\n\ntask clean(type: Delete) {\n delete rootProject.buildDir\n}\n" }, { "path": "android/gradle/wrapper/gradle-wrapper.properties", "content": "distributionBase=GRADLE_USER_HOME\ndistributionPath=wrapper/dists\ndistributionUrl=https\\://services.gradle.org/distributions/gradle-8.0.1-bin.zip\nzipStoreBase=GRADLE_USER_HOME\nzipStorePath=wrapper/dists\n" }, { "path": "android/gradle.properties", "content": "# Project-wide Gradle settings.\n# IDE (e.g. Android Studio) users:\n# Gradle settings configured through the IDE *will override*\n# any settings specified in this file.\n# For more details on how to configure your build environment visit\n# http://www.gradle.org/docs/current/userguide/build_environment.html\n# Specifies the JVM arguments used for the daemon process.\n# The setting is particularly useful for tweaking memory settings.\norg.gradle.jvmargs=-Xmx2048m\n# When configured, Gradle will run in incubating parallel mode.\n# This option should only be used with decoupled projects. More details, visit\n# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects\n# org.gradle.parallel=true\n# AndroidX package structure to make it clearer which packages are bundled with the\n# Android operating system, and which are packaged with your app\"s APK\n# https://developer.android.com/topic/libraries/support-library/androidx-rn\nandroid.useAndroidX=true\n# Automatically convert third-party libraries to use AndroidX\nandroid.enableJetifier=true\n# Kotlin code style for this project: \"official\" or \"obsolete\":\nkotlin.code.style=official\n# Use parallel builds\norg.gradle.parallel=true" }, { "path": "android/gradlew", "content": "#!/usr/bin/env sh\n\n##############################################################################\n##\n## Gradle start up script for UN*X\n##\n##############################################################################\n\n# Attempt to set APP_HOME\n# Resolve links: $0 may be a link\nPRG=\"$0\"\n# Need this for relative symlinks.\nwhile [ -h \"$PRG\" ] ; do\n ls=`ls -ld \"$PRG\"`\n link=`expr \"$ls\" : '.*-> \\(.*\\)$'`\n if expr \"$link\" : '/.*' > /dev/null; then\n PRG=\"$link\"\n else\n PRG=`dirname \"$PRG\"`\"/$link\"\n fi\ndone\nSAVED=\"`pwd`\"\ncd \"`dirname \\\"$PRG\\\"`/\" >/dev/null\nAPP_HOME=\"`pwd -P`\"\ncd \"$SAVED\" >/dev/null\n\nAPP_NAME=\"Gradle\"\nAPP_BASE_NAME=`basename \"$0\"`\n\n# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.\nDEFAULT_JVM_OPTS=\"\"\n\n# Use the maximum available, or set MAX_FD != -1 to use that value.\nMAX_FD=\"maximum\"\n\nwarn () {\n echo \"$*\"\n}\n\ndie () {\n echo\n echo \"$*\"\n echo\n exit 1\n}\n\n# OS specific support (must be 'true' or 'false').\ncygwin=false\nmsys=false\ndarwin=false\nnonstop=false\ncase \"`uname`\" in\n CYGWIN* )\n cygwin=true\n ;;\n Darwin* )\n darwin=true\n ;;\n MINGW* )\n msys=true\n ;;\n NONSTOP* )\n nonstop=true\n ;;\nesac\n\nCLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar\n\n# Determine the Java command to use to start the JVM.\nif [ -n \"$JAVA_HOME\" ] ; then\n if [ -x \"$JAVA_HOME/jre/sh/java\" ] ; then\n # IBM's JDK on AIX uses strange locations for the executables\n JAVACMD=\"$JAVA_HOME/jre/sh/java\"\n else\n JAVACMD=\"$JAVA_HOME/bin/java\"\n fi\n if [ ! -x \"$JAVACMD\" ] ; then\n die \"ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME\n\nPlease set the JAVA_HOME variable in your environment to match the\nlocation of your Java installation.\"\n fi\nelse\n JAVACMD=\"java\"\n which java >/dev/null 2>&1 || die \"ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.\n\nPlease set the JAVA_HOME variable in your environment to match the\nlocation of your Java installation.\"\nfi\n\n# Increase the maximum file descriptors if we can.\nif [ \"$cygwin\" = \"false\" -a \"$darwin\" = \"false\" -a \"$nonstop\" = \"false\" ] ; then\n MAX_FD_LIMIT=`ulimit -H -n`\n if [ $? -eq 0 ] ; then\n if [ \"$MAX_FD\" = \"maximum\" -o \"$MAX_FD\" = \"max\" ] ; then\n MAX_FD=\"$MAX_FD_LIMIT\"\n fi\n ulimit -n $MAX_FD\n if [ $? -ne 0 ] ; then\n warn \"Could not set maximum file descriptor limit: $MAX_FD\"\n fi\n else\n warn \"Could not query maximum file descriptor limit: $MAX_FD_LIMIT\"\n fi\nfi\n\n# For Darwin, add options to specify how the application appears in the dock\nif $darwin; then\n GRADLE_OPTS=\"$GRADLE_OPTS \\\"-Xdock:name=$APP_NAME\\\" \\\"-Xdock:icon=$APP_HOME/media/gradle.icns\\\"\"\nfi\n\n# For Cygwin, switch paths to Windows format before running java\nif $cygwin ; then\n APP_HOME=`cygpath --path --mixed \"$APP_HOME\"`\n CLASSPATH=`cygpath --path --mixed \"$CLASSPATH\"`\n JAVACMD=`cygpath --unix \"$JAVACMD\"`\n\n # We build the pattern for arguments to be converted via cygpath\n ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`\n SEP=\"\"\n for dir in $ROOTDIRSRAW ; do\n ROOTDIRS=\"$ROOTDIRS$SEP$dir\"\n SEP=\"|\"\n done\n OURCYGPATTERN=\"(^($ROOTDIRS))\"\n # Add a user-defined pattern to the cygpath arguments\n if [ \"$GRADLE_CYGPATTERN\" != \"\" ] ; then\n OURCYGPATTERN=\"$OURCYGPATTERN|($GRADLE_CYGPATTERN)\"\n fi\n # Now convert the arguments - kludge to limit ourselves to /bin/sh\n i=0\n for arg in \"$@\" ; do\n CHECK=`echo \"$arg\"|egrep -c \"$OURCYGPATTERN\" -`\n CHECK2=`echo \"$arg\"|egrep -c \"^-\"` ### Determine if an option\n\n if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition\n eval `echo args$i`=`cygpath --path --ignore --mixed \"$arg\"`\n else\n eval `echo args$i`=\"\\\"$arg\\\"\"\n fi\n i=$((i+1))\n done\n case $i in\n (0) set -- ;;\n (1) set -- \"$args0\" ;;\n (2) set -- \"$args0\" \"$args1\" ;;\n (3) set -- \"$args0\" \"$args1\" \"$args2\" ;;\n (4) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" ;;\n (5) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" ;;\n (6) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" ;;\n (7) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" ;;\n (8) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" \"$args7\" ;;\n (9) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" \"$args7\" \"$args8\" ;;\n esac\nfi\n\n# Escape application args\nsave () {\n for i do printf %s\\\\n \"$i\" | sed \"s/'/'\\\\\\\\''/g;1s/^/'/;\\$s/\\$/' \\\\\\\\/\" ; done\n echo \" \"\n}\nAPP_ARGS=$(save \"$@\")\n\n# Collect all arguments for the java command, following the shell quoting and substitution rules\neval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS \"\\\"-Dorg.gradle.appname=$APP_BASE_NAME\\\"\" -classpath \"\\\"$CLASSPATH\\\"\" org.gradle.wrapper.GradleWrapperMain \"$APP_ARGS\"\n\n# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong\nif [ \"$(uname)\" = \"Darwin\" ] && [ \"$HOME\" = \"$PWD\" ]; then\n cd \"$(dirname \"$0\")\"\nfi\n\nexec \"$JAVACMD\" \"$@\"\n" }, { "path": "android/gradlew.bat", "content": "@if \"%DEBUG%\" == \"\" @echo off\n@rem ##########################################################################\n@rem\n@rem Gradle startup script for Windows\n@rem\n@rem ##########################################################################\n\n@rem Set local scope for the variables with windows NT shell\nif \"%OS%\"==\"Windows_NT\" setlocal\n\nset DIRNAME=%~dp0\nif \"%DIRNAME%\" == \"\" set DIRNAME=.\nset APP_BASE_NAME=%~n0\nset APP_HOME=%DIRNAME%\n\n@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.\nset DEFAULT_JVM_OPTS=\n\n@rem Find java.exe\nif defined JAVA_HOME goto findJavaFromJavaHome\n\nset JAVA_EXE=java.exe\n%JAVA_EXE% -version >NUL 2>&1\nif \"%ERRORLEVEL%\" == \"0\" goto init\n\necho.\necho ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.\necho.\necho Please set the JAVA_HOME variable in your environment to match the\necho location of your Java installation.\n\ngoto fail\n\n:findJavaFromJavaHome\nset JAVA_HOME=%JAVA_HOME:\"=%\nset JAVA_EXE=%JAVA_HOME%/bin/java.exe\n\nif exist \"%JAVA_EXE%\" goto init\n\necho.\necho ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%\necho.\necho Please set the JAVA_HOME variable in your environment to match the\necho location of your Java installation.\n\ngoto fail\n\n:init\n@rem Get command-line arguments, handling Windows variants\n\nif not \"%OS%\" == \"Windows_NT\" goto win9xME_args\n\n:win9xME_args\n@rem Slurp the command line arguments.\nset CMD_LINE_ARGS=\nset _SKIP=2\n\n:win9xME_args_slurp\nif \"x%~1\" == \"x\" goto execute\n\nset CMD_LINE_ARGS=%*\n\n:execute\n@rem Setup the command line\n\nset CLASSPATH=%APP_HOME%\\gradle\\wrapper\\gradle-wrapper.jar\n\n@rem Execute Gradle\n\"%JAVA_EXE%\" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% \"-Dorg.gradle.appname=%APP_BASE_NAME%\" -classpath \"%CLASSPATH%\" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%\n\n:end\n@rem End local scope for the variables with windows NT shell\nif \"%ERRORLEVEL%\"==\"0\" goto mainEnd\n\n:fail\nrem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of\nrem the _cmd.exe /c_ return code!\nif not \"\" == \"%GRADLE_EXIT_CONSOLE%\" exit 1\nexit /b 1\n\n:mainEnd\nif \"%OS%\"==\"Windows_NT\" endlocal\n\n:omega\n" }, { "path": "android/settings.gradle", "content": "include ':app'\nrootProject.name = \"FlatbuffersTest\"\n" }, { "path": "bazel/BUILD.bazel", "content": "" }, { "path": "benchmarks/CMakeLists.txt", "content": "# Setup for running Google Benchmarks (https://github.com/google/benchmark) on\n# flatbuffers. This requires both that benchmark library and its dependency gtest\n# to build. Instead of including them here or doing a submodule, this uses\n# FetchContent (https://cmake.org/cmake/help/latest/module/FetchContent.html) to\n# grab the dependencies at config time. This requires CMake 3.14 or higher.\n\ncmake_minimum_required(VERSION 3.14)\ninclude(FetchContent)\n\n# No particular reason for the specific GIT_TAGs for the following repos, they\n# were just the latest releases when this was added.\nFetchContent_Declare(\n googletest\n GIT_REPOSITORY https://github.com/google/googletest.git\n GIT_TAG e2239ee6043f73722e7aa812a459f54a28552929 # release-1.11.0\n)\nFetchContent_Declare(\n googlebenchmark\n GIT_REPOSITORY https://github.com/google/benchmark.git\n GIT_TAG 0d98dba29d66e93259db7daa53a9327df767a415 # v1.6.1\n)\n\n# For Windows: Prevent overriding the parent project's compiler/linker \n# settings.\nset(gtest_force_shared_crt ON CACHE BOOL \"\" FORCE)\nFetchContent_MakeAvailable(\n googletest\n googlebenchmark\n)\n\nset(CPP_BENCH_DIR ${CMAKE_CURRENT_SOURCE_DIR}/cpp)\nset(CPP_FB_BENCH_DIR ${CPP_BENCH_DIR}/flatbuffers)\nset(CPP_RAW_BENCH_DIR ${CPP_BENCH_DIR}/raw)\nset(CPP_BENCH_FBS ${CPP_FB_BENCH_DIR}/bench.fbs)\nset(CPP_BENCH_FB_GEN ${CPP_FB_BENCH_DIR}/bench_generated.h)\n\nset(FlatBenchmark_SRCS\n ${CPP_BENCH_DIR}/benchmark_main.cpp\n ${CPP_FB_BENCH_DIR}/fb_bench.cpp\n ${CPP_RAW_BENCH_DIR}/raw_bench.cpp\n ${CPP_BENCH_FB_GEN}\n)\n\n# Generate the flatbuffers benchmark code from the flatbuffers schema using\n# flatc itself, thus it depends on flatc. This also depends on the C++ runtime\n# flatbuffers and the schema file itself, so it should auto-generated at the\n# correct times.\nadd_custom_command(\n OUTPUT ${CPP_BENCH_FB_GEN}\n COMMAND \n \"${FLATBUFFERS_FLATC_EXECUTABLE}\"\n --cpp\n -o ${CPP_FB_BENCH_DIR}\n ${CPP_BENCH_FBS}\n DEPENDS \n flatc\n flatbuffers\n ${CPP_BENCH_FBS}\n COMMENT \"Run Flatbuffers Benchmark Codegen: ${CPP_BENCH_FB_GEN}\"\n VERBATIM)\n\n# The main flatbuffers benchmark executable\nadd_executable(flatbenchmark ${FlatBenchmark_SRCS})\n\n# Benchmark requires C++11 \ntarget_compile_features(flatbenchmark PRIVATE\n cxx_std_11 # requires cmake 3.8\n)\n\ntarget_compile_options(flatbenchmark\n PRIVATE\n -fno-aligned-new\n -Wno-deprecated-declarations\n)\n\n# Set the output directory to the root binary directory\nset_target_properties(flatbenchmark \n PROPERTIES RUNTIME_OUTPUT_DIRECTORY \n \"${CMAKE_BINARY_DIR}\"\n)\n\n# The includes of the benchmark files are fully qualified from flatbuffers root.\ntarget_include_directories(flatbenchmark PUBLIC ${CMAKE_SOURCE_DIR})\n\ntarget_link_libraries(flatbenchmark PRIVATE\n benchmark::benchmark_main # _main to use their entry point \n gtest # Link to gtest so we can also assert in the benchmarks\n)" }, { "path": "benchmarks/cpp/bench.h", "content": "#ifndef BENCHMARKS_CPP_BENCH_H_\n#define BENCHMARKS_CPP_BENCH_H_\n\n#include \n\nstruct Bench {\n virtual ~Bench() {}\n\n inline void Add(int64_t value) { sum += value; }\n\n virtual uint8_t* Encode(void* buf, int64_t& len) = 0;\n virtual void* Decode(void* buf, int64_t len) = 0;\n virtual int64_t Use(void* decoded) = 0;\n virtual void Dealloc(void* decoded) = 0;\n\n int64_t sum = 0;\n};\n\n#endif // BENCHMARKS_CPP_BENCH_H_" }, { "path": "benchmarks/cpp/benchmark_main.cpp", "content": "#include \n#include \n\n#include \"benchmarks/cpp/bench.h\"\n#include \"benchmarks/cpp/flatbuffers/fb_bench.h\"\n#include \"benchmarks/cpp/raw/raw_bench.h\"\n\nstatic inline void Encode(benchmark::State& state,\n std::unique_ptr& bench, uint8_t* buffer) {\n int64_t length;\n for (auto _ : state) {\n bench->Encode(buffer, length);\n benchmark::DoNotOptimize(length);\n }\n}\n\nstatic inline void Decode(benchmark::State& state,\n std::unique_ptr& bench, uint8_t* buffer) {\n int64_t length;\n uint8_t* encoded = bench->Encode(buffer, length);\n\n for (auto _ : state) {\n void* decoded = bench->Decode(encoded, length);\n benchmark::DoNotOptimize(decoded);\n }\n}\n\nstatic inline void Use(benchmark::State& state, std::unique_ptr& bench,\n uint8_t* buffer, int64_t check_sum) {\n int64_t length;\n uint8_t* encoded = bench->Encode(buffer, length);\n void* decoded = bench->Decode(encoded, length);\n\n int64_t sum = 0;\n\n for (auto _ : state) {\n sum = bench->Use(decoded);\n }\n\n EXPECT_EQ(sum, check_sum);\n}\n\nstatic void BM_Flatbuffers_Encode(benchmark::State& state) {\n const int64_t kBufferLength = 1024;\n uint8_t buffer[kBufferLength];\n\n StaticAllocator allocator(&buffer[0]);\n std::unique_ptr bench = NewFlatBuffersBench(kBufferLength, &allocator);\n Encode(state, bench, buffer);\n}\nBENCHMARK(BM_Flatbuffers_Encode);\n\nstatic void BM_Flatbuffers_Decode(benchmark::State& state) {\n const int64_t kBufferLength = 1024;\n uint8_t buffer[kBufferLength];\n\n StaticAllocator allocator(&buffer[0]);\n std::unique_ptr bench = NewFlatBuffersBench(kBufferLength, &allocator);\n Decode(state, bench, buffer);\n}\nBENCHMARK(BM_Flatbuffers_Decode);\n\nstatic void BM_Flatbuffers_Use(benchmark::State& state) {\n const int64_t kBufferLength = 1024;\n uint8_t buffer[kBufferLength];\n\n StaticAllocator allocator(&buffer[0]);\n std::unique_ptr bench = NewFlatBuffersBench(kBufferLength, &allocator);\n Use(state, bench, buffer, 218812692406581874);\n}\nBENCHMARK(BM_Flatbuffers_Use);\n\nstatic void BM_Raw_Encode(benchmark::State& state) {\n const int64_t kBufferLength = 1024;\n uint8_t buffer[kBufferLength];\n\n std::unique_ptr bench = NewRawBench();\n Encode(state, bench, buffer);\n}\nBENCHMARK(BM_Raw_Encode);\n\nstatic void BM_Raw_Decode(benchmark::State& state) {\n const int64_t kBufferLength = 1024;\n uint8_t buffer[kBufferLength];\n\n std::unique_ptr bench = NewRawBench();\n Decode(state, bench, buffer);\n}\nBENCHMARK(BM_Raw_Decode);\n\nstatic void BM_Raw_Use(benchmark::State& state) {\n const int64_t kBufferLength = 1024;\n uint8_t buffer[kBufferLength];\n\n std::unique_ptr bench = NewRawBench();\n Use(state, bench, buffer, 218812692406581874);\n}\nBENCHMARK(BM_Raw_Use);\n" }, { "path": "benchmarks/cpp/flatbuffers/bench.fbs", "content": "// Copyright 2021 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n\n// trying to represent a typical mix of datatypes:\n// 1 array of 3 elements, each element: 1 string, 3 nested objects, 9 scalars\n// root element has the array, additional string and an enum\n\nnamespace benchmarks_flatbuffers;\n\nenum Enum : short { Apples, Pears, Bananas}\n\nstruct Foo {\n id:ulong;\n count:short;\n prefix:byte;\n length:uint;\n}\n\nstruct Bar {\n parent:Foo;\n time:int;\n ratio:float;\n size:ushort;\n}\n\ntable FooBar {\n sibling:Bar;\n name:string;\n rating:double;\n postfix:ubyte;\n}\n\ntable FooBarContainer {\n list:[FooBar]; // 3 copies of the above\n initialized:bool;\n fruit:Enum;\n location:string;\n}\n\nroot_type FooBarContainer;\n" }, { "path": "benchmarks/cpp/flatbuffers/bench_generated.h", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n\n#ifndef FLATBUFFERS_GENERATED_BENCH_BENCHMARKS_FLATBUFFERS_H_\n#define FLATBUFFERS_GENERATED_BENCH_BENCHMARKS_FLATBUFFERS_H_\n\n#include \"flatbuffers/flatbuffers.h\"\n\n// Ensure the included flatbuffers.h is the same version as when this file was\n// generated, otherwise it may not be compatible.\nstatic_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&\n FLATBUFFERS_VERSION_MINOR == 12 &&\n FLATBUFFERS_VERSION_REVISION == 23,\n \"Non-compatible flatbuffers version included\");\n\nnamespace benchmarks_flatbuffers {\n\nstruct Foo;\n\nstruct Bar;\n\nstruct FooBar;\nstruct FooBarBuilder;\n\nstruct FooBarContainer;\nstruct FooBarContainerBuilder;\n\nenum Enum : int16_t {\n Enum_Apples = 0,\n Enum_Pears = 1,\n Enum_Bananas = 2,\n Enum_MIN = Enum_Apples,\n Enum_MAX = Enum_Bananas\n};\n\ninline const Enum (&EnumValuesEnum())[3] {\n static const Enum values[] = {Enum_Apples, Enum_Pears, Enum_Bananas};\n return values;\n}\n\ninline const char* const* EnumNamesEnum() {\n static const char* const names[4] = {\"Apples\", \"Pears\", \"Bananas\", nullptr};\n return names;\n}\n\ninline const char* EnumNameEnum(Enum e) {\n if (flatbuffers::IsOutRange(e, Enum_Apples, Enum_Bananas)) return \"\";\n const size_t index = static_cast(e);\n return EnumNamesEnum()[index];\n}\n\nFLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Foo FLATBUFFERS_FINAL_CLASS {\n private:\n uint64_t id_;\n int16_t count_;\n int8_t prefix_;\n int8_t padding0__;\n uint32_t length_;\n\n public:\n Foo() : id_(0), count_(0), prefix_(0), padding0__(0), length_(0) {\n (void)padding0__;\n }\n Foo(uint64_t _id, int16_t _count, int8_t _prefix, uint32_t _length)\n : id_(flatbuffers::EndianScalar(_id)),\n count_(flatbuffers::EndianScalar(_count)),\n prefix_(flatbuffers::EndianScalar(_prefix)),\n padding0__(0),\n length_(flatbuffers::EndianScalar(_length)) {\n (void)padding0__;\n }\n uint64_t id() const { return flatbuffers::EndianScalar(id_); }\n int16_t count() const { return flatbuffers::EndianScalar(count_); }\n int8_t prefix() const { return flatbuffers::EndianScalar(prefix_); }\n uint32_t length() const { return flatbuffers::EndianScalar(length_); }\n};\nFLATBUFFERS_STRUCT_END(Foo, 16);\n\nFLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Bar FLATBUFFERS_FINAL_CLASS {\n private:\n benchmarks_flatbuffers::Foo parent_;\n int32_t time_;\n float ratio_;\n uint16_t size_;\n int16_t padding0__;\n int32_t padding1__;\n\n public:\n Bar()\n : parent_(), time_(0), ratio_(0), size_(0), padding0__(0), padding1__(0) {\n (void)padding0__;\n (void)padding1__;\n }\n Bar(const benchmarks_flatbuffers::Foo& _parent, int32_t _time, float _ratio,\n uint16_t _size)\n : parent_(_parent),\n time_(flatbuffers::EndianScalar(_time)),\n ratio_(flatbuffers::EndianScalar(_ratio)),\n size_(flatbuffers::EndianScalar(_size)),\n padding0__(0),\n padding1__(0) {\n (void)padding0__;\n (void)padding1__;\n }\n const benchmarks_flatbuffers::Foo& parent() const { return parent_; }\n int32_t time() const { return flatbuffers::EndianScalar(time_); }\n float ratio() const { return flatbuffers::EndianScalar(ratio_); }\n uint16_t size() const { return flatbuffers::EndianScalar(size_); }\n};\nFLATBUFFERS_STRUCT_END(Bar, 32);\n\nstruct FooBar FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {\n typedef FooBarBuilder Builder;\n enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {\n VT_SIBLING = 4,\n VT_NAME = 6,\n VT_RATING = 8,\n VT_POSTFIX = 10\n };\n const benchmarks_flatbuffers::Bar* sibling() const {\n return GetStruct(VT_SIBLING);\n }\n const flatbuffers::String* name() const {\n return GetPointer(VT_NAME);\n }\n double rating() const { return GetField(VT_RATING, 0.0); }\n uint8_t postfix() const { return GetField(VT_POSTFIX, 0); }\n bool Verify(flatbuffers::Verifier& verifier) const {\n return VerifyTableStart(verifier) &&\n VerifyField(verifier, VT_SIBLING, 8) &&\n VerifyOffset(verifier, VT_NAME) && verifier.VerifyString(name()) &&\n VerifyField(verifier, VT_RATING, 8) &&\n VerifyField(verifier, VT_POSTFIX, 1) && verifier.EndTable();\n }\n};\n\nstruct FooBarBuilder {\n typedef FooBar Table;\n flatbuffers::FlatBufferBuilder& fbb_;\n flatbuffers::uoffset_t start_;\n void add_sibling(const benchmarks_flatbuffers::Bar* sibling) {\n fbb_.AddStruct(FooBar::VT_SIBLING, sibling);\n }\n void add_name(flatbuffers::Offset name) {\n fbb_.AddOffset(FooBar::VT_NAME, name);\n }\n void add_rating(double rating) {\n fbb_.AddElement(FooBar::VT_RATING, rating, 0.0);\n }\n void add_postfix(uint8_t postfix) {\n fbb_.AddElement(FooBar::VT_POSTFIX, postfix, 0);\n }\n explicit FooBarBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {\n start_ = fbb_.StartTable();\n }\n flatbuffers::Offset Finish() {\n const auto end = fbb_.EndTable(start_);\n auto o = flatbuffers::Offset(end);\n return o;\n }\n};\n\ninline flatbuffers::Offset CreateFooBar(\n flatbuffers::FlatBufferBuilder& _fbb,\n const benchmarks_flatbuffers::Bar* sibling = nullptr,\n flatbuffers::Offset name = 0, double rating = 0.0,\n uint8_t postfix = 0) {\n FooBarBuilder builder_(_fbb);\n builder_.add_rating(rating);\n builder_.add_name(name);\n builder_.add_sibling(sibling);\n builder_.add_postfix(postfix);\n return builder_.Finish();\n}\n\ninline flatbuffers::Offset CreateFooBarDirect(\n flatbuffers::FlatBufferBuilder& _fbb,\n const benchmarks_flatbuffers::Bar* sibling = nullptr,\n const char* name = nullptr, double rating = 0.0, uint8_t postfix = 0) {\n auto name__ = name ? _fbb.CreateString(name) : 0;\n return benchmarks_flatbuffers::CreateFooBar(_fbb, sibling, name__, rating,\n postfix);\n}\n\nstruct FooBarContainer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {\n typedef FooBarContainerBuilder Builder;\n enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {\n VT_LIST = 4,\n VT_INITIALIZED = 6,\n VT_FRUIT = 8,\n VT_LOCATION = 10\n };\n const flatbuffers::Vector<\n flatbuffers::Offset>*\n list() const {\n return GetPointer>*>(VT_LIST);\n }\n bool initialized() const { return GetField(VT_INITIALIZED, 0) != 0; }\n benchmarks_flatbuffers::Enum fruit() const {\n return static_cast(\n GetField(VT_FRUIT, 0));\n }\n const flatbuffers::String* location() const {\n return GetPointer(VT_LOCATION);\n }\n bool Verify(flatbuffers::Verifier& verifier) const {\n return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_LIST) &&\n verifier.VerifyVector(list()) &&\n verifier.VerifyVectorOfTables(list()) &&\n VerifyField(verifier, VT_INITIALIZED, 1) &&\n VerifyField(verifier, VT_FRUIT, 2) &&\n VerifyOffset(verifier, VT_LOCATION) &&\n verifier.VerifyString(location()) && verifier.EndTable();\n }\n};\n\nstruct FooBarContainerBuilder {\n typedef FooBarContainer Table;\n flatbuffers::FlatBufferBuilder& fbb_;\n flatbuffers::uoffset_t start_;\n void add_list(flatbuffers::Offset>>\n list) {\n fbb_.AddOffset(FooBarContainer::VT_LIST, list);\n }\n void add_initialized(bool initialized) {\n fbb_.AddElement(FooBarContainer::VT_INITIALIZED,\n static_cast(initialized), 0);\n }\n void add_fruit(benchmarks_flatbuffers::Enum fruit) {\n fbb_.AddElement(FooBarContainer::VT_FRUIT,\n static_cast(fruit), 0);\n }\n void add_location(flatbuffers::Offset location) {\n fbb_.AddOffset(FooBarContainer::VT_LOCATION, location);\n }\n explicit FooBarContainerBuilder(flatbuffers::FlatBufferBuilder& _fbb)\n : fbb_(_fbb) {\n start_ = fbb_.StartTable();\n }\n flatbuffers::Offset Finish() {\n const auto end = fbb_.EndTable(start_);\n auto o = flatbuffers::Offset(end);\n return o;\n }\n};\n\ninline flatbuffers::Offset CreateFooBarContainer(\n flatbuffers::FlatBufferBuilder& _fbb,\n flatbuffers::Offset>>\n list = 0,\n bool initialized = false,\n benchmarks_flatbuffers::Enum fruit = benchmarks_flatbuffers::Enum_Apples,\n flatbuffers::Offset location = 0) {\n FooBarContainerBuilder builder_(_fbb);\n builder_.add_location(location);\n builder_.add_list(list);\n builder_.add_fruit(fruit);\n builder_.add_initialized(initialized);\n return builder_.Finish();\n}\n\ninline flatbuffers::Offset CreateFooBarContainerDirect(\n flatbuffers::FlatBufferBuilder& _fbb,\n const std::vector>*\n list = nullptr,\n bool initialized = false,\n benchmarks_flatbuffers::Enum fruit = benchmarks_flatbuffers::Enum_Apples,\n const char* location = nullptr) {\n auto list__ =\n list ? _fbb.CreateVector<\n flatbuffers::Offset>(*list)\n : 0;\n auto location__ = location ? _fbb.CreateString(location) : 0;\n return benchmarks_flatbuffers::CreateFooBarContainer(\n _fbb, list__, initialized, fruit, location__);\n}\n\ninline const benchmarks_flatbuffers::FooBarContainer* GetFooBarContainer(\n const void* buf) {\n return flatbuffers::GetRoot(buf);\n}\n\ninline const benchmarks_flatbuffers::FooBarContainer*\nGetSizePrefixedFooBarContainer(const void* buf) {\n return flatbuffers::GetSizePrefixedRoot<\n benchmarks_flatbuffers::FooBarContainer>(buf);\n}\n\ninline bool VerifyFooBarContainerBuffer(flatbuffers::Verifier& verifier) {\n return verifier.VerifyBuffer(\n nullptr);\n}\n\ninline bool VerifySizePrefixedFooBarContainerBuffer(\n flatbuffers::Verifier& verifier) {\n return verifier\n .VerifySizePrefixedBuffer(\n nullptr);\n}\n\ninline void FinishFooBarContainerBuffer(\n flatbuffers::FlatBufferBuilder& fbb,\n flatbuffers::Offset root) {\n fbb.Finish(root);\n}\n\ninline void FinishSizePrefixedFooBarContainerBuffer(\n flatbuffers::FlatBufferBuilder& fbb,\n flatbuffers::Offset root) {\n fbb.FinishSizePrefixed(root);\n}\n\n} // namespace benchmarks_flatbuffers\n\n#endif // FLATBUFFERS_GENERATED_BENCH_BENCHMARKS_FLATBUFFERS_H_\n" }, { "path": "benchmarks/cpp/flatbuffers/fb_bench.cpp", "content": "#include \"benchmarks/cpp/flatbuffers/fb_bench.h\"\n\n#include \n#include \n\n#include \"benchmarks/cpp/bench.h\"\n#include \"benchmarks/cpp/flatbuffers/bench_generated.h\"\n#include \"flatbuffers/flatbuffers.h\"\n\nusing namespace flatbuffers;\nusing namespace benchmarks_flatbuffers;\n\nnamespace {\n\nstruct FlatBufferBench : Bench {\n explicit FlatBufferBench(int64_t initial_size, Allocator* allocator)\n : fbb(initial_size, allocator, false) {}\n\n uint8_t* Encode(void*, int64_t& len) override {\n fbb.Clear();\n\n const int kVectorLength = 3;\n Offset vec[kVectorLength];\n\n for (int i = 0; i < kVectorLength; ++i) {\n Foo foo(0xABADCAFEABADCAFE + i, 10000 + i, '@' + i, 1000000 + i);\n Bar bar(foo, 123456 + i, 3.14159f + i, 10000 + i);\n auto name = fbb.CreateString(\"Hello, World!\");\n auto foobar =\n CreateFooBar(fbb, &bar, name, 3.1415432432445543543 + i, '!' + i);\n vec[i] = foobar;\n }\n auto location = fbb.CreateString(\"http://google.com/flatbuffers/\");\n auto foobarvec = fbb.CreateVector(vec, kVectorLength);\n auto foobarcontainer =\n CreateFooBarContainer(fbb, foobarvec, true, Enum_Bananas, location);\n fbb.Finish(foobarcontainer);\n\n len = fbb.GetSize();\n return fbb.GetBufferPointer();\n }\n\n int64_t Use(void* decoded) override {\n sum = 0;\n auto foobarcontainer = GetFooBarContainer(decoded);\n sum = 0;\n Add(foobarcontainer->initialized());\n Add(foobarcontainer->location()->Length());\n Add(foobarcontainer->fruit());\n for (unsigned int i = 0; i < foobarcontainer->list()->Length(); i++) {\n auto foobar = foobarcontainer->list()->Get(i);\n Add(foobar->name()->Length());\n Add(foobar->postfix());\n Add(static_cast(foobar->rating()));\n auto bar = foobar->sibling();\n Add(static_cast(bar->ratio()));\n Add(bar->size());\n Add(bar->time());\n auto& foo = bar->parent();\n Add(foo.count());\n Add(foo.id());\n Add(foo.length());\n Add(foo.prefix());\n }\n return sum;\n }\n\n void* Decode(void* buffer, int64_t) override { return buffer; }\n void Dealloc(void*) override {};\n\n FlatBufferBuilder fbb;\n};\n\n} // namespace\n\nstd::unique_ptr NewFlatBuffersBench(int64_t initial_size,\n Allocator* allocator) {\n return std::unique_ptr(\n new FlatBufferBench(initial_size, allocator));\n}\n" }, { "path": "benchmarks/cpp/flatbuffers/fb_bench.h", "content": "#ifndef BENCHMARKS_CPP_FLATBUFFERS_FB_BENCH_H_\n#define BENCHMARKS_CPP_FLATBUFFERS_FB_BENCH_H_\n\n#include \n#include \n\n#include \"benchmarks/cpp/bench.h\"\n#include \"include/flatbuffers/flatbuffers.h\"\n\nstruct StaticAllocator : public flatbuffers::Allocator {\n explicit StaticAllocator(uint8_t* buffer) : buffer_(buffer) {}\n\n uint8_t* allocate(size_t) override { return buffer_; }\n\n void deallocate(uint8_t*, size_t) override {}\n\n uint8_t* buffer_;\n};\n\nstd::unique_ptr NewFlatBuffersBench(\n int64_t initial_size = 1024, flatbuffers::Allocator* allocator = nullptr);\n\n#endif // BENCHMARKS_CPP_FLATBUFFERS_FB_BENCH_H_" }, { "path": "benchmarks/cpp/raw/raw_bench.cpp", "content": "#include \"benchmarks/cpp/raw/raw_bench.h\"\n\n#include \n#include \n#include \n\n#include \"benchmarks/cpp/bench.h\"\n\nnamespace {\nconst int64_t kStringLength = 32;\nconst int64_t kVectorLength = 3;\n\nenum Enum { Apples, Pears, Bananas };\n\nstruct Foo {\n int64_t id;\n short count;\n char prefix;\n int length;\n};\n\nstruct Bar {\n Foo parent;\n int time;\n float ratio;\n unsigned short size;\n};\n\nstruct FooBar {\n Bar sibling;\n // We have to stick this in, otherwise strlen() will make it slower than\n // FlatBuffers:\n int name_len;\n char name[kStringLength];\n double rating;\n unsigned char postfix;\n};\n\nstruct FooBarContainer {\n FooBar list[kVectorLength]; // 3 copies of the above\n bool initialized;\n Enum fruit;\n int location_len;\n char location[kStringLength];\n};\n\nstruct RawBench : Bench {\n uint8_t* Encode(void* buf, int64_t& len) override {\n FooBarContainer* fbc = new (buf) FooBarContainer;\n strcpy(fbc->location, \"http://google.com/flatbuffers/\"); // Unsafe eek!\n fbc->location_len = (int)strlen(fbc->location);\n fbc->fruit = Bananas;\n fbc->initialized = true;\n for (int i = 0; i < kVectorLength; i++) {\n // We add + i to not make these identical copies for a more realistic\n // compression test.\n auto& foobar = fbc->list[i];\n foobar.rating = 3.1415432432445543543 + i;\n foobar.postfix = '!' + i;\n strcpy(foobar.name, \"Hello, World!\");\n foobar.name_len = (int)strlen(foobar.name);\n auto& bar = foobar.sibling;\n bar.ratio = 3.14159f + i;\n bar.size = 10000 + i;\n bar.time = 123456 + i;\n auto& foo = bar.parent;\n foo.id = 0xABADCAFEABADCAFE + i;\n foo.count = 10000 + i;\n foo.length = 1000000 + i;\n foo.prefix = '@' + i;\n }\n\n len = sizeof(FooBarContainer);\n return reinterpret_cast(fbc);\n };\n\n int64_t Use(void* decoded) override {\n auto foobarcontainer = reinterpret_cast(decoded);\n sum = 0;\n Add(foobarcontainer->initialized);\n Add(foobarcontainer->location_len);\n Add(foobarcontainer->fruit);\n for (unsigned int i = 0; i < kVectorLength; i++) {\n auto foobar = &foobarcontainer->list[i];\n Add(foobar->name_len);\n Add(foobar->postfix);\n Add(static_cast(foobar->rating));\n auto bar = &foobar->sibling;\n Add(static_cast(bar->ratio));\n Add(bar->size);\n Add(bar->time);\n auto& foo = bar->parent;\n Add(foo.count);\n Add(foo.id);\n Add(foo.length);\n Add(foo.prefix);\n }\n return sum;\n }\n\n void* Decode(void* buf, int64_t) override { return buf; }\n void Dealloc(void*) override {};\n};\n\n} // namespace\n\nstd::unique_ptr NewRawBench() {\n return std::unique_ptr(new RawBench());\n}\n" }, { "path": "benchmarks/cpp/raw/raw_bench.h", "content": "#ifndef BENCHMARKS_CPP_RAW_RAW_BENCH_H_\n#define BENCHMARKS_CPP_RAW_RAW_BENCH_H_\n\n#include \n\n#include \"benchmarks/cpp/bench.h\"\n\nstd::unique_ptr NewRawBench();\n\n#endif // BENCHMARKS_CPP_RAW_RAW_BENCH_H_" }, { "path": "benchmarks/swift/Benchmarks/FlatbuffersBenchmarks/FlatbuffersBenchmarks.swift", "content": "/*\n * Copyright 2024 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport Benchmark\nimport FlatBuffers\nimport Foundation\n\n@usableFromInline\nstruct AA: NativeStruct {\n public init(a: Double, b: Double) {\n self.a = a\n self.b = b\n }\n var a: Double\n var b: Double\n}\n\nlet benchmarks = {\n let oneGB: Int32 = 1_024_000_000\n let data = {\n var array = [8888.88, 8888.88]\n var data = Data()\n array.withUnsafeBytes { ptr in\n data.append(contentsOf: ptr)\n }\n return data\n }()\n let ints: [Int] = Array(repeating: 42, count: 100)\n let bytes: [UInt8] = Array(repeating: 42, count: 100)\n let str10 = (0...9).map { _ -> String in \"x\" }.joined()\n let str100 = (0...99).map { _ -> String in \"x\" }.joined()\n let array: [AA] = [\n AA(a: 2.4, b: 2.4),\n AA(a: 2.4, b: 2.4),\n AA(a: 2.4, b: 2.4),\n AA(a: 2.4, b: 2.4),\n AA(a: 2.4, b: 2.4),\n ]\n\n let metrics: [BenchmarkMetric] = [\n .cpuTotal,\n .wallClock,\n .mallocCountTotal,\n .releaseCount,\n .peakMemoryResident,\n ]\n let maxIterations = 1_000_000\n let maxDuration: Duration = .seconds(3)\n let singleConfiguration: Benchmark.Configuration = .init(\n metrics: metrics,\n warmupIterations: 1,\n scalingFactor: .one,\n maxDuration: maxDuration,\n maxIterations: maxIterations)\n let kiloConfiguration: Benchmark.Configuration = .init(\n metrics: metrics,\n warmupIterations: 1,\n scalingFactor: .kilo,\n maxDuration: maxDuration,\n maxIterations: maxIterations)\n let megaConfiguration: Benchmark.Configuration = .init(\n metrics: metrics,\n warmupIterations: 1,\n scalingFactor: .mega,\n maxDuration: maxDuration,\n maxIterations: maxIterations)\n\n Benchmark.defaultConfiguration = megaConfiguration\n\n Benchmark(\"Allocating 1GB\", configuration: singleConfiguration) { benchmark in\n for _ in benchmark.scaledIterations {\n blackHole(FlatBufferBuilder(initialSize: oneGB))\n }\n }\n\n Benchmark(\n \"Allocating ByteBuffer 1GB\",\n configuration: singleConfiguration)\n { benchmark in\n let memory = UnsafeMutableRawPointer.allocate(\n byteCount: 1_024_000_000,\n alignment: 1)\n benchmark.startMeasurement()\n for _ in benchmark.scaledIterations {\n blackHole(ByteBuffer(assumingMemoryBound: memory, capacity: Int(oneGB)))\n }\n }\n\n Benchmark(\"Clearing 1GB\", configuration: singleConfiguration) { benchmark in\n var fb = FlatBufferBuilder(initialSize: oneGB)\n benchmark.startMeasurement()\n for _ in benchmark.scaledIterations {\n blackHole(fb.clear())\n }\n }\n\n Benchmark(\"Strings 10\") { benchmark in\n var fb = FlatBufferBuilder(initialSize: 1 << 20)\n benchmark.startMeasurement()\n for _ in benchmark.scaledIterations {\n blackHole(fb.create(string: str10))\n }\n }\n\n Benchmark(\"Strings 100\") { benchmark in\n var fb = FlatBufferBuilder(initialSize: 1 << 20)\n benchmark.startMeasurement()\n for _ in benchmark.scaledIterations {\n blackHole(fb.create(string: str100))\n }\n }\n\n Benchmark(\"Vector 1 Bytes\") { benchmark in\n var fb = FlatBufferBuilder(initialSize: 1 << 20)\n benchmark.startMeasurement()\n for _ in benchmark.scaledIterations {\n blackHole(fb.createVector(bytes: bytes))\n }\n }\n\n Benchmark(\"Vector 1 Ints\") { benchmark in\n var fb = FlatBufferBuilder(initialSize: 1 << 20)\n benchmark.startMeasurement()\n for _ in benchmark.scaledIterations {\n blackHole(fb.createVector(ints))\n }\n }\n\n Benchmark(\"Vector 100 Ints\") { benchmark in\n var fb = FlatBufferBuilder(initialSize: 1 << 20)\n benchmark.startMeasurement()\n for i in benchmark.scaledIterations {\n blackHole(fb.createVector(ints))\n }\n }\n\n Benchmark(\"Vector 100 Bytes\") { benchmark in\n var fb = FlatBufferBuilder(initialSize: 1 << 20)\n benchmark.startMeasurement()\n for i in benchmark.scaledIterations {\n blackHole(fb.createVector(bytes))\n }\n }\n\n Benchmark(\"Vector 100 ContiguousBytes\") { benchmark in\n var fb = FlatBufferBuilder(initialSize: 1 << 20)\n benchmark.startMeasurement()\n for i in benchmark.scaledIterations {\n blackHole(fb.createVector(bytes: bytes))\n }\n }\n\n Benchmark(\n \"FlatBufferBuilder Add\",\n configuration: kiloConfiguration)\n { benchmark in\n var fb = FlatBufferBuilder(initialSize: 1024 * 1024 * 32)\n benchmark.startMeasurement()\n for _ in benchmark.scaledIterations {\n let off = fb.create(string: \"T\")\n let s = fb.startTable(with: 4)\n fb.add(element: 3.2, def: 0, at: 2)\n fb.add(element: 4.2, def: 0, at: 4)\n fb.add(element: 5.2, def: 0, at: 6)\n fb.add(offset: off, at: 8)\n blackHole(fb.endTable(at: s))\n }\n }\n\n Benchmark(\n \"FlatBufferBuilder Start table\",\n configuration: kiloConfiguration)\n { benchmark in\n var fb = FlatBufferBuilder(initialSize: 1024 * 1024 * 32)\n benchmark.startMeasurement()\n for _ in benchmark.scaledIterations {\n let s = fb.startTable(with: 4)\n blackHole(fb.endTable(at: s))\n }\n }\n\n Benchmark(\"Struct\") { benchmark in\n var fb = FlatBufferBuilder(initialSize: 1024 * 1024 * 32)\n benchmark.startMeasurement()\n for _ in benchmark.scaledIterations {\n blackHole(fb.create(struct: array.first!))\n }\n }\n\n Benchmark(\"Structs\") { benchmark in\n let rawSize = ((16 * 5) * benchmark.scaledIterations.count) / 1024\n var fb = FlatBufferBuilder(initialSize: Int32(rawSize * 1600))\n var offsets: [Offset] = []\n\n benchmark.startMeasurement()\n for _ in benchmark.scaledIterations {\n let vector = fb.createVector(\n ofStructs: array)\n let start = fb.startTable(with: 1)\n fb.add(offset: vector, at: 4)\n offsets.append(Offset(offset: fb.endTable(at: start)))\n }\n\n let vector = fb.createVector(ofOffsets: offsets)\n let start = fb.startTable(with: 1)\n fb.add(offset: vector, at: 4)\n let root = Offset(offset: fb.endTable(at: start))\n blackHole(fb.finish(offset: root))\n }\n\n Benchmark(\"Vector of Offsets\") { benchmark in\n let rawSize = ((16 * 5) * benchmark.scaledIterations.count) / 1024\n var fb = FlatBufferBuilder(initialSize: Int32(rawSize * 1600))\n benchmark.startMeasurement()\n for _ in benchmark.scaledIterations {\n let offsets = [\n fb.create(string: \"T\"),\n fb.create(string: \"2\"),\n fb.create(string: \"3\"),\n ]\n let off = fb.createVector(ofOffsets: [\n fb.createVector(ofOffsets: offsets),\n fb.createVector(ofOffsets: offsets),\n ])\n let s = fb.startTable(with: 2)\n fb.add(offset: off, at: 2)\n blackHole(fb.endTable(at: s))\n }\n }\n\n Benchmark(\"Reading Doubles\") { benchmark in\n let byteBuffer = ByteBuffer(data: data)\n for _ in benchmark.scaledIterations {\n blackHole(byteBuffer.read(def: Double.self, position: 0))\n }\n }\n}\n" }, { "path": "benchmarks/swift/Package.swift", "content": "// swift-tools-version:5.10\n/*\n * Copyright 2020 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport PackageDescription\n\nlet package = Package(\n name: \"benchmarks\",\n platforms: [\n .macOS(.v13),\n ],\n dependencies: [\n .package(path: \"../..\"),\n .package(\n url: \"https://github.com/ordo-one/package-benchmark\",\n from: \"1.27.0\"),\n ],\n targets: [\n .executableTarget(\n name: \"FlatbuffersBenchmarks\",\n dependencies: [\n .product(name: \"FlatBuffers\", package: \"flatbuffers\"),\n .product(name: \"Benchmark\", package: \"package-benchmark\"),\n ],\n path: \"Benchmarks/FlatbuffersBenchmarks\",\n plugins: [\n .plugin(name: \"BenchmarkPlugin\", package: \"package-benchmark\"),\n ]),\n ])\n" }, { "path": "benchmarks/swift/README.md", "content": "# Benchmarks\n\nTo open the benchmarks in xcode use:\n\n`open --env BENCHMARK_DISABLE_JEMALLOC=true Package.swift`\n\nor running them directly within terminal using:\n\n`swift package benchmark`\n" }, { "path": "build_defs.bzl", "content": "# Description:\n# BUILD rules for generating flatbuffer files in various languages.\n\n\"\"\"\nRules for building C++ flatbuffers with Bazel.\n\"\"\"\n\nload(\"@rules_cc//cc:defs.bzl\", \"cc_library\")\n\nTRUE_FLATC_PATH = Label(\"//:flatc\")\n\nDEFAULT_INCLUDE_PATHS = [\n \"./\",\n \"$(GENDIR)\",\n \"$(BINDIR)\",\n \"$(execpath %s).runfiles/%s\" % (TRUE_FLATC_PATH, TRUE_FLATC_PATH.repo_name),\n]\n\ndef default_include_paths(flatc_path):\n return [\n \"./\",\n \"$(GENDIR)\",\n \"$(BINDIR)\",\n \"$(execpath %s).runfiles/%s\" % (flatc_path, flatc_path.repo_name),\n ]\n\nDEFAULT_FLATC_ARGS = [\n \"--gen-object-api\",\n \"--gen-compare\",\n \"--no-includes\",\n \"--gen-mutable\",\n \"--reflect-names\",\n \"--cpp-ptr-type flatbuffers::unique_ptr\",\n]\n\ndef flatbuffer_library_public(\n name,\n srcs,\n outs,\n language_flag,\n out_prefix = \"\",\n includes = [],\n include_paths = None,\n flatc_args = DEFAULT_FLATC_ARGS,\n reflection_name = \"\",\n reflection_visibility = None,\n compatible_with = None,\n restricted_to = None,\n target_compatible_with = None,\n flatc_path = None,\n output_to_bindir = False,\n tools = None,\n extra_env = None,\n **kwargs):\n \"\"\"Generates code files for reading/writing the given flatbuffers in the requested language using the public compiler.\n\n Args:\n name: Rule name.\n srcs: Source .fbs files. Sent in order to the compiler.\n outs: Output files from flatc.\n language_flag: Target language flag. One of [-c, -j, -js].\n out_prefix: Prepend this path to the front of all generated files except on\n single source targets. Usually is a directory name.\n includes: Optional, list of filegroups of schemas that the srcs depend on.\n include_paths: Optional, list of paths the includes files can be found in.\n flatc_args: Optional, list of additional arguments to pass to flatc.\n reflection_name: Optional, if set this will generate the flatbuffer\n reflection binaries for the schemas.\n reflection_visibility: The visibility of the generated reflection Fileset.\n output_to_bindir: Passed to genrule for output to bin directory.\n compatible_with: Optional, The list of environments this rule can be\n built for, in addition to default-supported environments.\n restricted_to: Optional, The list of environments this rule can be built\n for, instead of default-supported environments.\n target_compatible_with: Optional, The list of target platform constraints\n to use.\n flatc_path: Bazel target corresponding to the flatc compiler to use.\n output_to_bindir: Passed to genrule for output to bin directory.\n tools: Optional, passed to genrule for list of tools to make available\n during the action.\n extra_env: Optional, must be a string of \"VAR1=VAL1 VAR2=VAL2\". These get\n set as environment variables that \"flatc_path\" sees.\n **kwargs: Passed to the underlying genrule.\n\n\n This rule creates a filegroup(name) with all generated source files, and\n optionally a Fileset([reflection_name]) with all generated reflection\n binaries.\n \"\"\"\n if flatc_path == None:\n flatc_path = TRUE_FLATC_PATH\n else:\n flatc_path = native.package_relative_label(flatc_path)\n\n reflection_include_paths = include_paths\n if include_paths == None:\n include_paths = default_include_paths(flatc_path)\n include_paths_cmd = [\"-I %s\" % (s) for s in include_paths]\n\n extra_env = extra_env or \"\"\n\n # '$(@D)' when given a single source target will give the appropriate\n # directory. Appending 'out_prefix' is only necessary when given a build\n # target with multiple sources.\n output_directory = (\n (\"-o $(@D)/%s\" % (out_prefix)) if len(srcs) > 1 else (\"-o $(@D)\")\n )\n genrule_cmd = \" \".join([\n \"SRCS=($(SRCS));\",\n \"for f in $${SRCS[@]:0:%s}; do\" % len(srcs),\n \"OUTPUT_FILE=\\\"$(OUTS)\\\" %s $(location %s)\" % (extra_env, flatc_path),\n \" \".join(include_paths_cmd),\n \" \".join(flatc_args),\n language_flag,\n output_directory,\n \"$$f;\",\n \"done\",\n ])\n native.genrule(\n name = name,\n srcs = srcs + includes,\n outs = outs,\n output_to_bindir = output_to_bindir,\n tools = (tools or []) + [flatc_path],\n cmd = genrule_cmd,\n compatible_with = compatible_with,\n target_compatible_with = target_compatible_with,\n restricted_to = restricted_to,\n message = \"Generating flatbuffer files for %s:\" % (name),\n **kwargs\n )\n if reflection_name:\n if reflection_include_paths == None:\n reflection_include_paths = default_include_paths(TRUE_FLATC_PATH)\n reflection_include_paths_cmd = [\"-I %s\" % (s) for s in reflection_include_paths]\n reflection_genrule_cmd = \" \".join([\n \"SRCS=($(SRCS));\",\n \"for f in $${SRCS[@]:0:%s}; do\" % len(srcs),\n # Move the .fbs file into the current package if it is not there already\n 'if [[ $$(dirname $$f) != \"{0}\" ]]; then s=\"$$f\"; f=\"{0}/$$(basename \"$$f\")\"; mkdir -p \"{0}\"; mv \"$$s\" \"$$f\"; fi;'.format(native.package_relative_label(\":invalid\").package),\n \"$(location %s)\" % (TRUE_FLATC_PATH),\n \"-b --schema\",\n \" \".join(flatc_args),\n \" \".join(reflection_include_paths_cmd),\n language_flag,\n output_directory,\n \"$$f;\",\n \"done\",\n ])\n reflection_outs = [\n (out_prefix + \"%s.bfbs\") % (native.package_relative_label(s).name.removesuffix(\".fbs\"))\n for s in srcs\n ]\n\n native.genrule(\n name = \"%s_srcs\" % reflection_name,\n srcs = srcs + includes,\n outs = reflection_outs,\n output_to_bindir = output_to_bindir,\n tools = [TRUE_FLATC_PATH],\n compatible_with = compatible_with,\n restricted_to = restricted_to,\n target_compatible_with = target_compatible_with,\n cmd = reflection_genrule_cmd,\n message = \"Generating flatbuffer reflection binary for %s:\" % (name),\n visibility = reflection_visibility,\n )\n native.filegroup(\n name = \"%s_out\" % reflection_name,\n srcs = reflection_outs,\n visibility = reflection_visibility,\n compatible_with = compatible_with,\n restricted_to = restricted_to,\n )\n\ndef flatbuffer_cc_library(\n name,\n srcs,\n srcs_filegroup_name = \"\",\n outs = [],\n out_prefix = \"\",\n deps = [],\n includes = [],\n include_paths = None,\n cc_include_paths = [],\n flatc_args = DEFAULT_FLATC_ARGS,\n visibility = None,\n compatible_with = None,\n restricted_to = None,\n filename_suffix = \"_generated\",\n target_compatible_with = None,\n srcs_filegroup_visibility = None,\n gen_reflections = False):\n \"\"\"A cc_library with the generated reader/writers for the given flatbuffer definitions.\n\n Args:\n name: Rule name.\n srcs: Source .fbs files. Sent in order to the compiler.\n srcs_filegroup_name: Name of the output filegroup that holds srcs. Pass this\n filegroup into the `includes` parameter of any other\n flatbuffer_cc_library that depends on this one's schemas.\n outs: Additional outputs expected to be generated by flatc.\n out_prefix: Prepend this path to the front of all generated files. Usually\n is a directory name.\n deps: Optional, list of other flatbuffer_cc_library's to depend on. Cannot be specified\n alongside includes.\n includes: Optional, list of filegroups of schemas that the srcs depend on.\n Use of this is discouraged, and may be deprecated.\n include_paths: Optional, list of paths the includes files can be found in.\n cc_include_paths: Optional, list of paths to add to the cc_library includes attribute.\n flatc_args: Optional list of additional arguments to pass to flatc\n (e.g. --gen-mutable).\n visibility: The visibility of the generated cc_library. By default, use the\n default visibility of the project.\n srcs_filegroup_visibility: The visibility of the generated srcs filegroup.\n By default, use the value of the visibility parameter above.\n gen_reflections: Optional, if true this will generate the flatbuffer\n reflection binaries for the schemas.\n compatible_with: Optional, The list of environments this rule can be built\n for, in addition to default-supported environments.\n restricted_to: Optional, The list of environments this rule can be built\n for, instead of default-supported environments.\n target_compatible_with: Optional, The list of target platform constraints\n to use.\n\n This produces:\n filegroup([name]_srcs): all generated .h files.\n filegroup(srcs_filegroup_name if specified, or [name]_includes if not):\n Other flatbuffer_cc_library's can pass this in for their `includes`\n parameter, if they depend on the schemas in this library.\n Fileset([name]_reflection): (Optional) all generated reflection binaries.\n cc_library([name]): library with sources and flatbuffers deps.\n \"\"\"\n\n output_headers = []\n for s in srcs:\n base_name = s.split(\"/\")[-1].split(\":\")[-1].replace(\".fbs\", \"\")\n header = out_prefix + base_name + filename_suffix + \".h\"\n output_headers.append(header)\n\n if deps and includes:\n # There is no inherent reason we couldn't support both, but this discourages\n # use of includes without good reason.\n fail(\"Cannot specify both deps and include in flatbuffer_cc_library.\")\n if deps:\n includes = [d + \"_includes\" for d in deps]\n reflection_name = \"%s_reflection\" % name if gen_reflections else \"\"\n\n srcs_lib = \"%s_srcs\" % (name)\n flatbuffer_library_public(\n name = srcs_lib,\n srcs = srcs,\n outs = outs + output_headers,\n language_flag = \"-c\",\n out_prefix = out_prefix,\n includes = includes,\n include_paths = include_paths,\n flatc_args = flatc_args,\n compatible_with = compatible_with,\n restricted_to = restricted_to,\n target_compatible_with = target_compatible_with,\n reflection_name = reflection_name,\n reflection_visibility = visibility,\n )\n cc_library(\n name = name,\n hdrs = [\n \":\" + srcs_lib,\n ],\n srcs = [\n \":\" + srcs_lib,\n ],\n features = [\n \"-parse_headers\",\n ],\n deps = [\n Label(\"//:runtime_cc\"),\n Label(\"//:flatbuffers\"),\n ] + deps,\n includes = cc_include_paths,\n compatible_with = compatible_with,\n restricted_to = restricted_to,\n target_compatible_with = target_compatible_with,\n linkstatic = 1,\n visibility = visibility,\n )\n\n # A filegroup for the `srcs`. That is, all the schema files for this\n # Flatbuffer set.\n native.filegroup(\n name = srcs_filegroup_name if srcs_filegroup_name else \"%s_includes\" % (name),\n srcs = srcs + includes,\n compatible_with = compatible_with,\n restricted_to = restricted_to,\n visibility = srcs_filegroup_visibility if srcs_filegroup_visibility != None else visibility,\n )\n" }, { "path": "composer.json", "content": "{\n \"name\": \"google/flatbuffers\",\n \"type\": \"library\",\n \"description\": \"FlatBuffers for PHP\",\n \"keywords\": [\"google\", \"flatbuffers\", \"serialization\"],\n \"homepage\": \"https://github.com/google/flatbuffers\",\n \"license\": \"Apache-2.0\",\n \"require\": {\n \"php\": \">=5.4\"\n },\n \"require-dev\": {\n },\n \"autoload\": {\n \"psr-4\": {\n \"Google\\\\FlatBuffers\\\\\": \"php\"\n }\n }\n}" }, { "path": "dart/CHANGELOG.md", "content": "# Changelog\n\n## 25.9.23\n\n- use enhanced enums (#8313)\n- fix incorrect write in Float64 write method (#8290)\n- code format improvements (#8707)\n\n## 23.5.26\n\n- omit type annotationes for local variables (#7067, #7069, #7070)\n- remove BSD 3-clause license (#7073)\n- correctly parse lists of enums (#7157)\n- align naming conventions for generated code (#7187)\n- add `putBool` to fix errors when serializing structs with booleans (#7359)\n- fix handling of +/-inf defaults in codegen (#7588)\n- fix import issues in generated code (#7621)\n- Fix incorrect storage of floats as ints in some cases (#7703)\n- add final modifiers to the library implementation (#7943)\n\n## 2.0.5\n\n- switch to null safety (#6696)\n- add Object APIs (pack/unpack) (#6682, #6723, #6846)\n- add custom builder buffer allocator support (#6711)\n- add `Builder.size()` - finished buffer size (#6403)\n- make `writeString()` argument non-nullable (#6737)\n- make tables fixed size (expect the number of fields when creating) (#6735)\n- make table deduplication optional (param `deduplicateTables`) (#6734)\n- change `Builder.reset()` to reuse an existing buffer (#6661)\n- change table building to assert() instead of exceptions (#6754)\n- optimize `writeString()` for ASCII (param `asciiOptimization`) (#6736)\n- change `StringReader` to make ASCII optimization optional (param `asciiOptimization`) (#6758)\n- change `[byte]` and `[ubyte]` representation to `dart:typed_data` `Int8List` and `Uint8List` (#6839)\n- rename `lowFinish()` to `buffer` getter (#6712)\n- fix `Builder._writeString()` - always write trailing zero byte (#6390)\n- fix `Builder.reset()` - clear vTables (#6386)\n- make sure added padding is zeroed, same as in C++ (#6716)\n- many performance improvements (#6755)\n\n## 1.9.2\n\n- Ensure `_writeString` adds enough padding to null terminate strings.\n\n## 1.9.1\n\n- Changed constant identifiers to be compatible with Dart 2.x\n- No longer supports Dart 1.x\n\n## 1.9.0\n\n- Initial release, supports Dart 1.x and many dev versions of Dart 2.x\n" }, { "path": "dart/LICENSE", "content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright 2014 Google Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n" }, { "path": "dart/README.md", "content": "# FlatBuffers for Dart\n\nThis package is used to read and write [FlatBuffers](https://google.github.io/flatbuffers/).\n\nMost consumers will want to use the [`flatc` - FlatBuffer compiler](https://github.com/google/flatbuffers) binary for your platform.\nYou can download the flatc version matching your dart package version from [GitHub releases](https://github.com/google/flatbuffers/releases).\n\nThe FlatBuffer compiler `flatc` reads a FlatBuffers IDL schema and generates Dart code.\nThe generated classes can be used to read or write binary data/files that are interoperable with\nother languages and platforms supported by FlatBuffers, as illustrated in the `example.dart` in the\nexamples folder.\n\nFor more details and documentation, head over to the official site and read the\n[Tutorial](https://google.github.io/flatbuffers/flatbuffers_guide_tutorial.html) and how to\n[use FlatBuffers in Dart](https://google.github.io/flatbuffers/flatbuffers_guide_use_dart.html).\n" }, { "path": "dart/analysis_options.yaml", "content": "include: package:lints/recommended.yaml\n" }, { "path": "dart/example/example.dart", "content": "/*\n * Copyright 2018 Dan Field. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport 'package:flat_buffers/flat_buffers.dart' as fb;\n\nimport './monster_my_game.sample_generated.dart' as my_game;\n\n// Example how to use FlatBuffers to create and read binary buffers.\n\nvoid main() {\n builderTest();\n objectBuilderTest();\n}\n\nvoid builderTest() {\n final builder = fb.Builder(initialSize: 1024);\n final int? weaponOneName = builder.writeString(\"Sword\");\n final int weaponOneDamage = 3;\n\n final int? weaponTwoName = builder.writeString(\"Axe\");\n final int weaponTwoDamage = 5;\n\n final swordBuilder = my_game.WeaponBuilder(builder)\n ..begin()\n ..addNameOffset(weaponOneName)\n ..addDamage(weaponOneDamage);\n final int sword = swordBuilder.finish();\n\n final axeBuilder = my_game.WeaponBuilder(builder)\n ..begin()\n ..addNameOffset(weaponTwoName)\n ..addDamage(weaponTwoDamage);\n final int axe = axeBuilder.finish();\n\n // Serialize a name for our monster, called \"Orc\".\n final int? name = builder.writeString('Orc');\n\n // Create a list representing the inventory of the Orc. Each number\n // could correspond to an item that can be claimed after he is slain.\n final List treasure = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n final inventory = builder.writeListUint8(treasure);\n final weapons = builder.writeList([sword, axe]);\n\n // Struct builders are very easy to reuse.\n final vec3Builder = my_game.Vec3Builder(builder);\n\n vec3Builder.finish(4.0, 5.0, 6.0);\n vec3Builder.finish(1.0, 2.0, 3.0);\n // Set his hit points to 300 and his mana to 150.\n final int hp = 300;\n final int mana = 150;\n\n final monster = my_game.MonsterBuilder(builder)\n ..begin()\n ..addNameOffset(name)\n ..addInventoryOffset(inventory)\n ..addWeaponsOffset(weapons)\n ..addEquippedType(my_game.EquipmentTypeId.Weapon)\n ..addEquippedOffset(axe)\n ..addHp(hp)\n ..addMana(mana)\n ..addPos(vec3Builder.finish(1.0, 2.0, 3.0))\n ..addColor(my_game.Color.Red);\n\n final int monsteroff = monster.finish();\n builder.finish(monsteroff);\n if (verify(builder.buffer)) {\n print(\n \"The FlatBuffer was successfully created with a builder and verified!\",\n );\n }\n}\n\nvoid objectBuilderTest() {\n // Create the builder here so we can use it for both weapons and equipped\n // the actual data will only be written to the buffer once.\n var axe = my_game.WeaponObjectBuilder(name: 'Axe', damage: 5);\n\n var monsterBuilder = my_game.MonsterObjectBuilder(\n pos: my_game.Vec3ObjectBuilder(x: 1.0, y: 2.0, z: 3.0),\n mana: 150,\n hp: 300,\n name: 'Orc',\n inventory: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],\n color: my_game.Color.Red,\n weapons: [\n my_game.WeaponObjectBuilder(name: 'Sword', damage: 3),\n axe,\n ],\n equippedType: my_game.EquipmentTypeId.Weapon,\n equipped: axe,\n );\n\n var buffer = monsterBuilder.toBytes();\n\n // We now have a FlatBuffer we can store on disk or send over a network.\n\n // ** file/network code goes here :) **\n\n // Instead, we're going to access it right away (as if we just received it).\n if (verify(buffer)) {\n print(\n \"The FlatBuffer was successfully created with an object builder and verified!\",\n );\n }\n}\n\nbool verify(List buffer) {\n // Get access to the root:\n var monster = my_game.Monster(buffer);\n\n // Get and test some scalar types from the FlatBuffer.\n assert(monster.hp == 80);\n assert(monster.mana == 150); // default\n assert(monster.name == \"MyMonster\");\n\n // Get and test a field of the FlatBuffer's `struct`.\n var pos = monster.pos!;\n assert(pos.z == 3.0);\n\n // Get a test an element from the `inventory` FlatBuffer's `vector`.\n var inv = monster.inventory!;\n assert(inv.length == 10);\n assert(inv[9] == 9);\n\n // Get and test the `weapons` FlatBuffers's `vector`.\n var expectedWeaponNames = [\"Sword\", \"Axe\"];\n var expectedWeaponDamages = [3, 5];\n var weps = monster.weapons!;\n for (int i = 0; i < weps.length; i++) {\n assert(weps[i].name == expectedWeaponNames[i]);\n assert(weps[i].damage == expectedWeaponDamages[i]);\n }\n\n // Get and test the `Equipment` union (`equipped` field).\n assert(monster.equippedType!.value == my_game.EquipmentTypeId.Weapon.value);\n assert(monster.equippedType == my_game.EquipmentTypeId.Weapon);\n\n assert(monster.equipped is my_game.Weapon);\n var equipped = monster.equipped as my_game.Weapon;\n assert(equipped.name == \"Axe\");\n assert(equipped.damage == 5);\n\n print(monster);\n return true;\n}\n" }, { "path": "dart/example/monster_my_game.sample_generated.dart", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable\n\nlibrary my_game.sample;\n\nimport 'dart:typed_data' show Uint8List;\n\nimport 'package:flat_buffers/flat_buffers.dart' as fb;\n\nclass Color {\n final int value;\n const Color._(this.value);\n\n factory Color.fromValue(int value) {\n final result = values[value];\n if (result == null) {\n throw StateError('Invalid value $value for bit flag enum Color');\n }\n return result;\n }\n\n static Color? _createOrNull(int? value) =>\n value == null ? null : Color.fromValue(value);\n\n static const int minValue = 0;\n static const int maxValue = 2;\n static bool containsValue(int value) => values.containsKey(value);\n\n static const Color Red = Color._(0);\n static const Color Green = Color._(1);\n static const Color Blue = Color._(2);\n static const Map values = {0: Red, 1: Green, 2: Blue};\n\n static const fb.Reader reader = _ColorReader();\n\n @override\n String toString() {\n return 'Color{value: $value}';\n }\n}\n\nclass _ColorReader extends fb.Reader {\n const _ColorReader();\n\n @override\n int get size => 1;\n\n @override\n Color read(fb.BufferContext bc, int offset) =>\n Color.fromValue(const fb.Int8Reader().read(bc, offset));\n}\n\nclass EquipmentTypeId {\n final int value;\n const EquipmentTypeId._(this.value);\n\n factory EquipmentTypeId.fromValue(int value) {\n final result = values[value];\n if (result == null) {\n throw StateError(\n 'Invalid value $value for bit flag enum EquipmentTypeId',\n );\n }\n return result;\n }\n\n static EquipmentTypeId? _createOrNull(int? value) =>\n value == null ? null : EquipmentTypeId.fromValue(value);\n\n static const int minValue = 0;\n static const int maxValue = 1;\n static bool containsValue(int value) => values.containsKey(value);\n\n static const EquipmentTypeId NONE = EquipmentTypeId._(0);\n static const EquipmentTypeId Weapon = EquipmentTypeId._(1);\n static const Map values = {0: NONE, 1: Weapon};\n\n static const fb.Reader reader = _EquipmentTypeIdReader();\n\n @override\n String toString() {\n return 'EquipmentTypeId{value: $value}';\n }\n}\n\nclass _EquipmentTypeIdReader extends fb.Reader {\n const _EquipmentTypeIdReader();\n\n @override\n int get size => 1;\n\n @override\n EquipmentTypeId read(fb.BufferContext bc, int offset) =>\n EquipmentTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));\n}\n\nclass Vec3 {\n Vec3._(this._bc, this._bcOffset);\n\n static const fb.Reader reader = _Vec3Reader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n double get x => const fb.Float32Reader().read(_bc, _bcOffset + 0);\n double get y => const fb.Float32Reader().read(_bc, _bcOffset + 4);\n double get z => const fb.Float32Reader().read(_bc, _bcOffset + 8);\n\n @override\n String toString() {\n return 'Vec3{x: $x, y: $y, z: $z}';\n }\n}\n\nclass _Vec3Reader extends fb.StructReader {\n const _Vec3Reader();\n\n @override\n int get size => 12;\n\n @override\n Vec3 createObject(fb.BufferContext bc, int offset) => Vec3._(bc, offset);\n}\n\nclass Vec3Builder {\n Vec3Builder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n int finish(double x, double y, double z) {\n fbBuilder.putFloat32(z);\n fbBuilder.putFloat32(y);\n fbBuilder.putFloat32(x);\n return fbBuilder.offset;\n }\n}\n\nclass Vec3ObjectBuilder extends fb.ObjectBuilder {\n final double _x;\n final double _y;\n final double _z;\n\n Vec3ObjectBuilder({required double x, required double y, required double z})\n : _x = x,\n _y = y,\n _z = z;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n fbBuilder.putFloat32(_z);\n fbBuilder.putFloat32(_y);\n fbBuilder.putFloat32(_x);\n return fbBuilder.offset;\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n\nclass Monster {\n Monster._(this._bc, this._bcOffset);\n factory Monster(List bytes) {\n final rootRef = fb.BufferContext.fromBytes(bytes);\n return reader.read(rootRef, 0);\n }\n\n static const fb.Reader reader = _MonsterReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n Vec3? get pos => Vec3.reader.vTableGetNullable(_bc, _bcOffset, 4);\n int get mana => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 6, 150);\n int get hp => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 8, 100);\n String? get name =>\n const fb.StringReader().vTableGetNullable(_bc, _bcOffset, 10);\n List? get inventory =>\n const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 14);\n Color get color =>\n Color.fromValue(const fb.Int8Reader().vTableGet(_bc, _bcOffset, 16, 2));\n List? get weapons => const fb.ListReader(\n Weapon.reader,\n ).vTableGetNullable(_bc, _bcOffset, 18);\n EquipmentTypeId? get equippedType => EquipmentTypeId._createOrNull(\n const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 20),\n );\n dynamic get equipped {\n switch (equippedType?.value) {\n case 1:\n return Weapon.reader.vTableGetNullable(_bc, _bcOffset, 22);\n default:\n return null;\n }\n }\n\n List? get path => const fb.ListReader(\n Vec3.reader,\n ).vTableGetNullable(_bc, _bcOffset, 24);\n\n @override\n String toString() {\n return 'Monster{pos: $pos, mana: $mana, hp: $hp, name: $name, inventory: $inventory, color: $color, weapons: $weapons, equippedType: $equippedType, equipped: $equipped, path: $path}';\n }\n}\n\nclass _MonsterReader extends fb.TableReader {\n const _MonsterReader();\n\n @override\n Monster createObject(fb.BufferContext bc, int offset) =>\n Monster._(bc, offset);\n}\n\nclass MonsterBuilder {\n MonsterBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n void begin() {\n fbBuilder.startTable(10);\n }\n\n int addPos(int offset) {\n fbBuilder.addStruct(0, offset);\n return fbBuilder.offset;\n }\n\n int addMana(int? mana) {\n fbBuilder.addInt16(1, mana);\n return fbBuilder.offset;\n }\n\n int addHp(int? hp) {\n fbBuilder.addInt16(2, hp);\n return fbBuilder.offset;\n }\n\n int addNameOffset(int? offset) {\n fbBuilder.addOffset(3, offset);\n return fbBuilder.offset;\n }\n\n int addInventoryOffset(int? offset) {\n fbBuilder.addOffset(5, offset);\n return fbBuilder.offset;\n }\n\n int addColor(Color? color) {\n fbBuilder.addInt8(6, color?.value);\n return fbBuilder.offset;\n }\n\n int addWeaponsOffset(int? offset) {\n fbBuilder.addOffset(7, offset);\n return fbBuilder.offset;\n }\n\n int addEquippedType(EquipmentTypeId? equippedType) {\n fbBuilder.addUint8(8, equippedType?.value);\n return fbBuilder.offset;\n }\n\n int addEquippedOffset(int? offset) {\n fbBuilder.addOffset(9, offset);\n return fbBuilder.offset;\n }\n\n int addPathOffset(int? offset) {\n fbBuilder.addOffset(10, offset);\n return fbBuilder.offset;\n }\n\n int finish() {\n return fbBuilder.endTable();\n }\n}\n\nclass MonsterObjectBuilder extends fb.ObjectBuilder {\n final Vec3ObjectBuilder? _pos;\n final int? _mana;\n final int? _hp;\n final String? _name;\n final List? _inventory;\n final Color? _color;\n final List? _weapons;\n final EquipmentTypeId? _equippedType;\n final dynamic _equipped;\n final List? _path;\n\n MonsterObjectBuilder({\n Vec3ObjectBuilder? pos,\n int? mana,\n int? hp,\n String? name,\n List? inventory,\n Color? color,\n List? weapons,\n EquipmentTypeId? equippedType,\n dynamic equipped,\n List? path,\n }) : _pos = pos,\n _mana = mana,\n _hp = hp,\n _name = name,\n _inventory = inventory,\n _color = color,\n _weapons = weapons,\n _equippedType = equippedType,\n _equipped = equipped,\n _path = path;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n final int? nameOffset = _name == null\n ? null\n : fbBuilder.writeString(_name!);\n final int? inventoryOffset = _inventory == null\n ? null\n : fbBuilder.writeListUint8(_inventory!);\n final int? weaponsOffset = _weapons == null\n ? null\n : fbBuilder.writeList(\n _weapons!.map((b) => b.getOrCreateOffset(fbBuilder)).toList(),\n );\n final int? equippedOffset = _equipped?.getOrCreateOffset(fbBuilder);\n final int? pathOffset = _path == null\n ? null\n : fbBuilder.writeListOfStructs(_path!);\n fbBuilder.startTable(10);\n if (_pos != null) {\n fbBuilder.addStruct(0, _pos!.finish(fbBuilder));\n }\n fbBuilder.addInt16(1, _mana);\n fbBuilder.addInt16(2, _hp);\n fbBuilder.addOffset(3, nameOffset);\n fbBuilder.addOffset(5, inventoryOffset);\n fbBuilder.addInt8(6, _color?.value);\n fbBuilder.addOffset(7, weaponsOffset);\n fbBuilder.addUint8(8, _equippedType?.value);\n fbBuilder.addOffset(9, equippedOffset);\n fbBuilder.addOffset(10, pathOffset);\n return fbBuilder.endTable();\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n\nclass Weapon {\n Weapon._(this._bc, this._bcOffset);\n factory Weapon(List bytes) {\n final rootRef = fb.BufferContext.fromBytes(bytes);\n return reader.read(rootRef, 0);\n }\n\n static const fb.Reader reader = _WeaponReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n String? get name =>\n const fb.StringReader().vTableGetNullable(_bc, _bcOffset, 4);\n int get damage => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 6, 0);\n\n @override\n String toString() {\n return 'Weapon{name: $name, damage: $damage}';\n }\n}\n\nclass _WeaponReader extends fb.TableReader {\n const _WeaponReader();\n\n @override\n Weapon createObject(fb.BufferContext bc, int offset) => Weapon._(bc, offset);\n}\n\nclass WeaponBuilder {\n WeaponBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n void begin() {\n fbBuilder.startTable(2);\n }\n\n int addNameOffset(int? offset) {\n fbBuilder.addOffset(0, offset);\n return fbBuilder.offset;\n }\n\n int addDamage(int? damage) {\n fbBuilder.addInt16(1, damage);\n return fbBuilder.offset;\n }\n\n int finish() {\n return fbBuilder.endTable();\n }\n}\n\nclass WeaponObjectBuilder extends fb.ObjectBuilder {\n final String? _name;\n final int? _damage;\n\n WeaponObjectBuilder({String? name, int? damage})\n : _name = name,\n _damage = damage;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n final int? nameOffset = _name == null\n ? null\n : fbBuilder.writeString(_name!);\n fbBuilder.startTable(2);\n fbBuilder.addOffset(0, nameOffset);\n fbBuilder.addInt16(1, _damage);\n return fbBuilder.endTable();\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n" }, { "path": "dart/lib/flat_buffers.dart", "content": "import 'dart:collection';\nimport 'dart:convert';\nimport 'dart:math';\nimport 'dart:typed_data';\n\nconst int _sizeofUint8 = 1;\nconst int _sizeofUint16 = 2;\nconst int _sizeofUint32 = 4;\nconst int _sizeofUint64 = 8;\nconst int _sizeofInt8 = 1;\nconst int _sizeofInt16 = 2;\nconst int _sizeofInt32 = 4;\nconst int _sizeofInt64 = 8;\nconst int _sizeofFloat32 = 4;\nconst int _sizeofFloat64 = 8;\n\n/// Callback used to invoke a struct builder's finish method.\n///\n/// This callback is used by other struct's `finish` methods to write the nested\n/// struct's fields inline.\ntypedef StructBuilder = void Function();\n\n/// Buffer with data and some context about it.\nclass BufferContext {\n final ByteData _buffer;\n\n ByteData get buffer => _buffer;\n\n /// Create from a FlatBuffer represented by a list of bytes (uint8).\n factory BufferContext.fromBytes(List byteList) => BufferContext(\n byteList is Uint8List\n ? byteList.buffer.asByteData(byteList.offsetInBytes)\n : ByteData.view(Uint8List.fromList(byteList).buffer),\n );\n\n /// Create from a FlatBuffer represented by ByteData.\n BufferContext(this._buffer);\n\n @pragma('vm:prefer-inline')\n int derefObject(int offset) => offset + _getUint32(offset);\n\n @pragma('vm:prefer-inline')\n Uint8List _asUint8List(int offset, int length) =>\n _buffer.buffer.asUint8List(_buffer.offsetInBytes + offset, length);\n\n @pragma('vm:prefer-inline')\n double _getFloat64(int offset) => _buffer.getFloat64(offset, Endian.little);\n\n @pragma('vm:prefer-inline')\n double _getFloat32(int offset) => _buffer.getFloat32(offset, Endian.little);\n\n @pragma('vm:prefer-inline')\n int _getInt64(int offset) => _buffer.getInt64(offset, Endian.little);\n\n @pragma('vm:prefer-inline')\n int _getInt32(int offset) => _buffer.getInt32(offset, Endian.little);\n\n @pragma('vm:prefer-inline')\n int _getInt16(int offset) => _buffer.getInt16(offset, Endian.little);\n\n @pragma('vm:prefer-inline')\n int _getInt8(int offset) => _buffer.getInt8(offset);\n\n @pragma('vm:prefer-inline')\n int _getUint64(int offset) => _buffer.getUint64(offset, Endian.little);\n\n @pragma('vm:prefer-inline')\n int _getUint32(int offset) => _buffer.getUint32(offset, Endian.little);\n\n @pragma('vm:prefer-inline')\n int _getUint16(int offset) => _buffer.getUint16(offset, Endian.little);\n\n @pragma('vm:prefer-inline')\n int _getUint8(int offset) => _buffer.getUint8(offset);\n}\n\n/// Interface implemented by the \"object-api\" classes (ending with \"T\").\nabstract class Packable {\n /// Serialize the object using the given builder, returning the offset.\n int pack(Builder fbBuilder);\n}\n\n/// Class implemented by typed builders generated by flatc.\nabstract class ObjectBuilder {\n int? _firstOffset;\n\n /// Can be used to write the data represented by this builder to the [Builder]\n /// and reuse the offset created in multiple tables.\n ///\n /// Note that this method assumes you call it using the same [Builder] instance\n /// every time. The returned offset is only good for the [Builder] used in the\n /// first call to this method.\n int getOrCreateOffset(Builder fbBuilder) {\n _firstOffset ??= finish(fbBuilder);\n return _firstOffset!;\n }\n\n /// Writes the data in this helper to the [Builder].\n int finish(Builder fbBuilder);\n\n /// Convenience method that will create a new [Builder], [finish]es the data,\n /// and returns the buffer as a [Uint8List] of bytes.\n Uint8List toBytes();\n}\n\n/// Class that helps building flat buffers.\nclass Builder {\n bool _finished = false;\n\n final int initialSize;\n\n /// The list of existing VTable(s).\n final List _vTables;\n\n final bool deduplicateTables;\n\n ByteData _buf;\n\n final Allocator _allocator;\n\n /// The maximum alignment that has been seen so far. If [_buf] has to be\n /// reallocated in the future (to insert room at its start for more bytes) the\n /// reallocation will need to be a multiple of this many bytes.\n int _maxAlign = 1;\n\n /// The number of bytes that have been written to the buffer so far. The\n /// most recently written byte is this many bytes from the end of [_buf].\n int _tail = 0;\n\n /// The location of the end of the current table, measured in bytes from the\n /// end of [_buf].\n int _currentTableEndTail = 0;\n\n _VTable? _currentVTable;\n\n /// Map containing all strings that have been written so far. This allows us\n /// to avoid duplicating strings.\n ///\n /// Allocated only if `internStrings` is set to true on the constructor.\n Map? _strings;\n\n /// Creates a new FlatBuffers Builder.\n ///\n /// `initialSize` is the initial array size in bytes. The [Builder] will\n /// automatically grow the array if/as needed. `internStrings`, if set to\n /// true, will cause [writeString] to pool strings in the buffer so that\n /// identical strings will always use the same offset in tables.\n Builder({\n this.initialSize = 1024,\n bool internStrings = false,\n Allocator allocator = const DefaultAllocator(),\n this.deduplicateTables = true,\n }) : _allocator = allocator,\n _buf = allocator.allocate(initialSize),\n _vTables = deduplicateTables ? [] : const [] {\n if (internStrings) {\n _strings = {};\n }\n }\n\n /// Calculate the finished buffer size (aligned).\n @pragma('vm:prefer-inline')\n int size() => _tail + ((-_tail) & (_maxAlign - 1));\n\n /// Add the [field] with the given boolean [value]. The field is not added if\n /// the [value] is equal to [def]. Booleans are stored as 8-bit fields with\n /// `0` for `false` and `1` for `true`.\n void addBool(int field, bool? value, [bool? def]) {\n assert(_inVTable);\n if (value != null && value != def) {\n _prepare(_sizeofUint8, 1);\n _trackField(field);\n _buf.setInt8(_buf.lengthInBytes - _tail, value ? 1 : 0);\n }\n }\n\n /// Add the [field] with the given 32-bit signed integer [value]. The field is\n /// not added if the [value] is equal to [def].\n void addInt32(int field, int? value, [int? def]) {\n assert(_inVTable);\n if (value != null && value != def) {\n _prepare(_sizeofInt32, 1);\n _trackField(field);\n _setInt32AtTail(_tail, value);\n }\n }\n\n /// Add the [field] with the given 32-bit signed integer [value]. The field is\n /// not added if the [value] is equal to [def].\n void addInt16(int field, int? value, [int? def]) {\n assert(_inVTable);\n if (value != null && value != def) {\n _prepare(_sizeofInt16, 1);\n _trackField(field);\n _setInt16AtTail(_tail, value);\n }\n }\n\n /// Add the [field] with the given 8-bit signed integer [value]. The field is\n /// not added if the [value] is equal to [def].\n void addInt8(int field, int? value, [int? def]) {\n assert(_inVTable);\n if (value != null && value != def) {\n _prepare(_sizeofInt8, 1);\n _trackField(field);\n _setInt8AtTail(_tail, value);\n }\n }\n\n void addStruct(int field, int offset) {\n assert(_inVTable);\n _trackField(field);\n _currentVTable!.addField(field, offset);\n }\n\n /// Add the [field] referencing an object with the given [offset].\n void addOffset(int field, int? offset) {\n assert(_inVTable);\n if (offset != null) {\n _prepare(_sizeofUint32, 1);\n _trackField(field);\n _setUint32AtTail(_tail, _tail - offset);\n }\n }\n\n /// Add the [field] with the given 32-bit unsigned integer [value]. The field\n /// is not added if the [value] is equal to [def].\n void addUint32(int field, int? value, [int? def]) {\n assert(_inVTable);\n if (value != null && value != def) {\n _prepare(_sizeofUint32, 1);\n _trackField(field);\n _setUint32AtTail(_tail, value);\n }\n }\n\n /// Add the [field] with the given 32-bit unsigned integer [value]. The field\n /// is not added if the [value] is equal to [def].\n void addUint16(int field, int? value, [int? def]) {\n assert(_inVTable);\n if (value != null && value != def) {\n _prepare(_sizeofUint16, 1);\n _trackField(field);\n _setUint16AtTail(_tail, value);\n }\n }\n\n /// Add the [field] with the given 8-bit unsigned integer [value]. The field\n /// is not added if the [value] is equal to [def].\n void addUint8(int field, int? value, [int? def]) {\n assert(_inVTable);\n if (value != null && value != def) {\n _prepare(_sizeofUint8, 1);\n _trackField(field);\n _setUint8AtTail(_tail, value);\n }\n }\n\n /// Add the [field] with the given 32-bit float [value]. The field\n /// is not added if the [value] is equal to [def].\n void addFloat32(int field, double? value, [double? def]) {\n assert(_inVTable);\n if (value != null && value != def) {\n _prepare(_sizeofFloat32, 1);\n _trackField(field);\n _setFloat32AtTail(_tail, value);\n }\n }\n\n /// Add the [field] with the given 64-bit double [value]. The field\n /// is not added if the [value] is equal to [def].\n void addFloat64(int field, double? value, [double? def]) {\n assert(_inVTable);\n if (value != null && value != def) {\n _prepare(_sizeofFloat64, 1);\n _trackField(field);\n _setFloat64AtTail(_tail, value);\n }\n }\n\n /// Add the [field] with the given 64-bit unsigned integer [value]. The field\n /// is not added if the [value] is equal to [def].\n void addUint64(int field, int? value, [double? def]) {\n assert(_inVTable);\n if (value != null && value != def) {\n _prepare(_sizeofUint64, 1);\n _trackField(field);\n _setUint64AtTail(_tail, value);\n }\n }\n\n /// Add the [field] with the given 64-bit unsigned integer [value]. The field\n /// is not added if the [value] is equal to [def].\n void addInt64(int field, int? value, [double? def]) {\n assert(_inVTable);\n if (value != null && value != def) {\n _prepare(_sizeofInt64, 1);\n _trackField(field);\n _setInt64AtTail(_tail, value);\n }\n }\n\n /// End the current table and return its offset.\n int endTable() {\n assert(_inVTable);\n // Prepare for writing the VTable.\n _prepare(_sizeofInt32, 1);\n final tableTail = _tail;\n // Prepare the size of the current table.\n final currentVTable = _currentVTable!;\n currentVTable.tableSize = tableTail - _currentTableEndTail;\n // Prepare the VTable to use for the current table.\n int? vTableTail;\n {\n currentVTable.computeFieldOffsets(tableTail);\n\n // Try to find an existing compatible VTable.\n if (deduplicateTables) {\n // Search backward - more likely to have recently used one\n for (var i = _vTables.length - 1; i >= 0; i--) {\n final vt2Offset = _vTables[i];\n final vt2Start = _buf.lengthInBytes - vt2Offset;\n final vt2Size = _buf.getUint16(vt2Start, Endian.little);\n\n if (currentVTable._vTableSize == vt2Size &&\n currentVTable._offsetsMatch(vt2Start, _buf)) {\n vTableTail = vt2Offset;\n break;\n }\n }\n }\n\n // Write a new VTable.\n if (vTableTail == null) {\n _prepare(_sizeofUint16, _currentVTable!.numOfUint16);\n vTableTail = _tail;\n currentVTable.tail = vTableTail;\n currentVTable.output(_buf, _buf.lengthInBytes - _tail);\n if (deduplicateTables) _vTables.add(currentVTable.tail);\n }\n }\n // Set the VTable offset.\n _setInt32AtTail(tableTail, vTableTail - tableTail);\n // Done with this table.\n _currentVTable = null;\n return tableTail;\n }\n\n /// Returns the finished buffer. You must call [finish] before accessing this.\n @pragma('vm:prefer-inline')\n Uint8List get buffer {\n assert(_finished);\n final finishedSize = size();\n return _buf.buffer.asUint8List(\n _buf.lengthInBytes - finishedSize,\n finishedSize,\n );\n }\n\n /// Finish off the creation of the buffer. The given [offset] is used as the\n /// root object offset, and usually references directly or indirectly every\n /// written object. If [fileIdentifier] is specified (and not `null`), it is\n /// interpreted as a 4-byte Latin-1 encoded string that should be placed at\n /// bytes 4-7 of the file.\n void finish(int offset, [String? fileIdentifier]) {\n final sizeBeforePadding = size();\n final requiredBytes = _sizeofUint32 * (fileIdentifier == null ? 1 : 2);\n _prepare(max(requiredBytes, _maxAlign), 1);\n final finishedSize = size();\n _setUint32AtTail(finishedSize, finishedSize - offset);\n if (fileIdentifier != null) {\n for (var i = 0; i < 4; i++) {\n _setUint8AtTail(\n finishedSize - _sizeofUint32 - i,\n fileIdentifier.codeUnitAt(i),\n );\n }\n }\n\n // zero out the added padding\n for (\n var i = sizeBeforePadding + 1;\n i <= finishedSize - requiredBytes;\n i++\n ) {\n _setUint8AtTail(i, 0);\n }\n _finished = true;\n }\n\n /// Writes a Float64 to the tail of the buffer after preparing space for it.\n ///\n /// Updates the [offset] pointer. This method is intended for use when writing structs to the buffer.\n void putFloat64(double value) {\n _prepare(_sizeofFloat64, 1);\n _setFloat64AtTail(_tail, value);\n }\n\n /// Writes a Float32 to the tail of the buffer after preparing space for it.\n ///\n /// Updates the [offset] pointer. This method is intended for use when writing structs to the buffer.\n void putFloat32(double value) {\n _prepare(_sizeofFloat32, 1);\n _setFloat32AtTail(_tail, value);\n }\n\n /// Writes a bool to the tail of the buffer after preparing space for it.\n /// Bools are represented as a Uint8, with the value set to '1' for true, and '0' for false\n ///\n /// Updates the [offset] pointer. This method is intended for use when writing structs to the buffer.\n void putBool(bool value) {\n _prepare(_sizeofUint8, 1);\n _buf.setInt8(_buf.lengthInBytes - _tail, value ? 1 : 0);\n }\n\n /// Writes a Int64 to the tail of the buffer after preparing space for it.\n ///\n /// Updates the [offset] pointer. This method is intended for use when writing structs to the buffer.\n void putInt64(int value) {\n _prepare(_sizeofInt64, 1);\n _setInt64AtTail(_tail, value);\n }\n\n /// Writes a Uint32 to the tail of the buffer after preparing space for it.\n ///\n /// Updates the [offset] pointer. This method is intended for use when writing structs to the buffer.\n void putInt32(int value) {\n _prepare(_sizeofInt32, 1);\n _setInt32AtTail(_tail, value);\n }\n\n /// Writes a Uint16 to the tail of the buffer after preparing space for it.\n ///\n /// Updates the [offset] pointer. This method is intended for use when writing structs to the buffer.\n void putInt16(int value) {\n _prepare(_sizeofInt16, 1);\n _setInt16AtTail(_tail, value);\n }\n\n /// Writes a Uint8 to the tail of the buffer after preparing space for it.\n ///\n /// Updates the [offset] pointer. This method is intended for use when writing structs to the buffer.\n void putInt8(int value) {\n _prepare(_sizeofInt8, 1);\n _buf.setInt8(_buf.lengthInBytes - _tail, value);\n }\n\n /// Writes a Uint64 to the tail of the buffer after preparing space for it.\n ///\n /// Updates the [offset] pointer. This method is intended for use when writing structs to the buffer.\n void putUint64(int value) {\n _prepare(_sizeofUint64, 1);\n _setUint64AtTail(_tail, value);\n }\n\n /// Writes a Uint32 to the tail of the buffer after preparing space for it.\n ///\n /// Updates the [offset] pointer. This method is intended for use when writing structs to the buffer.\n void putUint32(int value) {\n _prepare(_sizeofUint32, 1);\n _setUint32AtTail(_tail, value);\n }\n\n /// Writes a Uint16 to the tail of the buffer after preparing space for it.\n ///\n /// Updates the [offset] pointer. This method is intended for use when writing structs to the buffer.\n void putUint16(int value) {\n _prepare(_sizeofUint16, 1);\n _setUint16AtTail(_tail, value);\n }\n\n /// Writes a Uint8 to the tail of the buffer after preparing space for it.\n ///\n /// Updates the [offset] pointer. This method is intended for use when writing structs to the buffer.\n void putUint8(int value) {\n _prepare(_sizeofUint8, 1);\n _buf.setUint8(_buf.lengthInBytes - _tail, value);\n }\n\n /// Reset the builder and make it ready for filling a new buffer.\n void reset() {\n _finished = false;\n _maxAlign = 1;\n _tail = 0;\n _currentVTable = null;\n if (deduplicateTables) _vTables.clear();\n if (_strings != null) {\n _strings = {};\n }\n }\n\n /// Start a new table. Must be finished with [endTable] invocation.\n void startTable(int numFields) {\n assert(!_inVTable); // Inline tables are not supported.\n _currentVTable = _VTable(numFields);\n _currentTableEndTail = _tail;\n }\n\n /// Finish a Struct vector. Most callers should preferto use [writeListOfStructs].\n ///\n /// Most callers should prefer [writeListOfStructs].\n int endStructVector(int count) {\n putUint32(count);\n return _tail;\n }\n\n /// Writes a list of Structs to the buffer, returning the offset\n int writeListOfStructs(List structBuilders) {\n assert(!_inVTable);\n for (var i = structBuilders.length - 1; i >= 0; i--) {\n structBuilders[i].finish(this);\n }\n return endStructVector(structBuilders.length);\n }\n\n /// Write the given list of [values].\n int writeList(List values) {\n assert(!_inVTable);\n _prepare(_sizeofUint32, 1 + values.length);\n final result = _tail;\n var tail = _tail;\n _setUint32AtTail(tail, values.length);\n tail -= _sizeofUint32;\n for (final value in values) {\n _setUint32AtTail(tail, tail - value);\n tail -= _sizeofUint32;\n }\n return result;\n }\n\n /// Write the given list of 64-bit float [values].\n int writeListFloat64(List values) {\n assert(!_inVTable);\n _prepare(_sizeofFloat64, values.length, additionalBytes: _sizeofUint32);\n final result = _tail;\n var tail = _tail;\n _setUint32AtTail(tail, values.length);\n tail -= _sizeofUint32;\n for (final value in values) {\n _setFloat64AtTail(tail, value);\n tail -= _sizeofFloat64;\n }\n return result;\n }\n\n /// Write the given list of 32-bit float [values].\n int writeListFloat32(List values) {\n assert(!_inVTable);\n _prepare(_sizeofFloat32, 1 + values.length);\n final result = _tail;\n var tail = _tail;\n _setUint32AtTail(tail, values.length);\n tail -= _sizeofUint32;\n for (final value in values) {\n _setFloat32AtTail(tail, value);\n tail -= _sizeofFloat32;\n }\n return result;\n }\n\n /// Write the given list of signed 64-bit integer [values].\n int writeListInt64(List values) {\n assert(!_inVTable);\n _prepare(_sizeofInt64, values.length, additionalBytes: _sizeofUint32);\n final result = _tail;\n var tail = _tail;\n _setUint32AtTail(tail, values.length);\n tail -= _sizeofUint32;\n for (final value in values) {\n _setInt64AtTail(tail, value);\n tail -= _sizeofInt64;\n }\n return result;\n }\n\n /// Write the given list of signed 64-bit integer [values].\n int writeListUint64(List values) {\n assert(!_inVTable);\n _prepare(_sizeofUint64, values.length, additionalBytes: _sizeofUint32);\n final result = _tail;\n var tail = _tail;\n _setUint32AtTail(tail, values.length);\n tail -= _sizeofUint32;\n for (final value in values) {\n _setUint64AtTail(tail, value);\n tail -= _sizeofUint64;\n }\n return result;\n }\n\n /// Write the given list of signed 32-bit integer [values].\n int writeListInt32(List values) {\n assert(!_inVTable);\n _prepare(_sizeofUint32, 1 + values.length);\n final result = _tail;\n var tail = _tail;\n _setUint32AtTail(tail, values.length);\n tail -= _sizeofUint32;\n for (final value in values) {\n _setInt32AtTail(tail, value);\n tail -= _sizeofInt32;\n }\n return result;\n }\n\n /// Write the given list of unsigned 32-bit integer [values].\n int writeListUint32(List values) {\n assert(!_inVTable);\n _prepare(_sizeofUint32, 1 + values.length);\n final result = _tail;\n var tail = _tail;\n _setUint32AtTail(tail, values.length);\n tail -= _sizeofUint32;\n for (final value in values) {\n _setUint32AtTail(tail, value);\n tail -= _sizeofUint32;\n }\n return result;\n }\n\n /// Write the given list of signed 16-bit integer [values].\n int writeListInt16(List values) {\n assert(!_inVTable);\n _prepare(_sizeofUint32, 1, additionalBytes: 2 * values.length);\n final result = _tail;\n var tail = _tail;\n _setUint32AtTail(tail, values.length);\n tail -= _sizeofUint32;\n for (final value in values) {\n _setInt16AtTail(tail, value);\n tail -= _sizeofInt16;\n }\n return result;\n }\n\n /// Write the given list of unsigned 16-bit integer [values].\n int writeListUint16(List values) {\n assert(!_inVTable);\n _prepare(_sizeofUint32, 1, additionalBytes: 2 * values.length);\n final result = _tail;\n var tail = _tail;\n _setUint32AtTail(tail, values.length);\n tail -= _sizeofUint32;\n for (final value in values) {\n _setUint16AtTail(tail, value);\n tail -= _sizeofUint16;\n }\n return result;\n }\n\n /// Write the given list of bools as unsigend 8-bit integer [values].\n int writeListBool(List values) {\n return writeListUint8(values.map((b) => b ? 1 : 0).toList());\n }\n\n /// Write the given list of signed 8-bit integer [values].\n int writeListInt8(List values) {\n assert(!_inVTable);\n _prepare(_sizeofUint32, 1, additionalBytes: values.length);\n final result = _tail;\n var tail = _tail;\n _setUint32AtTail(tail, values.length);\n tail -= _sizeofUint32;\n for (final value in values) {\n _setInt8AtTail(tail, value);\n tail -= _sizeofUint8;\n }\n return result;\n }\n\n /// Write the given list of unsigned 8-bit integer [values].\n int writeListUint8(List values) {\n assert(!_inVTable);\n _prepare(_sizeofUint32, 1, additionalBytes: values.length);\n final result = _tail;\n var tail = _tail;\n _setUint32AtTail(tail, values.length);\n tail -= _sizeofUint32;\n for (final value in values) {\n _setUint8AtTail(tail, value);\n tail -= _sizeofUint8;\n }\n return result;\n }\n\n /// Write the given string [value] and return its offset.\n ///\n /// Dart strings are UTF-16 but must be stored as UTF-8 in FlatBuffers.\n /// If the given string consists only of ASCII characters, you can indicate\n /// enable [asciiOptimization]. In this mode, [writeString()] first tries to\n /// copy the ASCII string directly to the output buffer and if that fails\n /// (because there are no-ASCII characters in the string) it falls back and to\n /// the default UTF-16 -> UTF-8 conversion (with slight performance penalty).\n int writeString(String value, {bool asciiOptimization = false}) {\n assert(!_inVTable);\n if (_strings != null) {\n return _strings!.putIfAbsent(\n value,\n () => _writeString(value, asciiOptimization),\n );\n } else {\n return _writeString(value, asciiOptimization);\n }\n }\n\n int _writeString(String value, bool asciiOptimization) {\n if (asciiOptimization) {\n // [utf8.encode()] is slow (up to at least Dart SDK 2.13). If the given\n // string is ASCII we can just write it directly, without any conversion.\n final originalTail = _tail;\n if (_tryWriteASCIIString(value)) return _tail;\n // if non-ASCII: reset the output buffer position for [_writeUTFString()]\n _tail = originalTail;\n }\n _writeUTFString(value);\n return _tail;\n }\n\n // Try to write the string as ASCII, return false if there's a non-ascii char.\n @pragma('vm:prefer-inline')\n bool _tryWriteASCIIString(String value) {\n _prepare(4, 1, additionalBytes: value.length + 1);\n final length = value.length;\n var offset = _buf.lengthInBytes - _tail + 4;\n for (var i = 0; i < length; i++) {\n // utf16 code unit, e.g. for '†' it's [0x20 0x20], which is 8224 decimal.\n // ASCII characters go from 0x00 to 0x7F (which is 0 to 127 decimal).\n final char = value.codeUnitAt(i);\n if ((char & ~0x7F) != 0) {\n return false;\n }\n _buf.setUint8(offset++, char);\n }\n _buf.setUint8(offset, 0); // trailing zero\n _setUint32AtTail(_tail, value.length);\n return true;\n }\n\n @pragma('vm:prefer-inline')\n void _writeUTFString(String value) {\n final bytes = utf8.encode(value) as Uint8List;\n final length = bytes.length;\n _prepare(4, 1, additionalBytes: length + 1);\n _setUint32AtTail(_tail, length);\n var offset = _buf.lengthInBytes - _tail + 4;\n for (var i = 0; i < length; i++) {\n _buf.setUint8(offset++, bytes[i]);\n }\n _buf.setUint8(offset, 0); // trailing zero\n }\n\n /// Used to assert whether a \"Table\" is currently being built.\n ///\n /// If you hit `assert(!_inVTable())`, you're trying to add table fields\n /// without starting a table with [Builder.startTable()].\n ///\n /// If you hit `assert(_inVTable())`, you're trying to construct a\n /// Table/Vector/String during the construction of its parent table,\n /// between the MyTableBuilder and [Builder.endTable()].\n /// Move the creation of these sub-objects to before the MyTableBuilder to\n /// not get this assert.\n @pragma('vm:prefer-inline')\n bool get _inVTable => _currentVTable != null;\n\n /// The number of bytes that have been written to the buffer so far. The\n /// most recently written byte is this many bytes from the end of the buffer.\n @pragma('vm:prefer-inline')\n int get offset => _tail;\n\n /// Zero-pads the buffer, which may be required for some struct layouts.\n @pragma('vm:prefer-inline')\n void pad(int howManyBytes) {\n for (var i = 0; i < howManyBytes; i++) {\n putUint8(0);\n }\n }\n\n /// Prepare for writing the given `count` of scalars of the given `size`.\n /// Additionally allocate the specified `additionalBytes`. Update the current\n /// tail pointer to point at the allocated space.\n @pragma('vm:prefer-inline')\n void _prepare(int size, int count, {int additionalBytes = 0}) {\n assert(!_finished);\n // Update the alignment.\n if (_maxAlign < size) {\n _maxAlign = size;\n }\n // Prepare amount of required space.\n final dataSize = size * count + additionalBytes;\n final alignDelta = (-(_tail + dataSize)) & (size - 1);\n final bufSize = alignDelta + dataSize;\n // Ensure that we have the required amount of space.\n {\n final oldCapacity = _buf.lengthInBytes;\n if (_tail + bufSize > oldCapacity) {\n final desiredNewCapacity = (oldCapacity + bufSize) * 2;\n var deltaCapacity = desiredNewCapacity - oldCapacity;\n deltaCapacity += (-deltaCapacity) & (_maxAlign - 1);\n final newCapacity = oldCapacity + deltaCapacity;\n _buf = _allocator.resize(_buf, newCapacity, _tail, 0);\n }\n }\n\n // zero out the added padding\n for (var i = _tail + 1; i <= _tail + alignDelta; i++) {\n _setUint8AtTail(i, 0);\n }\n\n // Update the tail pointer.\n _tail += bufSize;\n }\n\n /// Record the offset of the given [field].\n @pragma('vm:prefer-inline')\n void _trackField(int field) => _currentVTable!.addField(field, _tail);\n\n @pragma('vm:prefer-inline')\n void _setFloat64AtTail(int tail, double x) =>\n _buf.setFloat64(_buf.lengthInBytes - tail, x, Endian.little);\n\n @pragma('vm:prefer-inline')\n void _setFloat32AtTail(int tail, double x) =>\n _buf.setFloat32(_buf.lengthInBytes - tail, x, Endian.little);\n\n @pragma('vm:prefer-inline')\n void _setUint64AtTail(int tail, int x) =>\n _buf.setUint64(_buf.lengthInBytes - tail, x, Endian.little);\n\n @pragma('vm:prefer-inline')\n void _setInt64AtTail(int tail, int x) =>\n _buf.setInt64(_buf.lengthInBytes - tail, x, Endian.little);\n\n @pragma('vm:prefer-inline')\n void _setInt32AtTail(int tail, int x) =>\n _buf.setInt32(_buf.lengthInBytes - tail, x, Endian.little);\n\n @pragma('vm:prefer-inline')\n void _setUint32AtTail(int tail, int x) =>\n _buf.setUint32(_buf.lengthInBytes - tail, x, Endian.little);\n\n @pragma('vm:prefer-inline')\n void _setInt16AtTail(int tail, int x) =>\n _buf.setInt16(_buf.lengthInBytes - tail, x, Endian.little);\n\n @pragma('vm:prefer-inline')\n void _setUint16AtTail(int tail, int x) =>\n _buf.setUint16(_buf.lengthInBytes - tail, x, Endian.little);\n\n @pragma('vm:prefer-inline')\n void _setInt8AtTail(int tail, int x) =>\n _buf.setInt8(_buf.lengthInBytes - tail, x);\n\n @pragma('vm:prefer-inline')\n void _setUint8AtTail(int tail, int x) =>\n _buf.setUint8(_buf.lengthInBytes - tail, x);\n}\n\n/// Reader of lists of boolean values.\n///\n/// The returned unmodifiable lists lazily read values on access.\nclass BoolListReader extends Reader> {\n const BoolListReader();\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofUint32;\n\n @override\n @pragma('vm:prefer-inline')\n List read(BufferContext bc, int offset) =>\n _FbBoolList(bc, bc.derefObject(offset));\n}\n\n/// The reader of booleans.\nclass BoolReader extends Reader {\n const BoolReader() : super();\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofUint8;\n\n @override\n @pragma('vm:prefer-inline')\n bool read(BufferContext bc, int offset) => bc._getInt8(offset) != 0;\n}\n\n/// The reader of lists of 64-bit float values.\n///\n/// The returned unmodifiable lists lazily read values on access.\nclass Float64ListReader extends Reader> {\n const Float64ListReader();\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofFloat64;\n\n @override\n @pragma('vm:prefer-inline')\n List read(BufferContext bc, int offset) =>\n _FbFloat64List(bc, bc.derefObject(offset));\n}\n\nclass Float32ListReader extends Reader> {\n const Float32ListReader();\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofFloat32;\n\n @override\n @pragma('vm:prefer-inline')\n List read(BufferContext bc, int offset) =>\n _FbFloat32List(bc, bc.derefObject(offset));\n}\n\nclass Float64Reader extends Reader {\n const Float64Reader();\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofFloat64;\n\n @override\n @pragma('vm:prefer-inline')\n double read(BufferContext bc, int offset) => bc._getFloat64(offset);\n}\n\nclass Float32Reader extends Reader {\n const Float32Reader();\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofFloat32;\n\n @override\n @pragma('vm:prefer-inline')\n double read(BufferContext bc, int offset) => bc._getFloat32(offset);\n}\n\nclass Int64Reader extends Reader {\n const Int64Reader() : super();\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofInt64;\n\n @override\n @pragma('vm:prefer-inline')\n int read(BufferContext bc, int offset) => bc._getInt64(offset);\n}\n\n/// The reader of signed 32-bit integers.\nclass Int32Reader extends Reader {\n const Int32Reader() : super();\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofInt32;\n\n @override\n @pragma('vm:prefer-inline')\n int read(BufferContext bc, int offset) => bc._getInt32(offset);\n}\n\n/// The reader of signed 32-bit integers.\nclass Int16Reader extends Reader {\n const Int16Reader() : super();\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofInt16;\n\n @override\n @pragma('vm:prefer-inline')\n int read(BufferContext bc, int offset) => bc._getInt16(offset);\n}\n\n/// The reader of 8-bit signed integers.\nclass Int8Reader extends Reader {\n const Int8Reader() : super();\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofInt8;\n\n @override\n @pragma('vm:prefer-inline')\n int read(BufferContext bc, int offset) => bc._getInt8(offset);\n}\n\n/// The reader of lists of objects. Lazy by default - see [lazy].\nclass ListReader extends Reader> {\n final Reader _elementReader;\n\n /// Enables lazy reading of the list\n ///\n /// If true, the returned unmodifiable list lazily reads objects on access.\n /// Therefore, the underlying buffer must not change while accessing the list.\n ///\n /// If false, reads the whole list immediately on access.\n final bool lazy;\n\n const ListReader(this._elementReader, {this.lazy = true});\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofUint32;\n\n @override\n List read(BufferContext bc, int offset) {\n final listOffset = bc.derefObject(offset);\n return lazy\n ? _FbGenericList(_elementReader, bc, listOffset)\n : List.generate(\n bc.buffer.getUint32(listOffset, Endian.little),\n (int index) => _elementReader.read(\n bc,\n listOffset + size + _elementReader.size * index,\n ),\n growable: true,\n );\n }\n}\n\n/// Object that can read a value at a [BufferContext].\nabstract class Reader {\n const Reader();\n\n /// The size of the value in bytes.\n int get size;\n\n /// Read the value at the given [offset] in [bc].\n T read(BufferContext bc, int offset);\n\n /// Read the value of the given [field] in the given [object].\n @pragma('vm:prefer-inline')\n T vTableGet(BufferContext object, int offset, int field, T defaultValue) {\n final fieldOffset = _vTableFieldOffset(object, offset, field);\n return fieldOffset == 0 ? defaultValue : read(object, offset + fieldOffset);\n }\n\n /// Read the value of the given [field] in the given [object].\n @pragma('vm:prefer-inline')\n T? vTableGetNullable(BufferContext object, int offset, int field) {\n final fieldOffset = _vTableFieldOffset(object, offset, field);\n return fieldOffset == 0 ? null : read(object, offset + fieldOffset);\n }\n\n @pragma('vm:prefer-inline')\n int _vTableFieldOffset(BufferContext object, int offset, int field) {\n final vTableSOffset = object._getInt32(offset);\n final vTableOffset = offset - vTableSOffset;\n final vTableSize = object._getUint16(vTableOffset);\n if (field >= vTableSize) return 0;\n return object._getUint16(vTableOffset + field);\n }\n}\n\n/// The reader of string values.\nclass StringReader extends Reader {\n final bool asciiOptimization;\n\n const StringReader({this.asciiOptimization = false}) : super();\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofUint32;\n\n @override\n @pragma('vm:prefer-inline')\n String read(BufferContext bc, int offset) {\n final strOffset = bc.derefObject(offset);\n final length = bc._getUint32(strOffset);\n final bytes = bc._asUint8List(strOffset + _sizeofUint32, length);\n if (asciiOptimization && _isLatin(bytes)) {\n return String.fromCharCodes(bytes);\n }\n return utf8.decode(bytes);\n }\n\n @pragma('vm:prefer-inline')\n static bool _isLatin(Uint8List bytes) {\n final length = bytes.length;\n for (var i = 0; i < length; i++) {\n if (bytes[i] > 127) {\n return false;\n }\n }\n return true;\n }\n}\n\n/// An abstract reader for structs.\nabstract class StructReader extends Reader {\n const StructReader();\n\n /// Return the object at `offset`.\n T createObject(BufferContext bc, int offset);\n\n @override\n T read(BufferContext bc, int offset) {\n return createObject(bc, offset);\n }\n}\n\n/// An abstract reader for tables.\nabstract class TableReader extends Reader {\n const TableReader();\n\n @override\n @pragma('vm:prefer-inline')\n int get size => 4;\n\n /// Return the object at [offset].\n T createObject(BufferContext bc, int offset);\n\n @override\n T read(BufferContext bc, int offset) {\n final objectOffset = bc.derefObject(offset);\n return createObject(bc, objectOffset);\n }\n}\n\n/// Reader of lists of unsigned 32-bit integer values.\n///\n/// The returned unmodifiable lists lazily read values on access.\nclass Uint32ListReader extends Reader> {\n const Uint32ListReader();\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofUint32;\n\n @override\n @pragma('vm:prefer-inline')\n List read(BufferContext bc, int offset) =>\n _FbUint32List(bc, bc.derefObject(offset));\n}\n\n/// The reader of unsigned 64-bit integers.\n///\n/// WARNING: May have compatibility issues with JavaScript\nclass Uint64Reader extends Reader {\n const Uint64Reader() : super();\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofUint64;\n\n @override\n @pragma('vm:prefer-inline')\n int read(BufferContext bc, int offset) => bc._getUint64(offset);\n}\n\n/// The reader of unsigned 32-bit integers.\nclass Uint32Reader extends Reader {\n const Uint32Reader() : super();\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofUint32;\n\n @override\n @pragma('vm:prefer-inline')\n int read(BufferContext bc, int offset) => bc._getUint32(offset);\n}\n\n/// Reader of lists of unsigned 32-bit integer values.\n///\n/// The returned unmodifiable lists lazily read values on access.\nclass Uint16ListReader extends Reader> {\n const Uint16ListReader();\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofUint32;\n\n @override\n @pragma('vm:prefer-inline')\n List read(BufferContext bc, int offset) =>\n _FbUint16List(bc, bc.derefObject(offset));\n}\n\n/// The reader of unsigned 32-bit integers.\nclass Uint16Reader extends Reader {\n const Uint16Reader() : super();\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofUint16;\n\n @override\n @pragma('vm:prefer-inline')\n int read(BufferContext bc, int offset) => bc._getUint16(offset);\n}\n\n/// Reader of unmodifiable binary data (a list of unsigned 8-bit integers).\nclass Uint8ListReader extends Reader> {\n /// Enables lazy reading of the list\n ///\n /// If true, the returned unmodifiable list lazily reads bytes on access.\n /// Therefore, the underlying buffer must not change while accessing the list.\n ///\n /// If false, reads the whole list immediately as an Uint8List.\n final bool lazy;\n\n const Uint8ListReader({this.lazy = true});\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofUint32;\n\n @override\n @pragma('vm:prefer-inline')\n List read(BufferContext bc, int offset) {\n final listOffset = bc.derefObject(offset);\n if (lazy) return _FbUint8List(bc, listOffset);\n\n final length = bc._getUint32(listOffset);\n final result = Uint8List(length);\n var pos = listOffset + _sizeofUint32;\n for (var i = 0; i < length; i++, pos++) {\n result[i] = bc._getUint8(pos);\n }\n return result;\n }\n}\n\n/// The reader of unsigned 8-bit integers.\nclass Uint8Reader extends Reader {\n const Uint8Reader() : super();\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofUint8;\n\n @override\n @pragma('vm:prefer-inline')\n int read(BufferContext bc, int offset) => bc._getUint8(offset);\n}\n\n/// Reader of unmodifiable binary data (a list of signed 8-bit integers).\nclass Int8ListReader extends Reader> {\n /// Enables lazy reading of the list\n ///\n /// If true, the returned unmodifiable list lazily reads bytes on access.\n /// Therefore, the underlying buffer must not change while accessing the list.\n ///\n /// If false, reads the whole list immediately as an Uint8List.\n final bool lazy;\n\n const Int8ListReader({this.lazy = true});\n\n @override\n @pragma('vm:prefer-inline')\n int get size => _sizeofUint32;\n\n @override\n @pragma('vm:prefer-inline')\n List read(BufferContext bc, int offset) {\n final listOffset = bc.derefObject(offset);\n if (lazy) return _FbUint8List(bc, listOffset);\n\n final length = bc._getUint32(listOffset);\n final result = Int8List(length);\n var pos = listOffset + _sizeofUint32;\n for (var i = 0; i < length; i++, pos++) {\n result[i] = bc._getInt8(pos);\n }\n return result;\n }\n}\n\n/// The list backed by 64-bit values - Uint64 length and Float64.\nclass _FbFloat64List extends _FbList {\n _FbFloat64List(BufferContext bc, int offset) : super(bc, offset);\n\n @override\n @pragma('vm:prefer-inline')\n double operator [](int i) => bc._getFloat64(offset + 4 + 8 * i);\n}\n\n/// The list backed by 32-bit values - Float32.\nclass _FbFloat32List extends _FbList {\n _FbFloat32List(BufferContext bc, int offset) : super(bc, offset);\n\n @override\n @pragma('vm:prefer-inline')\n double operator [](int i) => bc._getFloat32(offset + 4 + 4 * i);\n}\n\n/// List backed by a generic object which may have any size.\nclass _FbGenericList extends _FbList {\n final Reader elementReader;\n\n List? _items;\n\n _FbGenericList(this.elementReader, BufferContext bp, int offset)\n : super(bp, offset);\n\n @override\n @pragma('vm:prefer-inline')\n E operator [](int i) {\n _items ??= List.filled(length, null);\n var item = _items![i];\n if (item == null) {\n item = elementReader.read(bc, offset + 4 + elementReader.size * i);\n _items![i] = item;\n }\n return item!;\n }\n}\n\n/// The base class for immutable lists read from flat buffers.\nabstract class _FbList extends Object with ListMixin implements List {\n final BufferContext bc;\n final int offset;\n int? _length;\n\n _FbList(this.bc, this.offset);\n\n @override\n @pragma('vm:prefer-inline')\n int get length => _length ??= bc._getUint32(offset);\n\n @override\n set length(int i) => throw StateError('Attempt to modify immutable list');\n\n @override\n void operator []=(int i, E e) =>\n throw StateError('Attempt to modify immutable list');\n}\n\n/// List backed by 32-bit unsigned integers.\nclass _FbUint32List extends _FbList {\n _FbUint32List(BufferContext bc, int offset) : super(bc, offset);\n\n @override\n @pragma('vm:prefer-inline')\n int operator [](int i) => bc._getUint32(offset + 4 + 4 * i);\n}\n\n/// List backed by 16-bit unsigned integers.\nclass _FbUint16List extends _FbList {\n _FbUint16List(BufferContext bc, int offset) : super(bc, offset);\n\n @override\n @pragma('vm:prefer-inline')\n int operator [](int i) => bc._getUint16(offset + 4 + 2 * i);\n}\n\n/// List backed by 8-bit unsigned integers.\nclass _FbUint8List extends _FbList {\n _FbUint8List(BufferContext bc, int offset) : super(bc, offset);\n\n @override\n @pragma('vm:prefer-inline')\n int operator [](int i) => bc._getUint8(offset + 4 + i);\n}\n\n/// List backed by 8-bit signed integers.\nclass _FbInt8List extends _FbList {\n _FbInt8List(BufferContext bc, int offset) : super(bc, offset);\n\n @override\n @pragma('vm:prefer-inline')\n int operator [](int i) => bc._getInt8(offset + 4 + i);\n}\n\n/// List backed by 8-bit unsigned integers.\nclass _FbBoolList extends _FbList {\n _FbBoolList(BufferContext bc, int offset) : super(bc, offset);\n\n @override\n @pragma('vm:prefer-inline')\n bool operator [](int i) => bc._getUint8(offset + 4 + i) == 1 ? true : false;\n}\n\n/// Class that describes the structure of a table.\nclass _VTable {\n static const int _metadataLength = 4;\n\n final int numFields;\n\n // Note: fieldOffsets start as \"tail offsets\" and are then transformed by\n // [computeFieldOffsets()] to actual offsets when a table is finished.\n final Uint32List fieldOffsets;\n bool offsetsComputed = false;\n\n _VTable(this.numFields) : fieldOffsets = Uint32List(numFields);\n\n /// The size of the table that uses this VTable.\n int tableSize = 0;\n\n /// The tail of this VTable. It is used to share the same VTable between\n /// multiple tables of identical structure.\n int tail = 0;\n\n int get _vTableSize => numOfUint16 * _sizeofUint16;\n\n int get numOfUint16 => 1 + 1 + numFields;\n\n @pragma('vm:prefer-inline')\n void addField(int field, int offset) {\n assert(!offsetsComputed);\n assert(offset > 0); // it's impossible for field to start at the buffer end\n assert(offset <= 4294967295); // uint32 max\n fieldOffsets[field] = offset;\n }\n\n @pragma('vm:prefer-inline')\n bool _offsetsMatch(int vt2Start, ByteData buf) {\n assert(offsetsComputed);\n for (var i = 0; i < numFields; i++) {\n if (fieldOffsets[i] !=\n buf.getUint16(vt2Start + _metadataLength + (2 * i), Endian.little)) {\n return false;\n }\n }\n return true;\n }\n\n /// Fill the [fieldOffsets] field.\n @pragma('vm:prefer-inline')\n void computeFieldOffsets(int tableTail) {\n assert(!offsetsComputed);\n offsetsComputed = true;\n for (var i = 0; i < numFields; i++) {\n if (fieldOffsets[i] != 0) {\n fieldOffsets[i] = tableTail - fieldOffsets[i];\n }\n }\n }\n\n /// Outputs this VTable to [buf], which is is expected to be aligned to 16-bit\n /// and have at least [numOfUint16] 16-bit words available.\n @pragma('vm:prefer-inline')\n void output(ByteData buf, int bufOffset) {\n assert(offsetsComputed);\n // VTable size.\n buf.setUint16(bufOffset, numOfUint16 * 2, Endian.little);\n bufOffset += 2;\n // Table size.\n buf.setUint16(bufOffset, tableSize, Endian.little);\n bufOffset += 2;\n // Field offsets.\n for (var i = 0; i < numFields; i++) {\n buf.setUint16(bufOffset, fieldOffsets[i], Endian.little);\n bufOffset += 2;\n }\n }\n}\n\n/// The interface that [Builder] uses to allocate buffers for encoding.\nabstract class Allocator {\n const Allocator();\n\n /// Allocate a [ByteData] buffer of a given size.\n ByteData allocate(int size);\n\n /// Free the given [ByteData] buffer previously allocated by [allocate].\n void deallocate(ByteData data);\n\n /// Reallocate [newSize] bytes of memory, replacing the old [oldData]. This\n /// grows downwards, and is intended specifically for use with [Builder].\n /// Params [inUseBack] and [inUseFront] indicate how much of [oldData] is\n /// actually in use at each end, and needs to be copied.\n ByteData resize(\n ByteData oldData,\n int newSize,\n int inUseBack,\n int inUseFront,\n ) {\n final newData = allocate(newSize);\n _copyDownward(oldData, newData, inUseBack, inUseFront);\n deallocate(oldData);\n return newData;\n }\n\n /// Called by [resize] to copy memory from [oldData] to [newData]. Only\n /// memory of size [inUseFront] and [inUseBack] will be copied from the front\n /// and back of the old memory allocation.\n void _copyDownward(\n ByteData oldData,\n ByteData newData,\n int inUseBack,\n int inUseFront,\n ) {\n if (inUseBack != 0) {\n newData.buffer.asUint8List().setAll(\n newData.lengthInBytes - inUseBack,\n oldData.buffer.asUint8List().getRange(\n oldData.lengthInBytes - inUseBack,\n oldData.lengthInBytes,\n ),\n );\n }\n if (inUseFront != 0) {\n newData.buffer.asUint8List().setAll(\n 0,\n oldData.buffer.asUint8List().getRange(0, inUseFront),\n );\n }\n }\n}\n\nclass DefaultAllocator extends Allocator {\n const DefaultAllocator();\n\n @override\n ByteData allocate(int size) => ByteData(size);\n\n @override\n void deallocate(ByteData data) {\n // nothing to do, it's garbage-collected\n }\n}\n" }, { "path": "dart/lib/flex_buffers.dart", "content": "export 'src/builder.dart';\nexport 'src/reference.dart';\n" }, { "path": "dart/lib/src/builder.dart", "content": "import 'dart:convert';\nimport 'dart:typed_data';\n\nimport 'types.dart';\n\n/// The main builder class for creation of a FlexBuffer.\nclass Builder {\n ByteData _buffer;\n List<_StackValue> _stack = [];\n List<_StackPointer> _stackPointers = [];\n int _offset = 0;\n bool _finished = false;\n final Map _stringCache = {};\n final Map _keyCache = {};\n final Map<_KeysHash, _StackValue> _keyVectorCache = {};\n final Map _indirectIntCache = {};\n final Map _indirectDoubleCache = {};\n\n /// Instantiate the builder if you intent to gradually build up the buffer by calling\n /// add... methods and calling [finish] to receive the resulting byte array.\n ///\n /// The default size of internal buffer is set to 2048. Provide a different value in order to avoid buffer copies.\n Builder({int size = 2048}) : _buffer = ByteData(size);\n\n /// Use this method in order to turn an object into a FlexBuffer directly.\n ///\n /// Use the manual instantiation of the [Builder] and gradual addition of values, if performance is more important than convenience.\n static ByteBuffer buildFromObject(Object? value) {\n final builder = Builder();\n builder._add(value);\n final buffer = builder.finish();\n final byteData = ByteData(buffer.lengthInBytes);\n byteData.buffer.asUint8List().setAll(0, buffer);\n return byteData.buffer;\n }\n\n void _add(Object? value) {\n if (value == null) {\n addNull();\n } else if (value is bool) {\n addBool(value);\n } else if (value is int) {\n addInt(value);\n } else if (value is double) {\n addDouble(value);\n } else if (value is ByteBuffer) {\n addBlob(value);\n } else if (value is String) {\n addString(value);\n } else if (value is List) {\n startVector();\n for (var i = 0; i < value.length; i++) {\n _add(value[i]);\n }\n end();\n } else if (value is Map) {\n startMap();\n value.forEach((key, value) {\n addKey(key);\n _add(value);\n });\n end();\n } else {\n throw UnsupportedError('Value of unexpected type: $value');\n }\n }\n\n /// Use this method if you want to store a null value.\n ///\n /// Specifically useful when building up a vector where values can be null.\n void addNull() {\n _integrityCheckOnValueAddition();\n _stack.add(_StackValue.withNull());\n }\n\n /// Adds a string value.\n void addInt(int value) {\n _integrityCheckOnValueAddition();\n _stack.add(_StackValue.withInt(value));\n }\n\n /// Adds a bool value.\n void addBool(bool value) {\n _integrityCheckOnValueAddition();\n _stack.add(_StackValue.withBool(value));\n }\n\n /// Adds a double value.\n void addDouble(double value) {\n _integrityCheckOnValueAddition();\n _stack.add(_StackValue.withDouble(value));\n }\n\n /// Adds a string value.\n void addString(String value) {\n _integrityCheckOnValueAddition();\n if (_stringCache.containsKey(value)) {\n _stack.add(_stringCache[value]!);\n return;\n }\n final utf8String = utf8.encode(value);\n final length = utf8String.length;\n final bitWidth = BitWidthUtil.uwidth(length);\n final byteWidth = _align(bitWidth);\n _writeUInt(length, byteWidth);\n final stringOffset = _offset;\n final newOffset = _newOffset(length + 1);\n _pushBuffer(utf8String);\n _offset = newOffset;\n final stackValue = _StackValue.withOffset(\n stringOffset,\n ValueType.String,\n bitWidth,\n );\n _stack.add(stackValue);\n _stringCache[value] = stackValue;\n }\n\n /// This methods adds a key to a map and should be followed by an add... value call.\n ///\n /// It also implies that you call this method only after you called [startMap].\n void addKey(String value) {\n _integrityCheckOnKeyAddition();\n if (_keyCache.containsKey(value)) {\n _stack.add(_keyCache[value]!);\n return;\n }\n final utf8String = utf8.encode(value);\n final length = utf8String.length;\n final keyOffset = _offset;\n final newOffset = _newOffset(length + 1);\n _pushBuffer(utf8String);\n _offset = newOffset;\n final stackValue = _StackValue.withOffset(\n keyOffset,\n ValueType.Key,\n BitWidth.width8,\n );\n _stack.add(stackValue);\n _keyCache[value] = stackValue;\n }\n\n /// Adds a byte array.\n ///\n /// This method can be used to store any generic BLOB.\n void addBlob(ByteBuffer value) {\n _integrityCheckOnValueAddition();\n final length = value.lengthInBytes;\n final bitWidth = BitWidthUtil.uwidth(length);\n final byteWidth = _align(bitWidth);\n _writeUInt(length, byteWidth);\n final blobOffset = _offset;\n final newOffset = _newOffset(length);\n _pushBuffer(value.asUint8List());\n _offset = newOffset;\n final stackValue = _StackValue.withOffset(\n blobOffset,\n ValueType.Blob,\n bitWidth,\n );\n _stack.add(stackValue);\n }\n\n /// Stores int value indirectly in the buffer.\n ///\n /// Adding large integer values indirectly might be beneficial if those values suppose to be store in a vector together with small integer values.\n /// This is due to the fact that FlexBuffers will add padding to small integer values, if they are stored together with large integer values.\n /// When we add integer indirectly the vector of ints will contain not the value itself, but only the relative offset to the value.\n /// By setting the [cache] parameter to true, you make sure that the builder tracks added int value and performs deduplication.\n void addIntIndirectly(int value, {bool cache = false}) {\n _integrityCheckOnValueAddition();\n if (_indirectIntCache.containsKey(value)) {\n _stack.add(_indirectIntCache[value]!);\n return;\n }\n final stackValue = _StackValue.withInt(value);\n final byteWidth = _align(stackValue.width);\n final newOffset = _newOffset(byteWidth);\n final valueOffset = _offset;\n _pushBuffer(stackValue.asU8List(stackValue.width));\n final stackOffset = _StackValue.withOffset(\n valueOffset,\n ValueType.IndirectInt,\n stackValue.width,\n );\n _stack.add(stackOffset);\n _offset = newOffset;\n if (cache) {\n _indirectIntCache[value] = stackOffset;\n }\n }\n\n /// Stores double value indirectly in the buffer.\n ///\n /// 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.\n /// 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.\n /// By setting the [cache] parameter to true, you make sure that the builder tracks already added double value and performs deduplication.\n void addDoubleIndirectly(double value, {bool cache = false}) {\n _integrityCheckOnValueAddition();\n if (cache && _indirectDoubleCache.containsKey(value)) {\n _stack.add(_indirectDoubleCache[value]!);\n return;\n }\n final stackValue = _StackValue.withDouble(value);\n final byteWidth = _align(stackValue.width);\n final newOffset = _newOffset(byteWidth);\n final valueOffset = _offset;\n _pushBuffer(stackValue.asU8List(stackValue.width));\n final stackOffset = _StackValue.withOffset(\n valueOffset,\n ValueType.IndirectFloat,\n stackValue.width,\n );\n _stack.add(stackOffset);\n _offset = newOffset;\n if (cache) {\n _indirectDoubleCache[value] = stackOffset;\n }\n }\n\n /// This method starts a vector definition and needs to be followed by 0 to n add... value calls.\n ///\n /// The vector definition needs to be finished with an [end] call.\n /// It is also possible to add nested vector or map by calling [startVector] / [startMap].\n void startVector() {\n _integrityCheckOnValueAddition();\n _stackPointers.add(_StackPointer(_stack.length, true));\n }\n\n /// This method starts a map definition.\n ///\n /// This method call needs to be followed by 0 to n [addKey] + add... value calls.\n /// The map definition needs to be finished with an [end] call.\n /// It is also possible to add nested vector or map by calling [startVector] / [startMap] after calling [addKey].\n void startMap() {\n _integrityCheckOnValueAddition();\n _stackPointers.add(_StackPointer(_stack.length, false));\n }\n\n /// Marks that the addition of values to the last vector, or map have ended.\n void end() {\n final pointer = _stackPointers.removeLast();\n if (pointer.isVector) {\n _endVector(pointer);\n } else {\n _sortKeysAndEndMap(pointer);\n }\n }\n\n /// Finish building the FlatBuffer and return array of bytes.\n ///\n /// Can be called multiple times, to get the array of bytes.\n /// After the first call, adding values, or starting vectors / maps will result in an exception.\n Uint8List finish() {\n if (_finished == false) {\n _finish();\n }\n return _buffer.buffer.asUint8List(0, _offset);\n }\n\n /// Builds a FlatBuffer with current state without finishing the builder.\n ///\n /// Creates an internal temporary copy of current builder and finishes the copy.\n /// Use this method, when the state of a long lasting builder need to be persisted periodically.\n ByteBuffer snapshot() {\n final tmp = Builder(size: _offset + 200);\n tmp._offset = _offset;\n tmp._stack = List.from(_stack);\n tmp._stackPointers = List.from(_stackPointers);\n tmp._buffer.buffer.asUint8List().setAll(\n 0,\n _buffer.buffer.asUint8List(0, _offset),\n );\n for (var i = 0; i < tmp._stackPointers.length; i++) {\n tmp.end();\n }\n final buffer = tmp.finish();\n final bd = ByteData(buffer.lengthInBytes);\n bd.buffer.asUint8List().setAll(0, buffer);\n return bd.buffer;\n }\n\n void _integrityCheckOnValueAddition() {\n if (_finished) {\n throw StateError('Adding values after finish is prohibited');\n }\n if (_stackPointers.isNotEmpty && _stackPointers.last.isVector == false) {\n if (_stack.last.type != ValueType.Key) {\n throw StateError(\n 'Adding value to a map before adding a key is prohibited',\n );\n }\n }\n }\n\n void _integrityCheckOnKeyAddition() {\n if (_finished) {\n throw StateError('Adding values after finish is prohibited');\n }\n if (_stackPointers.isEmpty || _stackPointers.last.isVector) {\n throw StateError('Adding key before staring a map is prohibited');\n }\n }\n\n void _finish() {\n if (_stack.length != 1) {\n throw StateError(\n 'Stack has to be exactly 1, but is ${_stack.length}. You have to end all started vectors and maps, before calling [finish]',\n );\n }\n final value = _stack[0];\n final byteWidth = _align(value.elementWidth(_offset, 0));\n _writeStackValue(value, byteWidth);\n _writeUInt(value.storedPackedType(), 1);\n _writeUInt(byteWidth, 1);\n _finished = true;\n }\n\n _StackValue _createVector(\n int start,\n int vecLength,\n int step, [\n _StackValue? keys,\n ]) {\n var bitWidth = BitWidthUtil.uwidth(vecLength);\n var prefixElements = 1;\n if (keys != null) {\n var elemWidth = keys.elementWidth(_offset, 0);\n if (elemWidth.index > bitWidth.index) {\n bitWidth = elemWidth;\n }\n prefixElements += 2;\n }\n var vectorType = ValueType.Key;\n var typed = keys == null;\n for (var i = start; i < _stack.length; i += step) {\n final elemWidth = _stack[i].elementWidth(_offset, i + prefixElements);\n if (elemWidth.index > bitWidth.index) {\n bitWidth = elemWidth;\n }\n if (i == start) {\n vectorType = _stack[i].type;\n typed &= ValueTypeUtils.isTypedVectorElement(vectorType);\n } else {\n if (vectorType != _stack[i].type) {\n typed = false;\n }\n }\n }\n final byteWidth = _align(bitWidth);\n final fix =\n typed & ValueTypeUtils.isNumber(vectorType) &&\n vecLength >= 2 &&\n vecLength <= 4;\n if (keys != null) {\n _writeStackValue(keys, byteWidth);\n _writeUInt(1 << keys.width.index, byteWidth);\n }\n if (fix == false) {\n _writeUInt(vecLength, byteWidth);\n }\n final vecOffset = _offset;\n for (var i = start; i < _stack.length; i += step) {\n _writeStackValue(_stack[i], byteWidth);\n }\n if (typed == false) {\n for (var i = start; i < _stack.length; i += step) {\n _writeUInt(_stack[i].storedPackedType(), 1);\n }\n }\n if (keys != null) {\n return _StackValue.withOffset(vecOffset, ValueType.Map, bitWidth);\n }\n if (typed) {\n final vType = ValueTypeUtils.toTypedVector(\n vectorType,\n fix ? vecLength : 0,\n );\n return _StackValue.withOffset(vecOffset, vType, bitWidth);\n }\n return _StackValue.withOffset(vecOffset, ValueType.Vector, bitWidth);\n }\n\n void _endVector(_StackPointer pointer) {\n final vecLength = _stack.length - pointer.stackPosition;\n final vec = _createVector(pointer.stackPosition, vecLength, 1);\n _stack.removeRange(pointer.stackPosition, _stack.length);\n _stack.add(vec);\n }\n\n void _sortKeysAndEndMap(_StackPointer pointer) {\n if (((_stack.length - pointer.stackPosition) & 1) == 1) {\n throw StateError(\n 'The stack needs to hold key value pairs (even number of elements). Check if you combined [addKey] with add... method calls properly.',\n );\n }\n\n var sorted = true;\n for (var i = pointer.stackPosition; i < _stack.length - 2; i += 2) {\n if (_shouldFlip(_stack[i], _stack[i + 2])) {\n sorted = false;\n break;\n }\n }\n\n if (sorted == false) {\n for (var i = pointer.stackPosition; i < _stack.length; i += 2) {\n var flipIndex = i;\n for (var j = i + 2; j < _stack.length; j += 2) {\n if (_shouldFlip(_stack[flipIndex], _stack[j])) {\n flipIndex = j;\n }\n }\n if (flipIndex != i) {\n var k = _stack[flipIndex];\n var v = _stack[flipIndex + 1];\n _stack[flipIndex] = _stack[i];\n _stack[flipIndex + 1] = _stack[i + 1];\n _stack[i] = k;\n _stack[i + 1] = v;\n }\n }\n }\n _endMap(pointer);\n }\n\n void _endMap(_StackPointer pointer) {\n final vecLength = (_stack.length - pointer.stackPosition) >> 1;\n final offsets = [];\n for (var i = pointer.stackPosition; i < _stack.length; i += 2) {\n offsets.add(_stack[i].offset!);\n }\n final keysHash = _KeysHash(offsets);\n _StackValue? keysStackValue;\n if (_keyVectorCache.containsKey(keysHash)) {\n keysStackValue = _keyVectorCache[keysHash];\n } else {\n keysStackValue = _createVector(pointer.stackPosition, vecLength, 2);\n _keyVectorCache[keysHash] = keysStackValue;\n }\n final vec = _createVector(\n pointer.stackPosition + 1,\n vecLength,\n 2,\n keysStackValue,\n );\n _stack.removeRange(pointer.stackPosition, _stack.length);\n _stack.add(vec);\n }\n\n bool _shouldFlip(_StackValue v1, _StackValue v2) {\n if (v1.type != ValueType.Key || v2.type != ValueType.Key) {\n throw StateError(\n 'Stack values are not keys $v1 | $v2. Check if you combined [addKey] with add... method calls properly.',\n );\n }\n\n late int c1, c2;\n var index = 0;\n do {\n c1 = _buffer.getUint8(v1.offset! + index);\n c2 = _buffer.getUint8(v2.offset! + index);\n if (c2 < c1) return true;\n if (c1 < c2) return false;\n index += 1;\n } while (c1 != 0 && c2 != 0);\n return false;\n }\n\n int _align(BitWidth width) {\n final byteWidth = BitWidthUtil.toByteWidth(width);\n _offset += BitWidthUtil.paddingSize(_offset, byteWidth);\n return byteWidth;\n }\n\n void _writeStackValue(_StackValue value, int byteWidth) {\n final newOffset = _newOffset(byteWidth);\n if (value.isOffset) {\n final relativeOffset = _offset - value.offset!;\n if (byteWidth == 8 || relativeOffset < (1 << (byteWidth * 8))) {\n _writeUInt(relativeOffset, byteWidth);\n } else {\n throw StateError(\n 'Unexpected size $byteWidth. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new',\n );\n }\n } else {\n _pushBuffer(value.asU8List(BitWidthUtil.fromByteWidth(byteWidth)));\n }\n _offset = newOffset;\n }\n\n void _writeUInt(int value, int byteWidth) {\n final newOffset = _newOffset(byteWidth);\n _pushUInt(value, BitWidthUtil.fromByteWidth(byteWidth));\n _offset = newOffset;\n }\n\n int _newOffset(int newValueSize) {\n final newOffset = _offset + newValueSize;\n var size = _buffer.lengthInBytes;\n final prevSize = size;\n while (size < newOffset) {\n size <<= 1;\n }\n if (prevSize < size) {\n final newBuf = ByteData(size);\n newBuf.buffer.asUint8List().setAll(0, _buffer.buffer.asUint8List());\n _buffer = newBuf;\n }\n return newOffset;\n }\n\n void _pushInt(int value, BitWidth width) {\n switch (width) {\n case BitWidth.width8:\n _buffer.setInt8(_offset, value);\n break;\n case BitWidth.width16:\n _buffer.setInt16(_offset, value, Endian.little);\n break;\n case BitWidth.width32:\n _buffer.setInt32(_offset, value, Endian.little);\n break;\n case BitWidth.width64:\n _buffer.setInt64(_offset, value, Endian.little);\n break;\n }\n }\n\n void _pushUInt(int value, BitWidth width) {\n switch (width) {\n case BitWidth.width8:\n _buffer.setUint8(_offset, value);\n break;\n case BitWidth.width16:\n _buffer.setUint16(_offset, value, Endian.little);\n break;\n case BitWidth.width32:\n _buffer.setUint32(_offset, value, Endian.little);\n break;\n case BitWidth.width64:\n _buffer.setUint64(_offset, value, Endian.little);\n break;\n }\n }\n\n void _pushBuffer(List value) {\n _buffer.buffer.asUint8List().setAll(_offset, value);\n }\n}\n\nclass _StackValue {\n late Object _value;\n int? _offset;\n final ValueType _type;\n final BitWidth _width;\n\n _StackValue.withNull() : _type = ValueType.Null, _width = BitWidth.width8;\n\n _StackValue.withInt(int value)\n : _type = ValueType.Int,\n _width = BitWidthUtil.width(value),\n _value = value;\n\n _StackValue.withBool(bool value)\n : _type = ValueType.Bool,\n _width = BitWidth.width8,\n _value = value;\n\n _StackValue.withDouble(double value)\n : _type = ValueType.Float,\n _width = BitWidthUtil.width(value),\n _value = value;\n\n _StackValue.withOffset(int value, ValueType type, BitWidth width)\n : _offset = value,\n _type = type,\n _width = width;\n\n BitWidth storedWidth({BitWidth width = BitWidth.width8}) {\n return ValueTypeUtils.isInline(_type)\n ? BitWidthUtil.max(_width, width)\n : _width;\n }\n\n int storedPackedType({BitWidth width = BitWidth.width8}) {\n return ValueTypeUtils.packedType(_type, storedWidth(width: width));\n }\n\n BitWidth elementWidth(int size, int index) {\n if (ValueTypeUtils.isInline(_type)) return _width;\n final offset = _offset!;\n for (var i = 0; i < 4; i++) {\n final width = 1 << i;\n final bitWidth = BitWidthUtil.uwidth(\n size + BitWidthUtil.paddingSize(size, width) + index * width - offset,\n );\n if (1 << bitWidth.index == width) {\n return bitWidth;\n }\n }\n throw StateError(\n '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',\n );\n }\n\n List asU8List(BitWidth width) {\n if (ValueTypeUtils.isNumber(_type)) {\n if (_type == ValueType.Float) {\n if (width == BitWidth.width32) {\n final result = ByteData(4);\n result.setFloat32(0, _value as double, Endian.little);\n return result.buffer.asUint8List();\n } else {\n final result = ByteData(8);\n result.setFloat64(0, _value as double, Endian.little);\n return result.buffer.asUint8List();\n }\n } else {\n switch (width) {\n case BitWidth.width8:\n final result = ByteData(1);\n result.setInt8(0, _value as int);\n return result.buffer.asUint8List();\n case BitWidth.width16:\n final result = ByteData(2);\n result.setInt16(0, _value as int, Endian.little);\n return result.buffer.asUint8List();\n case BitWidth.width32:\n final result = ByteData(4);\n result.setInt32(0, _value as int, Endian.little);\n return result.buffer.asUint8List();\n case BitWidth.width64:\n final result = ByteData(8);\n result.setInt64(0, _value as int, Endian.little);\n return result.buffer.asUint8List();\n }\n }\n }\n if (_type == ValueType.Null) {\n final result = ByteData(1);\n result.setInt8(0, 0);\n return result.buffer.asUint8List();\n }\n if (_type == ValueType.Bool) {\n final result = ByteData(1);\n result.setInt8(0, _value as bool ? 1 : 0);\n return result.buffer.asUint8List();\n }\n\n throw StateError(\n 'Unexpected type: $_type. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new',\n );\n }\n\n ValueType get type {\n return _type;\n }\n\n BitWidth get width {\n return _width;\n }\n\n bool get isOffset {\n return !ValueTypeUtils.isInline(_type);\n }\n\n int? get offset => _offset;\n\n bool get isFloat32 {\n return _type == ValueType.Float && _width == BitWidth.width32;\n }\n}\n\nclass _StackPointer {\n int stackPosition;\n bool isVector;\n\n _StackPointer(this.stackPosition, this.isVector);\n}\n\nclass _KeysHash {\n final List keys;\n\n const _KeysHash(this.keys);\n\n @override\n bool operator ==(Object other) {\n if (other is _KeysHash) {\n if (keys.length != other.keys.length) return false;\n for (var i = 0; i < keys.length; i++) {\n if (keys[i] != other.keys[i]) return false;\n }\n return true;\n }\n return false;\n }\n\n @override\n int get hashCode {\n var result = 17;\n for (var i = 0; i < keys.length; i++) {\n result = result * 23 + keys[i];\n }\n return result;\n }\n}\n" }, { "path": "dart/lib/src/reference.dart", "content": "import 'dart:collection';\nimport 'dart:convert';\nimport 'dart:typed_data';\n\nimport 'types.dart';\n\n/// Main class to read a value out of a FlexBuffer.\n///\n/// This class let you access values stored in the buffer in a lazy fashion.\nclass Reference {\n final ByteData _buffer;\n final int _offset;\n final BitWidth _parentWidth;\n final String _path;\n final int _byteWidth;\n final ValueType _valueType;\n int? _length;\n\n Reference._(\n this._buffer,\n this._offset,\n this._parentWidth,\n int packedType,\n this._path, [\n int? byteWidth,\n ValueType? valueType,\n ]) : _byteWidth = byteWidth ?? 1 << (packedType & 3),\n _valueType = valueType ?? ValueTypeUtils.fromInt(packedType >> 2);\n\n /// Use this method to access the root value of a FlexBuffer.\n static Reference fromBuffer(ByteBuffer buffer) {\n final len = buffer.lengthInBytes;\n if (len < 3) {\n throw UnsupportedError('Buffer needs to be bigger than 3');\n }\n final byteData = ByteData.view(buffer);\n final byteWidth = byteData.getUint8(len - 1);\n final packedType = byteData.getUint8(len - 2);\n final offset = len - byteWidth - 2;\n return Reference._(\n ByteData.view(buffer),\n offset,\n BitWidthUtil.fromByteWidth(byteWidth),\n packedType,\n \"/\",\n );\n }\n\n /// Returns true if the underlying value is null.\n bool get isNull => _valueType == ValueType.Null;\n\n /// Returns true if the underlying value can be represented as [num].\n bool get isNum =>\n ValueTypeUtils.isNumber(_valueType) ||\n ValueTypeUtils.isIndirectNumber(_valueType);\n\n /// Returns true if the underlying value was encoded as a float (direct or indirect).\n bool get isDouble =>\n _valueType == ValueType.Float || _valueType == ValueType.IndirectFloat;\n\n /// Returns true if the underlying value was encoded as an int or uint (direct or indirect).\n bool get isInt => isNum && !isDouble;\n\n /// Returns true if the underlying value was encoded as a string or a key.\n bool get isString =>\n _valueType == ValueType.String || _valueType == ValueType.Key;\n\n /// Returns true if the underlying value was encoded as a bool.\n bool get isBool => _valueType == ValueType.Bool;\n\n /// Returns true if the underlying value was encoded as a blob.\n bool get isBlob => _valueType == ValueType.Blob;\n\n /// Returns true if the underlying value points to a vector.\n bool get isVector => ValueTypeUtils.isAVector(_valueType);\n\n /// Returns true if the underlying value points to a map.\n bool get isMap => _valueType == ValueType.Map;\n\n /// If this [isBool], returns the bool value. Otherwise, returns null.\n bool? get boolValue {\n if (_valueType == ValueType.Bool) {\n return _readInt(_offset, _parentWidth) != 0;\n }\n return null;\n }\n\n /// Returns an [int], if the underlying value can be represented as an int.\n ///\n /// Otherwise returns [null].\n int? get intValue {\n if (_valueType == ValueType.Int) {\n return _readInt(_offset, _parentWidth);\n }\n if (_valueType == ValueType.UInt) {\n return _readUInt(_offset, _parentWidth);\n }\n if (_valueType == ValueType.IndirectInt) {\n return _readInt(_indirect, BitWidthUtil.fromByteWidth(_byteWidth));\n }\n if (_valueType == ValueType.IndirectUInt) {\n return _readUInt(_indirect, BitWidthUtil.fromByteWidth(_byteWidth));\n }\n return null;\n }\n\n /// Returns [double], if the underlying value [isDouble].\n ///\n /// Otherwise returns [null].\n double? get doubleValue {\n if (_valueType == ValueType.Float) {\n return _readFloat(_offset, _parentWidth);\n }\n if (_valueType == ValueType.IndirectFloat) {\n return _readFloat(_indirect, BitWidthUtil.fromByteWidth(_byteWidth));\n }\n return null;\n }\n\n /// Returns [num], if the underlying value is numeric, be it int uint, or float (direct or indirect).\n ///\n /// Otherwise returns [null].\n num? get numValue => doubleValue ?? intValue;\n\n /// Returns [String] value or null otherwise.\n ///\n /// This method performers a utf8 decoding, as FlexBuffers format stores strings in utf8 encoding.\n String? get stringValue {\n if (_valueType == ValueType.String || _valueType == ValueType.Key) {\n return utf8.decode(_buffer.buffer.asUint8List(_indirect, length));\n }\n return null;\n }\n\n /// Returns [Uint8List] value or null otherwise.\n Uint8List? get blobValue {\n if (_valueType == ValueType.Blob) {\n return _buffer.buffer.asUint8List(_indirect, length);\n }\n return null;\n }\n\n /// Can be used with an [int] or a [String] value for key.\n /// If the underlying value in FlexBuffer is a vector, then use [int] for access.\n /// If the underlying value in FlexBuffer is a map, then use [String] for access.\n /// Returns [Reference] value. Throws an exception when [key] is not applicable.\n Reference operator [](Object key) {\n if (key is int && ValueTypeUtils.isAVector(_valueType)) {\n final index = key;\n if (index >= length || index < 0) {\n throw ArgumentError(\n 'Key: [$key] is not applicable on: $_path of: $_valueType length: $length',\n );\n }\n final elementOffset = _indirect + index * _byteWidth;\n int packedType = 0;\n int? byteWidth;\n ValueType? valueType;\n if (ValueTypeUtils.isTypedVector(_valueType)) {\n byteWidth = 1;\n valueType = ValueTypeUtils.typedVectorElementType(_valueType);\n } else if (ValueTypeUtils.isFixedTypedVector(_valueType)) {\n byteWidth = 1;\n valueType = ValueTypeUtils.fixedTypedVectorElementType(_valueType);\n } else {\n packedType = _buffer.getUint8(_indirect + length * _byteWidth + index);\n }\n return Reference._(\n _buffer,\n elementOffset,\n BitWidthUtil.fromByteWidth(_byteWidth),\n packedType,\n \"$_path[$index]\",\n byteWidth,\n valueType,\n );\n }\n if (key is String && _valueType == ValueType.Map) {\n final index = _keyIndex(key);\n if (index != null) {\n return _valueForIndexWithKey(index, key);\n }\n }\n throw ArgumentError(\n 'Key: [$key] is not applicable on: $_path of: $_valueType',\n );\n }\n\n /// Get an iterable if the underlying flexBuffer value is a vector.\n /// Otherwise throws an exception.\n Iterable get vectorIterable {\n if (isVector == false) {\n throw UnsupportedError('Value is not a vector. It is: $_valueType');\n }\n return _VectorIterator(this);\n }\n\n /// Get an iterable for keys if the underlying flexBuffer value is a map.\n /// Otherwise throws an exception.\n Iterable get mapKeyIterable {\n if (isMap == false) {\n throw UnsupportedError('Value is not a map. It is: $_valueType');\n }\n return _MapKeyIterator(this);\n }\n\n /// Get an iterable for values if the underlying flexBuffer value is a map.\n /// Otherwise throws an exception.\n Iterable get mapValueIterable {\n if (isMap == false) {\n throw UnsupportedError('Value is not a map. It is: $_valueType');\n }\n return _MapValueIterator(this);\n }\n\n /// Returns the length of the underlying FlexBuffer value.\n /// If the underlying value is [null] the length is 0.\n /// If the underlying value is a number, or a bool, the length is 1.\n /// If the underlying value is a vector, or map, the length reflects number of elements / element pairs.\n /// 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).\n int get length {\n if (_length == null) {\n // needs to be checked before more generic isAVector\n if (ValueTypeUtils.isFixedTypedVector(_valueType)) {\n _length = ValueTypeUtils.fixedTypedVectorElementSize(_valueType);\n } else if (_valueType == ValueType.Blob ||\n ValueTypeUtils.isAVector(_valueType) ||\n _valueType == ValueType.Map) {\n _length = _readUInt(\n _indirect - _byteWidth,\n BitWidthUtil.fromByteWidth(_byteWidth),\n );\n } else if (_valueType == ValueType.Null) {\n _length = 0;\n } else if (_valueType == ValueType.String) {\n final indirect = _indirect;\n var sizeByteWidth = _byteWidth;\n var size = _readUInt(\n indirect - sizeByteWidth,\n BitWidthUtil.fromByteWidth(sizeByteWidth),\n );\n while (_buffer.getInt8(indirect + size) != 0) {\n sizeByteWidth <<= 1;\n size = _readUInt(\n indirect - sizeByteWidth,\n BitWidthUtil.fromByteWidth(sizeByteWidth),\n );\n }\n _length = size;\n } else if (_valueType == ValueType.Key) {\n final indirect = _indirect;\n var size = 1;\n while (_buffer.getInt8(indirect + size) != 0) {\n size += 1;\n }\n _length = size;\n } else {\n _length = 1;\n }\n }\n return _length!;\n }\n\n /// Returns a minified JSON representation of the underlying FlexBuffer value.\n ///\n /// This method involves materializing the entire object tree, which may be\n /// expensive. It is more efficient to work with [Reference] and access only the needed data.\n /// Blob values are represented as base64 encoded string.\n String get json {\n if (_valueType == ValueType.Bool) {\n return boolValue! ? 'true' : 'false';\n }\n if (_valueType == ValueType.Null) {\n return 'null';\n }\n if (ValueTypeUtils.isNumber(_valueType)) {\n return jsonEncode(numValue);\n }\n if (_valueType == ValueType.String) {\n return jsonEncode(stringValue);\n }\n if (_valueType == ValueType.Blob) {\n return jsonEncode(base64Encode(blobValue!));\n }\n if (ValueTypeUtils.isAVector(_valueType)) {\n final result = StringBuffer();\n result.write('[');\n for (var i = 0; i < length; i++) {\n result.write(this[i].json);\n if (i < length - 1) {\n result.write(',');\n }\n }\n result.write(']');\n return result.toString();\n }\n if (_valueType == ValueType.Map) {\n final result = StringBuffer();\n result.write('{');\n for (var i = 0; i < length; i++) {\n result.write(jsonEncode(_keyForIndex(i)));\n result.write(':');\n result.write(_valueForIndex(i).json);\n if (i < length - 1) {\n result.write(',');\n }\n }\n result.write('}');\n return result.toString();\n }\n throw UnsupportedError(\n 'Type: $_valueType is not supported for JSON conversion',\n );\n }\n\n /// Computes the indirect offset of the value.\n ///\n /// To optimize for the more common case of being called only once, this\n /// value is not cached. Callers that need to use it more than once should\n /// cache the return value in a local variable.\n int get _indirect {\n final step = _readUInt(_offset, _parentWidth);\n return _offset - step;\n }\n\n int _readInt(int offset, BitWidth width) {\n _validateOffset(offset, width);\n if (width == BitWidth.width8) {\n return _buffer.getInt8(offset);\n }\n if (width == BitWidth.width16) {\n return _buffer.getInt16(offset, Endian.little);\n }\n if (width == BitWidth.width32) {\n return _buffer.getInt32(offset, Endian.little);\n }\n return _buffer.getInt64(offset, Endian.little);\n }\n\n int _readUInt(int offset, BitWidth width) {\n _validateOffset(offset, width);\n if (width == BitWidth.width8) {\n return _buffer.getUint8(offset);\n }\n if (width == BitWidth.width16) {\n return _buffer.getUint16(offset, Endian.little);\n }\n if (width == BitWidth.width32) {\n return _buffer.getUint32(offset, Endian.little);\n }\n return _buffer.getUint64(offset, Endian.little);\n }\n\n double _readFloat(int offset, BitWidth width) {\n _validateOffset(offset, width);\n if (width.index < BitWidth.width32.index) {\n throw StateError('Bad width: $width');\n }\n\n if (width == BitWidth.width32) {\n return _buffer.getFloat32(offset, Endian.little);\n }\n\n return _buffer.getFloat64(offset, Endian.little);\n }\n\n void _validateOffset(int offset, BitWidth width) {\n if (_offset < 0 ||\n _buffer.lengthInBytes <= offset + width.index ||\n offset & (BitWidthUtil.toByteWidth(width) - 1) != 0) {\n throw StateError('Bad offset: $offset, width: $width');\n }\n }\n\n int? _keyIndex(String key) {\n final input = utf8.encode(key);\n final keysVectorOffset = _indirect - _byteWidth * 3;\n final indirectOffset =\n keysVectorOffset -\n _readUInt(keysVectorOffset, BitWidthUtil.fromByteWidth(_byteWidth));\n final byteWidth = _readUInt(\n keysVectorOffset + _byteWidth,\n BitWidthUtil.fromByteWidth(_byteWidth),\n );\n var low = 0;\n var high = length - 1;\n while (low <= high) {\n final mid = (high + low) >> 1;\n final dif = _diffKeys(input, mid, indirectOffset, byteWidth);\n if (dif == 0) return mid;\n if (dif < 0) {\n high = mid - 1;\n } else {\n low = mid + 1;\n }\n }\n return null;\n }\n\n int _diffKeys(List input, int index, int indirectOffset, int byteWidth) {\n final keyOffset = indirectOffset + index * byteWidth;\n final keyIndirectOffset =\n keyOffset - _readUInt(keyOffset, BitWidthUtil.fromByteWidth(byteWidth));\n for (var i = 0; i < input.length; i++) {\n final dif = input[i] - _buffer.getUint8(keyIndirectOffset + i);\n if (dif != 0) {\n return dif;\n }\n }\n return (_buffer.getUint8(keyIndirectOffset + input.length) == 0) ? 0 : -1;\n }\n\n Reference _valueForIndexWithKey(int index, String key) {\n final indirect = _indirect;\n final elementOffset = indirect + index * _byteWidth;\n final packedType = _buffer.getUint8(indirect + length * _byteWidth + index);\n return Reference._(\n _buffer,\n elementOffset,\n BitWidthUtil.fromByteWidth(_byteWidth),\n packedType,\n \"$_path/$key\",\n );\n }\n\n Reference _valueForIndex(int index) {\n final indirect = _indirect;\n final elementOffset = indirect + index * _byteWidth;\n final packedType = _buffer.getUint8(indirect + length * _byteWidth + index);\n return Reference._(\n _buffer,\n elementOffset,\n BitWidthUtil.fromByteWidth(_byteWidth),\n packedType,\n \"$_path/[$index]\",\n );\n }\n\n String _keyForIndex(int index) {\n final keysVectorOffset = _indirect - _byteWidth * 3;\n final indirectOffset =\n keysVectorOffset -\n _readUInt(keysVectorOffset, BitWidthUtil.fromByteWidth(_byteWidth));\n final byteWidth = _readUInt(\n keysVectorOffset + _byteWidth,\n BitWidthUtil.fromByteWidth(_byteWidth),\n );\n final keyOffset = indirectOffset + index * byteWidth;\n final keyIndirectOffset =\n keyOffset - _readUInt(keyOffset, BitWidthUtil.fromByteWidth(byteWidth));\n var length = 0;\n while (_buffer.getUint8(keyIndirectOffset + length) != 0) {\n length += 1;\n }\n return utf8.decode(_buffer.buffer.asUint8List(keyIndirectOffset, length));\n }\n}\n\nclass _VectorIterator\n with IterableMixin\n implements Iterator {\n final Reference _vector;\n int index = -1;\n\n _VectorIterator(this._vector);\n\n @override\n Reference get current => _vector[index];\n\n @override\n bool moveNext() {\n index++;\n return index < _vector.length;\n }\n\n @override\n Iterator get iterator => this;\n}\n\nclass _MapKeyIterator with IterableMixin implements Iterator {\n final Reference _map;\n int index = -1;\n\n _MapKeyIterator(this._map);\n\n @override\n String get current => _map._keyForIndex(index);\n\n @override\n bool moveNext() {\n index++;\n return index < _map.length;\n }\n\n @override\n Iterator get iterator => this;\n}\n\nclass _MapValueIterator\n with IterableMixin\n implements Iterator {\n final Reference _map;\n int index = -1;\n\n _MapValueIterator(this._map);\n\n @override\n Reference get current => _map._valueForIndex(index);\n\n @override\n bool moveNext() {\n index++;\n return index < _map.length;\n }\n\n @override\n Iterator get iterator => this;\n}\n" }, { "path": "dart/lib/src/types.dart", "content": "import 'dart:typed_data';\n\n/// Represents the number of bits a value occupies.\nenum BitWidth { width8, width16, width32, width64 }\n\nclass BitWidthUtil {\n static int toByteWidth(BitWidth self) {\n return 1 << self.index;\n }\n\n static BitWidth width(num value) {\n if (value is int) {\n var v = value.toInt().abs();\n if (v >> 7 == 0) return BitWidth.width8;\n if (v >> 15 == 0) return BitWidth.width16;\n if (v >> 31 == 0) return BitWidth.width32;\n return BitWidth.width64;\n }\n return value == _toF32(value as double)\n ? BitWidth.width32\n : BitWidth.width64;\n }\n\n static BitWidth uwidth(num value) {\n if (value.toInt() == value) {\n var v = value.toInt().abs();\n if (v >> 8 == 0) return BitWidth.width8;\n if (v >> 16 == 0) return BitWidth.width16;\n if (v >> 32 == 0) return BitWidth.width32;\n return BitWidth.width64;\n }\n return value == _toF32(value as double)\n ? BitWidth.width32\n : BitWidth.width64;\n }\n\n static BitWidth fromByteWidth(int value) {\n if (value == 1) {\n return BitWidth.width8;\n }\n if (value == 2) {\n return BitWidth.width16;\n }\n if (value == 4) {\n return BitWidth.width32;\n }\n if (value == 8) {\n return BitWidth.width64;\n }\n throw Exception('Unexpected value $value');\n }\n\n static int paddingSize(int bufSize, int scalarSize) {\n return (~bufSize + 1) & (scalarSize - 1);\n }\n\n static double _toF32(double value) {\n var bdata = ByteData(4);\n bdata.setFloat32(0, value);\n return bdata.getFloat32(0);\n }\n\n static BitWidth max(BitWidth self, BitWidth other) {\n if (self.index < other.index) {\n return other;\n }\n return self;\n }\n}\n\n/// Represents all internal FlexBuffer types.\nenum ValueType {\n Null,\n Int,\n UInt,\n Float,\n Key,\n String,\n IndirectInt,\n IndirectUInt,\n IndirectFloat,\n Map,\n Vector,\n VectorInt,\n VectorUInt,\n VectorFloat,\n VectorKey,\n @Deprecated(\n 'VectorString is deprecated due to a flaw in the binary format (https://github.com/google/flatbuffers/issues/5627)',\n )\n VectorString,\n VectorInt2,\n VectorUInt2,\n VectorFloat2,\n VectorInt3,\n VectorUInt3,\n VectorFloat3,\n VectorInt4,\n VectorUInt4,\n VectorFloat4,\n Blob,\n Bool,\n VectorBool,\n}\n\nclass ValueTypeUtils {\n static int toInt(ValueType self) {\n if (self == ValueType.VectorBool) return 36;\n return self.index;\n }\n\n static ValueType fromInt(int value) {\n if (value == 36) return ValueType.VectorBool;\n return ValueType.values[value];\n }\n\n static bool isInline(ValueType self) {\n return self == ValueType.Bool || toInt(self) <= toInt(ValueType.Float);\n }\n\n static bool isNumber(ValueType self) {\n return toInt(self) >= toInt(ValueType.Int) &&\n toInt(self) <= toInt(ValueType.Float);\n }\n\n static bool isIndirectNumber(ValueType self) {\n return toInt(self) >= toInt(ValueType.IndirectInt) &&\n toInt(self) <= toInt(ValueType.IndirectFloat);\n }\n\n static bool isTypedVectorElement(ValueType self) {\n return self == ValueType.Bool ||\n (toInt(self) >= toInt(ValueType.Int) &&\n toInt(self) <= toInt(ValueType.String));\n }\n\n static bool isTypedVector(ValueType self) {\n return self == ValueType.VectorBool ||\n (toInt(self) >= toInt(ValueType.VectorInt) &&\n toInt(self) <= toInt(ValueType.VectorString));\n }\n\n static bool isFixedTypedVector(ValueType self) {\n return (toInt(self) >= toInt(ValueType.VectorInt2) &&\n toInt(self) <= toInt(ValueType.VectorFloat4));\n }\n\n static bool isAVector(ValueType self) {\n return (isTypedVector(self) ||\n isFixedTypedVector(self) ||\n self == ValueType.Vector);\n }\n\n static ValueType toTypedVector(ValueType self, int length) {\n if (length == 0) {\n return ValueTypeUtils.fromInt(\n toInt(self) - toInt(ValueType.Int) + toInt(ValueType.VectorInt),\n );\n }\n if (length == 2) {\n return ValueTypeUtils.fromInt(\n toInt(self) - toInt(ValueType.Int) + toInt(ValueType.VectorInt2),\n );\n }\n if (length == 3) {\n return ValueTypeUtils.fromInt(\n toInt(self) - toInt(ValueType.Int) + toInt(ValueType.VectorInt3),\n );\n }\n if (length == 4) {\n return ValueTypeUtils.fromInt(\n toInt(self) - toInt(ValueType.Int) + toInt(ValueType.VectorInt4),\n );\n }\n throw Exception('unexpected length ' + length.toString());\n }\n\n static ValueType typedVectorElementType(ValueType self) {\n return ValueTypeUtils.fromInt(\n toInt(self) - toInt(ValueType.VectorInt) + toInt(ValueType.Int),\n );\n }\n\n static ValueType fixedTypedVectorElementType(ValueType self) {\n return ValueTypeUtils.fromInt(\n (toInt(self) - toInt(ValueType.VectorInt2)) % 3 + toInt(ValueType.Int),\n );\n }\n\n static int fixedTypedVectorElementSize(ValueType self) {\n return (toInt(self) - toInt(ValueType.VectorInt2)) ~/ 3 + 2;\n }\n\n static int packedType(ValueType self, BitWidth bitWidth) {\n return bitWidth.index | (toInt(self) << 2);\n }\n}\n" }, { "path": "dart/publish.sh", "content": "#!/bin/sh\n#\n# Copyright 2018 Google Inc. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# Note to pub consumers: this file is used to assist with publishing the\n# pub package from the flatbuffers repository and is not meant for general use.\n# As pub does not currently provide a way to exclude files, it is included here.\nset -e\n\ncommand -v dart >/dev/null 2>&1 || { echo >&2 \"Require `dart` but it's not installed. Aborting.\"; exit 1; }\n\npushd ../tests\n./DartTest.sh\npopd\n\npushd ../samples\n./dart_sample.sh\npopd\n\ndart pub publish\n\nrm example/monster.fbs\nrm test/*.fbs\nrm -rf test/sub\n" }, { "path": "dart/pubspec.yaml", "content": "name: flat_buffers\nversion: 25.12.19\ndescription: FlatBuffers reading and writing library for Dart. Based on original work by Konstantin Scheglov and Paul Berry of the Dart SDK team.\nhomepage: https://github.com/google/flatbuffers\ndocumentation: https://google.github.io/flatbuffers/index.html\n\nenvironment:\n sdk: '>=2.17.0 <4.0.0'\n\ndev_dependencies:\n test: ^1.17.7\n test_reflective_loader: ^0.2.0\n path: ^1.8.0\n lints: ^1.0.1\n" }, { "path": "dart/test/bool_structs.fbs", "content": "// Test for #7355\ntable Foo {\n my_foo : foo_properties;\n}\n\nstruct foo_properties\n{\n a : bool;\n b : bool;\n}\n" }, { "path": "dart/test/bool_structs_generated.dart", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable, constant_identifier_names\n\nimport 'dart:typed_data' show Uint8List;\n\nimport 'package:flat_buffers/flat_buffers.dart' as fb;\n\nclass Foo {\n Foo._(this._bc, this._bcOffset);\n factory Foo(List bytes) {\n final rootRef = fb.BufferContext.fromBytes(bytes);\n return reader.read(rootRef, 0);\n }\n\n static const fb.Reader reader = _FooReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n FooProperties? get myFoo =>\n FooProperties.reader.vTableGetNullable(_bc, _bcOffset, 4);\n\n @override\n String toString() {\n return 'Foo{myFoo: ${myFoo}}';\n }\n\n FooT unpack() => FooT(myFoo: myFoo?.unpack());\n\n static int pack(fb.Builder fbBuilder, FooT? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass FooT implements fb.Packable {\n FooPropertiesT? myFoo;\n\n FooT({this.myFoo});\n\n @override\n int pack(fb.Builder fbBuilder) {\n fbBuilder.startTable(1);\n if (myFoo != null) {\n fbBuilder.addStruct(0, myFoo!.pack(fbBuilder));\n }\n return fbBuilder.endTable();\n }\n\n @override\n String toString() {\n return 'FooT{myFoo: ${myFoo}}';\n }\n}\n\nclass _FooReader extends fb.TableReader {\n const _FooReader();\n\n @override\n Foo createObject(fb.BufferContext bc, int offset) => Foo._(bc, offset);\n}\n\nclass FooBuilder {\n FooBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n void begin() {\n fbBuilder.startTable(1);\n }\n\n int addMyFoo(int offset) {\n fbBuilder.addStruct(0, offset);\n return fbBuilder.offset;\n }\n\n int finish() {\n return fbBuilder.endTable();\n }\n}\n\nclass FooObjectBuilder extends fb.ObjectBuilder {\n final FooPropertiesObjectBuilder? _myFoo;\n\n FooObjectBuilder({FooPropertiesObjectBuilder? myFoo}) : _myFoo = myFoo;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n fbBuilder.startTable(1);\n if (_myFoo != null) {\n fbBuilder.addStruct(0, _myFoo!.finish(fbBuilder));\n }\n return fbBuilder.endTable();\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n\nclass FooProperties {\n FooProperties._(this._bc, this._bcOffset);\n\n static const fb.Reader reader = _FooPropertiesReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n bool get a => const fb.BoolReader().read(_bc, _bcOffset + 0);\n bool get b => const fb.BoolReader().read(_bc, _bcOffset + 1);\n\n @override\n String toString() {\n return 'FooProperties{a: ${a}, b: ${b}}';\n }\n\n FooPropertiesT unpack() => FooPropertiesT(a: a, b: b);\n\n static int pack(fb.Builder fbBuilder, FooPropertiesT? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass FooPropertiesT implements fb.Packable {\n bool a;\n bool b;\n\n FooPropertiesT({required this.a, required this.b});\n\n @override\n int pack(fb.Builder fbBuilder) {\n fbBuilder.putBool(b);\n fbBuilder.putBool(a);\n return fbBuilder.offset;\n }\n\n @override\n String toString() {\n return 'FooPropertiesT{a: ${a}, b: ${b}}';\n }\n}\n\nclass _FooPropertiesReader extends fb.StructReader {\n const _FooPropertiesReader();\n\n @override\n int get size => 2;\n\n @override\n FooProperties createObject(fb.BufferContext bc, int offset) =>\n FooProperties._(bc, offset);\n}\n\nclass FooPropertiesBuilder {\n FooPropertiesBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n int finish(bool a, bool b) {\n fbBuilder.putBool(b);\n fbBuilder.putBool(a);\n return fbBuilder.offset;\n }\n}\n\nclass FooPropertiesObjectBuilder extends fb.ObjectBuilder {\n final bool _a;\n final bool _b;\n\n FooPropertiesObjectBuilder({required bool a, required bool b})\n : _a = a,\n _b = b;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n fbBuilder.putBool(_b);\n fbBuilder.putBool(_a);\n return fbBuilder.offset;\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n" }, { "path": "dart/test/enums.fbs", "content": "enum OptionsEnum : uint32\n{\n A = 1,\n B = 2,\n C = 3\n}\n\ntable MyTable {\n options : [OptionsEnum];\n}\n" }, { "path": "dart/test/enums_generated.dart", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable, constant_identifier_names\n\nimport 'dart:typed_data' show Uint8List;\n\nimport 'package:flat_buffers/flat_buffers.dart' as fb;\n\nenum OptionsEnum {\n A(1),\n B(2),\n C(3);\n\n final int value;\n const OptionsEnum(this.value);\n\n factory OptionsEnum.fromValue(int value) {\n switch (value) {\n case 1:\n return OptionsEnum.A;\n case 2:\n return OptionsEnum.B;\n case 3:\n return OptionsEnum.C;\n default:\n throw StateError('Invalid value $value for bit flag enum');\n }\n }\n\n static OptionsEnum? _createOrNull(int? value) =>\n value == null ? null : OptionsEnum.fromValue(value);\n\n static const int minValue = 1;\n static const int maxValue = 3;\n static const fb.Reader reader = _OptionsEnumReader();\n}\n\nclass _OptionsEnumReader extends fb.Reader {\n const _OptionsEnumReader();\n\n @override\n int get size => 4;\n\n @override\n OptionsEnum read(fb.BufferContext bc, int offset) =>\n OptionsEnum.fromValue(const fb.Uint32Reader().read(bc, offset));\n}\n\nclass MyTable {\n MyTable._(this._bc, this._bcOffset);\n factory MyTable(List bytes) {\n final rootRef = fb.BufferContext.fromBytes(bytes);\n return reader.read(rootRef, 0);\n }\n\n static const fb.Reader reader = _MyTableReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n List? get options => const fb.ListReader(\n OptionsEnum.reader,\n ).vTableGetNullable(_bc, _bcOffset, 4);\n\n @override\n String toString() {\n return 'MyTable{options: ${options}}';\n }\n\n MyTableT unpack() => MyTableT(\n options: const fb.ListReader(\n OptionsEnum.reader,\n lazy: false,\n ).vTableGetNullable(_bc, _bcOffset, 4),\n );\n\n static int pack(fb.Builder fbBuilder, MyTableT? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass MyTableT implements fb.Packable {\n List? options;\n\n MyTableT({this.options});\n\n @override\n int pack(fb.Builder fbBuilder) {\n final int? optionsOffset = options == null\n ? null\n : fbBuilder.writeListUint32(options!.map((f) => f.value).toList());\n fbBuilder.startTable(1);\n fbBuilder.addOffset(0, optionsOffset);\n return fbBuilder.endTable();\n }\n\n @override\n String toString() {\n return 'MyTableT{options: ${options}}';\n }\n}\n\nclass _MyTableReader extends fb.TableReader {\n const _MyTableReader();\n\n @override\n MyTable createObject(fb.BufferContext bc, int offset) =>\n MyTable._(bc, offset);\n}\n\nclass MyTableBuilder {\n MyTableBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n void begin() {\n fbBuilder.startTable(1);\n }\n\n int addOptionsOffset(int? offset) {\n fbBuilder.addOffset(0, offset);\n return fbBuilder.offset;\n }\n\n int finish() {\n return fbBuilder.endTable();\n }\n}\n\nclass MyTableObjectBuilder extends fb.ObjectBuilder {\n final List? _options;\n\n MyTableObjectBuilder({List? options}) : _options = options;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n final int? optionsOffset = _options == null\n ? null\n : fbBuilder.writeListUint32(_options!.map((f) => f.value).toList());\n fbBuilder.startTable(1);\n fbBuilder.addOffset(0, optionsOffset);\n return fbBuilder.endTable();\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n" }, { "path": "dart/test/flat_buffers_test.dart", "content": "import 'dart:io' as io;\nimport 'dart:typed_data';\n\nimport 'package:flat_buffers/flat_buffers.dart';\nimport 'package:path/path.dart' as path;\nimport 'package:test/test.dart';\nimport 'package:test_reflective_loader/test_reflective_loader.dart';\n\nimport './bool_structs_generated.dart' as example4;\nimport './monster_test_my_game.example2_generated.dart' as example2;\nimport './monster_test_my_game.example_generated.dart' as example;\nimport 'enums_generated.dart' as example3;\n\nmain() {\n defineReflectiveSuite(() {\n defineReflectiveTests(BuilderTest);\n defineReflectiveTests(ObjectAPITest);\n defineReflectiveTests(CheckOtherLangaugesData);\n defineReflectiveTests(GeneratorTest);\n defineReflectiveTests(ListOfEnumsTest);\n });\n}\n\nint indexToField(int index) {\n return (1 + 1 + index) * 2;\n}\n\n@reflectiveTest\nclass CheckOtherLangaugesData {\n test_cppData() async {\n List data = await io.File(\n path.join(path.context.current, 'test', 'monsterdata_test.mon'),\n ).readAsBytes();\n example.Monster mon = example.Monster(data);\n expect(mon.hp, 80);\n expect(mon.mana, 150);\n expect(mon.name, 'MyMonster');\n expect(mon.pos!.x, 1.0);\n expect(mon.pos!.y, 2.0);\n expect(mon.pos!.z, 3.0);\n expect(mon.pos!.test1, 3.0);\n expect(mon.pos!.test2.value, 2.0);\n expect(mon.pos!.test3.a, 5);\n expect(mon.pos!.test3.b, 6);\n expect(mon.testType!.value, example.AnyTypeId.Monster.value);\n expect(mon.test is example.Monster, true);\n final monster2 = mon.test as example.Monster;\n expect(monster2.name, \"Fred\");\n\n expect(mon.inventory!.length, 5);\n expect(mon.inventory!.reduce((cur, next) => cur + next), 10);\n final test4 = mon.test4!;\n expect(test4.length, 2);\n expect(test4[0].a + test4[0].b + test4[1].a + test4[1].b, 100);\n expect(mon.testarrayofstring!.length, 2);\n expect(mon.testarrayofstring![0], \"test1\");\n expect(mon.testarrayofstring![1], \"test2\");\n\n // this will fail if accessing any field fails.\n expect(\n mon.toString(),\n 'Monster{'\n 'pos: Vec3{x: 1.0, y: 2.0, z: 3.0, test1: 3.0, test2: Color.Green, test3: Test{a: 5, b: 6}}, '\n 'mana: 150, hp: 80, name: MyMonster, inventory: [0, 1, 2, 3, 4], '\n 'color: Color.Blue, testType: AnyTypeId.Monster, '\n 'test: Monster{pos: null, mana: 150, hp: 100, name: Fred, '\n 'inventory: null, color: Color.Blue, testType: null, '\n 'test: null, test4: null, testarrayofstring: null, '\n 'testarrayoftables: null, enemy: null, testnestedflatbuffer: null, '\n 'testempty: null, testbool: false, testhashs32Fnv1: 0, '\n 'testhashu32Fnv1: 0, testhashs64Fnv1: 0, testhashu64Fnv1: 0, '\n 'testhashs32Fnv1a: 0, testhashu32Fnv1a: 0, testhashs64Fnv1a: 0, '\n 'testhashu64Fnv1a: 0, testarrayofbools: null, testf: 3.14159, '\n 'testf2: 3.0, testf3: 0.0, testarrayofstring2: null, '\n 'testarrayofsortedstruct: null, flex: null, test5: null, '\n 'vectorOfLongs: null, vectorOfDoubles: null, parentNamespaceTest: null, '\n 'vectorOfReferrables: null, singleWeakReference: 0, '\n 'vectorOfWeakReferences: null, vectorOfStrongReferrables: null, '\n 'coOwningReference: 0, vectorOfCoOwningReferences: null, '\n 'nonOwningReference: 0, vectorOfNonOwningReferences: null, '\n 'anyUniqueType: null, anyUnique: null, anyAmbiguousType: null, '\n 'anyAmbiguous: null, vectorOfEnums: null, signedEnum: Race.None, '\n 'testrequirednestedflatbuffer: null, scalarKeySortedTables: null, '\n 'nativeInline: null, '\n 'longEnumNonEnumDefault: LongEnum._default, '\n 'longEnumNormalDefault: LongEnum.LongOne, nanDefault: NaN, '\n 'infDefault: Infinity, positiveInfDefault: Infinity, infinityDefault: '\n 'Infinity, positiveInfinityDefault: Infinity, negativeInfDefault: '\n '-Infinity, negativeInfinityDefault: -Infinity, doubleInfDefault: Infinity}, '\n 'test4: [Test{a: 10, b: 20}, Test{a: 30, b: 40}], '\n 'testarrayofstring: [test1, test2], testarrayoftables: null, '\n 'enemy: Monster{pos: null, mana: 150, hp: 100, name: Fred, '\n 'inventory: null, color: Color.Blue, testType: null, '\n 'test: null, test4: null, testarrayofstring: null, '\n 'testarrayoftables: null, enemy: null, testnestedflatbuffer: null, '\n 'testempty: null, testbool: false, testhashs32Fnv1: 0, '\n 'testhashu32Fnv1: 0, testhashs64Fnv1: 0, testhashu64Fnv1: 0, '\n 'testhashs32Fnv1a: 0, testhashu32Fnv1a: 0, testhashs64Fnv1a: 0, '\n 'testhashu64Fnv1a: 0, testarrayofbools: null, testf: 3.14159, '\n 'testf2: 3.0, testf3: 0.0, testarrayofstring2: null, '\n 'testarrayofsortedstruct: null, flex: null, test5: null, '\n 'vectorOfLongs: null, vectorOfDoubles: null, parentNamespaceTest: null, '\n 'vectorOfReferrables: null, singleWeakReference: 0, '\n 'vectorOfWeakReferences: null, vectorOfStrongReferrables: null, '\n 'coOwningReference: 0, vectorOfCoOwningReferences: null, '\n 'nonOwningReference: 0, vectorOfNonOwningReferences: null, '\n 'anyUniqueType: null, anyUnique: null, anyAmbiguousType: null, '\n 'anyAmbiguous: null, vectorOfEnums: null, signedEnum: Race.None, '\n 'testrequirednestedflatbuffer: null, scalarKeySortedTables: null, '\n 'nativeInline: null, '\n 'longEnumNonEnumDefault: LongEnum._default, '\n 'longEnumNormalDefault: LongEnum.LongOne, nanDefault: NaN, '\n 'infDefault: Infinity, positiveInfDefault: Infinity, infinityDefault: '\n 'Infinity, positiveInfinityDefault: Infinity, negativeInfDefault: '\n '-Infinity, negativeInfinityDefault: -Infinity, doubleInfDefault: Infinity}, '\n 'testnestedflatbuffer: null, testempty: null, testbool: true, '\n 'testhashs32Fnv1: -579221183, testhashu32Fnv1: 3715746113, '\n 'testhashs64Fnv1: 7930699090847568257, '\n 'testhashu64Fnv1: 7930699090847568257, '\n 'testhashs32Fnv1a: -1904106383, testhashu32Fnv1a: 2390860913, '\n 'testhashs64Fnv1a: 4898026182817603057, '\n 'testhashu64Fnv1a: 4898026182817603057, '\n 'testarrayofbools: [true, false, true], testf: 3.14159, testf2: 3.0, '\n 'testf3: 0.0, testarrayofstring2: null, testarrayofsortedstruct: ['\n 'Ability{id: 0, distance: 45}, Ability{id: 1, distance: 21}, '\n 'Ability{id: 5, distance: 12}], '\n 'flex: null, test5: [Test{a: 10, b: 20}, Test{a: 30, b: 40}], '\n 'vectorOfLongs: [1, 100, 10000, 1000000, 100000000], '\n 'vectorOfDoubles: [-1.7976931348623157e+308, 0.0, 1.7976931348623157e+308], '\n 'parentNamespaceTest: null, vectorOfReferrables: null, '\n 'singleWeakReference: 0, vectorOfWeakReferences: null, '\n 'vectorOfStrongReferrables: null, coOwningReference: 0, '\n 'vectorOfCoOwningReferences: null, nonOwningReference: 0, '\n 'vectorOfNonOwningReferences: null, '\n 'anyUniqueType: null, anyUnique: null, '\n 'anyAmbiguousType: null, '\n 'anyAmbiguous: null, vectorOfEnums: null, signedEnum: Race.None, '\n 'testrequirednestedflatbuffer: null, scalarKeySortedTables: [Stat{id: '\n 'miss, val: 0, count: 0}, Stat{id: hit, val: 10, count: 1}], '\n 'nativeInline: Test{a: 1, b: 2}, '\n 'longEnumNonEnumDefault: LongEnum._default, '\n 'longEnumNormalDefault: LongEnum.LongOne, nanDefault: NaN, '\n 'infDefault: Infinity, positiveInfDefault: Infinity, infinityDefault: '\n 'Infinity, positiveInfinityDefault: Infinity, negativeInfDefault: '\n '-Infinity, negativeInfinityDefault: -Infinity, doubleInfDefault: Infinity}',\n );\n }\n}\n\n/// Test a custom, fixed-memory allocator (no actual allocations performed)\nclass CustomAllocator extends Allocator {\n final _memory = ByteData(10 * 1024);\n int _used = 0;\n\n Uint8List buffer(int size) => _memory.buffer.asUint8List(_used - size, size);\n\n @override\n ByteData allocate(int size) {\n if (size > _memory.lengthInBytes) {\n throw UnsupportedError('Trying to allocate too much');\n }\n _used = size;\n return ByteData.sublistView(_memory, 0, size);\n }\n\n @override\n void deallocate(ByteData _) {}\n}\n\n@reflectiveTest\nclass BuilderTest {\n void test_monsterBuilder([Builder? builder]) {\n final fbBuilder = builder ?? Builder();\n final str = fbBuilder.writeString('MyMonster');\n\n fbBuilder.writeString('test1');\n fbBuilder.writeString('test2', asciiOptimization: true);\n final testArrayOfString = fbBuilder.endStructVector(2);\n\n final fred = fbBuilder.writeString('Fred');\n\n final List treasure = [0, 1, 2, 3, 4];\n final inventory = fbBuilder.writeListUint8(treasure);\n\n final monBuilder = example.MonsterBuilder(fbBuilder)\n ..begin()\n ..addNameOffset(fred);\n final mon2 = monBuilder.finish();\n\n final testBuilder = example.TestBuilder(fbBuilder);\n testBuilder.finish(10, 20);\n testBuilder.finish(30, 40);\n final test4 = fbBuilder.endStructVector(2);\n\n monBuilder\n ..begin()\n ..addPos(\n example.Vec3Builder(fbBuilder).finish(\n 1.0,\n 2.0,\n 3.0,\n 3.0,\n example.Color.Green,\n () => testBuilder.finish(5, 6),\n ),\n )\n ..addHp(80)\n ..addNameOffset(str)\n ..addInventoryOffset(inventory)\n ..addTestType(example.AnyTypeId.Monster)\n ..addTestOffset(mon2)\n ..addTest4Offset(test4)\n ..addTestarrayofstringOffset(testArrayOfString);\n final mon = monBuilder.finish();\n fbBuilder.finish(mon);\n\n final mon3 = example.Monster(fbBuilder.buffer);\n expect(mon3.name, 'MyMonster');\n expect(mon3.pos!.test1, 3.0);\n }\n\n void test_error_addInt32_withoutStartTable([Builder? builder]) {\n builder ??= Builder();\n expect(() {\n builder!.addInt32(0, 0);\n }, throwsA(isA()));\n }\n\n void test_error_addOffset_withoutStartTable() {\n Builder builder = Builder();\n expect(() {\n builder.addOffset(0, 0);\n }, throwsA(isA()));\n }\n\n void test_error_endTable_withoutStartTable() {\n Builder builder = Builder();\n expect(() {\n builder.endTable();\n }, throwsA(isA()));\n }\n\n void test_error_startTable_duringTable() {\n Builder builder = Builder();\n builder.startTable(0);\n expect(() {\n builder.startTable(0);\n }, throwsA(isA()));\n }\n\n void test_error_writeString_duringTable() {\n Builder builder = Builder();\n builder.startTable(1);\n expect(() {\n builder.writeString('12345');\n }, throwsA(isA()));\n }\n\n void test_file_identifier() {\n Uint8List byteList;\n {\n Builder builder = Builder(initialSize: 0);\n builder.startTable(0);\n int offset = builder.endTable();\n builder.finish(offset, 'Az~ÿ');\n byteList = builder.buffer;\n }\n // Convert byteList to a ByteData so that we can read data from it.\n ByteData byteData = byteList.buffer.asByteData(byteList.offsetInBytes);\n // First 4 bytes are an offset to the table data.\n int tableDataLoc = byteData.getUint32(0, Endian.little);\n // Next 4 bytes are the file identifier.\n expect(byteData.getUint8(4), 65); // 'a'\n expect(byteData.getUint8(5), 122); // 'z'\n expect(byteData.getUint8(6), 126); // '~'\n expect(byteData.getUint8(7), 255); // 'ÿ'\n // First 4 bytes of the table data are a backwards offset to the vtable.\n int vTableLoc =\n tableDataLoc - byteData.getInt32(tableDataLoc, Endian.little);\n // First 2 bytes of the vtable are the size of the vtable in bytes, which\n // should be 4.\n expect(byteData.getUint16(vTableLoc, Endian.little), 4);\n // Next 2 bytes are the size of the object in bytes (including the vtable\n // pointer), which should be 4.\n expect(byteData.getUint16(vTableLoc + 2, Endian.little), 4);\n }\n\n void test_low() {\n final allocator = CustomAllocator();\n final builder = Builder(initialSize: 0, allocator: allocator);\n\n builder.putUint8(1);\n expect(allocator.buffer(builder.size()), [1]);\n\n builder.putUint32(2);\n expect(allocator.buffer(builder.size()), [2, 0, 0, 0, 0, 0, 0, 1]);\n\n builder.putUint8(3);\n expect(allocator.buffer(builder.size()), [\n 0,\n 0,\n 0,\n 3,\n 2,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 1,\n ]);\n\n builder.putUint8(4);\n expect(allocator.buffer(builder.size()), [\n 0,\n 0,\n 4,\n 3,\n 2,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 1,\n ]);\n\n builder.putUint8(5);\n expect(allocator.buffer(builder.size()), [\n 0,\n 5,\n 4,\n 3,\n 2,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 1,\n ]);\n\n builder.putUint32(6);\n expect(allocator.buffer(builder.size()), [\n 6,\n 0,\n 0,\n 0,\n 0,\n 5,\n 4,\n 3,\n 2,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 1,\n ]);\n }\n\n void test_table_default() {\n List byteList;\n {\n final builder = Builder(initialSize: 0, allocator: CustomAllocator());\n builder.startTable(2);\n builder.addInt32(0, 10, 10);\n builder.addInt32(1, 20, 10);\n int offset = builder.endTable();\n builder.finish(offset);\n byteList = builder.buffer;\n expect(builder.size(), byteList.length);\n }\n // read and verify\n BufferContext buffer = BufferContext.fromBytes(byteList);\n int objectOffset = buffer.derefObject(0);\n // was not written, so uses the new default value\n expect(\n const Int32Reader().vTableGet(buffer, objectOffset, indexToField(0), 15),\n 15,\n );\n // has the written value\n expect(\n const Int32Reader().vTableGet(buffer, objectOffset, indexToField(1), 15),\n 20,\n );\n }\n\n void test_table_format([Builder? builder]) {\n Uint8List byteList;\n {\n builder ??= Builder(initialSize: 0);\n builder.startTable(3);\n builder.addInt32(0, 10);\n builder.addInt32(1, 20);\n builder.addInt32(2, 30);\n builder.finish(builder.endTable());\n byteList = builder.buffer;\n }\n // Convert byteList to a ByteData so that we can read data from it.\n ByteData byteData = byteList.buffer.asByteData(byteList.offsetInBytes);\n // First 4 bytes are an offset to the table data.\n int tableDataLoc = byteData.getUint32(0, Endian.little);\n // First 4 bytes of the table data are a backwards offset to the vtable.\n int vTableLoc =\n tableDataLoc - byteData.getInt32(tableDataLoc, Endian.little);\n // First 2 bytes of the vtable are the size of the vtable in bytes, which\n // should be 10.\n expect(byteData.getUint16(vTableLoc, Endian.little), 10);\n // Next 2 bytes are the size of the object in bytes (including the vtable\n // pointer), which should be 16.\n expect(byteData.getUint16(vTableLoc + 2, Endian.little), 16);\n // Remaining 6 bytes are the offsets within the object where the ints are\n // located.\n for (int i = 0; i < 3; i++) {\n int offset = byteData.getUint16(vTableLoc + 4 + 2 * i, Endian.little);\n expect(\n byteData.getInt32(tableDataLoc + offset, Endian.little),\n 10 + 10 * i,\n );\n }\n }\n\n void test_table_string() {\n String latinString = 'test';\n String unicodeString = 'Проба пера';\n List byteList;\n {\n Builder builder = Builder(initialSize: 0);\n int? latinStringOffset = builder.writeString(\n latinString,\n asciiOptimization: true,\n );\n int? unicodeStringOffset = builder.writeString(\n unicodeString,\n asciiOptimization: true,\n );\n builder.startTable(2);\n builder.addOffset(0, latinStringOffset);\n builder.addOffset(1, unicodeStringOffset);\n int offset = builder.endTable();\n builder.finish(offset);\n byteList = builder.buffer;\n }\n // read and verify\n BufferContext buf = BufferContext.fromBytes(byteList);\n int objectOffset = buf.derefObject(0);\n expect(\n const StringReader().vTableGetNullable(\n buf,\n objectOffset,\n indexToField(0),\n ),\n latinString,\n );\n expect(\n const StringReader(\n asciiOptimization: true,\n ).vTableGetNullable(buf, objectOffset, indexToField(1)),\n unicodeString,\n );\n }\n\n void test_table_types([Builder? builder]) {\n List byteList;\n {\n builder ??= Builder(initialSize: 0);\n int? stringOffset = builder.writeString('12345');\n builder.startTable(7);\n builder.addBool(0, true);\n builder.addInt8(1, 10);\n builder.addInt32(2, 20);\n builder.addOffset(3, stringOffset);\n builder.addInt32(4, 40);\n builder.addUint32(5, 0x9ABCDEF0);\n builder.addUint8(6, 0x9A);\n int offset = builder.endTable();\n builder.finish(offset);\n byteList = builder.buffer;\n }\n // read and verify\n BufferContext buf = BufferContext.fromBytes(byteList);\n int objectOffset = buf.derefObject(0);\n expect(\n const BoolReader().vTableGetNullable(buf, objectOffset, indexToField(0)),\n true,\n );\n expect(\n const Int8Reader().vTableGetNullable(buf, objectOffset, indexToField(1)),\n 10,\n );\n expect(\n const Int32Reader().vTableGetNullable(buf, objectOffset, indexToField(2)),\n 20,\n );\n expect(\n const StringReader().vTableGetNullable(\n buf,\n objectOffset,\n indexToField(3),\n ),\n '12345',\n );\n expect(\n const Int32Reader().vTableGetNullable(buf, objectOffset, indexToField(4)),\n 40,\n );\n expect(\n const Uint32Reader().vTableGetNullable(\n buf,\n objectOffset,\n indexToField(5),\n ),\n 0x9ABCDEF0,\n );\n expect(\n const Uint8Reader().vTableGetNullable(buf, objectOffset, indexToField(6)),\n 0x9A,\n );\n }\n\n void test_writeList_of_Uint32() {\n List values = [10, 100, 12345, 0x9abcdef0];\n // write\n List byteList;\n {\n Builder builder = Builder(initialSize: 0);\n int offset = builder.writeListUint32(values);\n builder.finish(offset);\n byteList = builder.buffer;\n }\n // read and verify\n BufferContext buf = BufferContext.fromBytes(byteList);\n List items = const Uint32ListReader().read(buf, 0);\n expect(items, hasLength(4));\n expect(items, orderedEquals(values));\n }\n\n void test_writeList_ofBool() {\n void verifyListBooleans(int len, List trueBits) {\n // write\n List byteList;\n {\n Builder builder = Builder(initialSize: 0);\n List values = List.filled(len, false);\n for (int bit in trueBits) {\n values[bit] = true;\n }\n int offset = builder.writeListBool(values);\n builder.finish(offset);\n byteList = builder.buffer;\n }\n // read and verify\n BufferContext buf = BufferContext.fromBytes(byteList);\n List items = const BoolListReader().read(buf, 0);\n expect(items, hasLength(len));\n for (int i = 0; i < items.length; i++) {\n expect(items[i], trueBits.contains(i), reason: 'bit $i of $len');\n }\n }\n\n verifyListBooleans(0, []);\n verifyListBooleans(1, []);\n verifyListBooleans(1, [0]);\n verifyListBooleans(31, [0, 1]);\n verifyListBooleans(31, [1, 2, 24, 25, 30]);\n verifyListBooleans(31, [0, 30]);\n verifyListBooleans(32, [1, 2, 24, 25, 31]);\n verifyListBooleans(33, [1, 2, 24, 25, 32]);\n verifyListBooleans(33, [1, 2, 24, 25, 31, 32]);\n verifyListBooleans(63, []);\n verifyListBooleans(63, [0, 1, 2, 61, 62]);\n verifyListBooleans(63, List.generate(63, (i) => i));\n verifyListBooleans(64, []);\n verifyListBooleans(64, [0, 1, 2, 61, 62, 63]);\n verifyListBooleans(64, [1, 2, 62]);\n verifyListBooleans(64, [0, 1, 2, 63]);\n verifyListBooleans(64, List.generate(64, (i) => i));\n verifyListBooleans(100, [0, 3, 30, 60, 90, 99]);\n }\n\n void test_writeList_ofInt32() {\n List byteList;\n {\n Builder builder = Builder(initialSize: 0);\n int offset = builder.writeListInt32([1, 2, 3, 4, 5]);\n builder.finish(offset);\n byteList = builder.buffer;\n }\n // read and verify\n BufferContext buf = BufferContext.fromBytes(byteList);\n List items = const ListReader(Int32Reader()).read(buf, 0);\n expect(items, hasLength(5));\n expect(items, orderedEquals([1, 2, 3, 4, 5]));\n }\n\n void test_writeList_ofFloat64() {\n List values = [-1.234567, 3.4E+9, -5.6E-13, 7.8, 12.13];\n // write\n List byteList;\n {\n Builder builder = Builder(initialSize: 0);\n int offset = builder.writeListFloat64(values);\n builder.finish(offset);\n byteList = builder.buffer;\n }\n\n // read and verify\n BufferContext buf = BufferContext.fromBytes(byteList);\n List items = const Float64ListReader().read(buf, 0);\n\n expect(items, hasLength(values.length));\n for (int i = 0; i < values.length; i++) {\n expect(values[i], closeTo(items[i], .001));\n }\n }\n\n void test_writeList_ofFloat32() {\n List values = [1.0, 2.23, -3.213, 7.8, 12.13];\n // write\n List byteList;\n {\n Builder builder = Builder(initialSize: 0);\n int offset = builder.writeListFloat32(values);\n builder.finish(offset);\n byteList = builder.buffer;\n }\n // read and verify\n BufferContext buf = BufferContext.fromBytes(byteList);\n List items = const Float32ListReader().read(buf, 0);\n expect(items, hasLength(5));\n for (int i = 0; i < values.length; i++) {\n expect(values[i], closeTo(items[i], .001));\n }\n }\n\n void test_writeList_ofObjects([Builder? builder]) {\n List byteList;\n {\n builder ??= Builder(initialSize: 0);\n // write the object #1\n int object1;\n {\n builder.startTable(2);\n builder.addInt32(0, 10);\n builder.addInt32(1, 20);\n object1 = builder.endTable();\n }\n // write the object #1\n int object2;\n {\n builder.startTable(2);\n builder.addInt32(0, 100);\n builder.addInt32(1, 200);\n object2 = builder.endTable();\n }\n // write the list\n int offset = builder.writeList([object1, object2]);\n builder.finish(offset);\n byteList = builder.buffer;\n }\n // read and verify\n BufferContext buf = BufferContext.fromBytes(byteList);\n List items = const ListReader(\n TestPointReader(),\n ).read(buf, 0);\n expect(items, hasLength(2));\n expect(items[0].x, 10);\n expect(items[0].y, 20);\n expect(items[1].x, 100);\n expect(items[1].y, 200);\n }\n\n void test_writeList_ofStrings_asRoot() {\n List byteList;\n {\n Builder builder = Builder(initialSize: 0);\n int? str1 = builder.writeString('12345');\n int? str2 = builder.writeString('ABC');\n int offset = builder.writeList([str1, str2]);\n builder.finish(offset);\n byteList = builder.buffer;\n }\n // read and verify\n BufferContext buf = BufferContext.fromBytes(byteList);\n List items = const ListReader(StringReader()).read(buf, 0);\n expect(items, hasLength(2));\n expect(items, contains('12345'));\n expect(items, contains('ABC'));\n }\n\n void test_writeList_ofStrings_inObject([Builder? builder]) {\n List byteList;\n {\n builder ??= Builder(initialSize: 0);\n int listOffset = builder.writeList([\n builder.writeString('12345'),\n builder.writeString('ABC'),\n ]);\n builder.startTable(1);\n builder.addOffset(0, listOffset);\n int offset = builder.endTable();\n builder.finish(offset);\n byteList = builder.buffer;\n }\n // read and verify\n BufferContext buf = BufferContext.fromBytes(byteList);\n StringListWrapperImpl reader = StringListWrapperReader().read(buf, 0);\n List? items = reader.items;\n expect(items, hasLength(2));\n expect(items, contains('12345'));\n expect(items, contains('ABC'));\n }\n\n void test_writeList_ofUint32() {\n List byteList;\n {\n Builder builder = Builder(initialSize: 0);\n int offset = builder.writeListUint32([1, 2, 0x9ABCDEF0]);\n builder.finish(offset);\n byteList = builder.buffer;\n }\n // read and verify\n BufferContext buf = BufferContext.fromBytes(byteList);\n List items = const Uint32ListReader().read(buf, 0);\n expect(items, hasLength(3));\n expect(items, orderedEquals([1, 2, 0x9ABCDEF0]));\n }\n\n void test_writeList_ofUint16() {\n List byteList;\n {\n Builder builder = Builder(initialSize: 0);\n int offset = builder.writeListUint16([1, 2, 60000]);\n builder.finish(offset);\n byteList = builder.buffer;\n }\n // read and verify\n BufferContext buf = BufferContext.fromBytes(byteList);\n List items = const Uint16ListReader().read(buf, 0);\n expect(items, hasLength(3));\n expect(items, orderedEquals([1, 2, 60000]));\n }\n\n void test_writeList_ofUint8() {\n List byteList;\n {\n Builder builder = Builder(initialSize: 0);\n int offset = builder.writeListUint8([1, 2, 3, 4, 0x9A, 0xFA]);\n builder.finish(offset);\n byteList = builder.buffer;\n }\n // read and verify\n BufferContext buf = BufferContext.fromBytes(byteList);\n const buffOffset = 8; // 32-bit offset to the list, + 32-bit length\n for (final lazy in [true, false]) {\n List items = Uint8ListReader(lazy: lazy).read(buf, 0);\n expect(items, hasLength(6));\n expect(items, orderedEquals([1, 2, 3, 4, 0x9A, 0xFA]));\n\n // overwrite the buffer to verify the laziness\n buf.buffer.setUint8(buffOffset + 1, 99);\n expect(items, orderedEquals([1, lazy ? 99 : 2, 3, 4, 0x9A, 0xFA]));\n\n // restore the previous value for the next loop\n buf.buffer.setUint8(buffOffset + 1, 2);\n }\n }\n\n void test_reset() {\n // We'll run a selection of tests , reusing the builder between them.\n final testCases = [\n test_monsterBuilder,\n test_error_addInt32_withoutStartTable,\n test_table_format,\n test_table_types,\n test_writeList_ofObjects,\n test_writeList_ofStrings_inObject,\n ];\n\n // Execute all test cases in all permutations of their order.\n // To do that, we generate permutations of test case indexes.\n final testCasesPermutations = _permutationsOf(\n List.generate(testCases.length, (index) => index),\n );\n expect(testCasesPermutations.length, _factorial(testCases.length));\n\n for (var indexes in testCasesPermutations) {\n // print the order so failures are reproducible\n printOnFailure('Running reset() test cases in order: $indexes');\n\n Builder? builder;\n for (var index in indexes) {\n if (builder == null) {\n // Initial size small enough so at least one test case increases it.\n // On the other hand, it's large enough so that some test cases don't.\n builder = Builder(initialSize: 32);\n } else {\n builder.reset();\n }\n testCases[index](builder);\n }\n }\n }\n\n // Generate permutations of the given list\n List> _permutationsOf(List source) {\n final result = >[];\n\n void permutate(List items, int startAt) {\n for (var i = startAt; i < items.length; i++) {\n List permutation = items.toList(growable: false);\n permutation[i] = items[startAt];\n permutation[startAt] = items[i];\n\n // add the current list upon reaching the end\n if (startAt == items.length - 1) {\n result.add(items);\n } else {\n permutate(permutation, startAt + 1);\n }\n }\n }\n\n permutate(source, 0);\n return result;\n }\n\n // a very simple implementation of n!\n int _factorial(int n) {\n var result = 1;\n for (var i = 2; i <= n; i++) {\n result *= i;\n }\n return result;\n }\n}\n\n@reflectiveTest\nclass ObjectAPITest {\n void test_tableStat() {\n final object1 = example.StatT(count: 3, id: \"foo\", val: 4);\n final fbb = Builder();\n fbb.finish(object1.pack(fbb));\n final object2 = example.Stat(fbb.buffer).unpack();\n expect(object2.count, object1.count);\n expect(object2.id, object1.id);\n expect(object2.val, object1.val);\n expect(object2.toString(), object1.toString());\n }\n\n void test_tableMonster() {\n final monster = example.MonsterT()\n ..pos = example.Vec3T(\n x: 1,\n y: 2,\n z: 3,\n test1: 4.0,\n test2: example.Color.Red,\n test3: example.TestT(a: 1, b: 2),\n )\n ..mana = 2\n ..name = 'Monstrous'\n ..inventory = [24, 42]\n ..color = example.Color.Green\n ..testType = example.AnyTypeId.MyGame_Example2_Monster\n ..test = example2.MonsterT()\n ..test4 = [example.TestT(a: 3, b: 4), example.TestT(a: 5, b: 6)]\n ..testarrayofstring = [\"foo\", \"bar\"]\n ..testarrayoftables = [example.MonsterT(name: 'Oof', testf: 2.75)]\n ..enemy = example.MonsterT(name: 'Enemy', testf: 2.5)\n ..testarrayofbools = [false, true, false]\n ..testf = 42.25\n ..testarrayofsortedstruct = [\n example.AbilityT(id: 1, distance: 5),\n example.AbilityT(id: 3, distance: 7),\n ]\n ..vectorOfLongs = [5, 6, 7]\n ..vectorOfDoubles = [8.9, 9.0, 10.1, 11.2]\n ..anyAmbiguousType = example.AnyAmbiguousAliasesTypeId.M2\n ..anyAmbiguous = null\n ..vectorOfEnums = [example.Color.Blue, example.Color.Green]\n ..signedEnum = example.Race.None;\n\n final fbBuilder = Builder();\n final offset = monster.pack(fbBuilder);\n expect(offset, isNonZero);\n fbBuilder.finish(offset);\n final data = fbBuilder.buffer;\n\n final monster2 = example.Monster(data); // Monster (reader)\n expect(\n // map Monster => MonsterT, Vec3 => Vec3T, ...\n monster2.toString().replaceAllMapped(\n RegExp('([a-zA-z0-9]+){'), (match) => match.group(1)! + 'T{'),\n monster.toString());\n\n final monster3 = monster2.unpack(); // MonsterT\n expect(monster3.toString(), monster.toString());\n }\n\n void test_Lists() {\n // Ensure unpack() reads lists eagerly by reusing the same builder and\n // overwriting data. Why: because standard reader reads lists lazily...\n final fbb = Builder();\n\n final object1 = example.TypeAliasesT(v8: [1, 2, 3], vf64: [5, 6]);\n fbb.finish(object1.pack(fbb));\n final object1Read = example.TypeAliases(fbb.buffer).unpack();\n\n // overwrite the original buffer by writing to the same builder\n fbb.reset();\n final object2 = example.TypeAliasesT(v8: [7, 8, 9], vf64: [10, 11]);\n fbb.finish(object2.pack(fbb));\n final object2Read = example.TypeAliases(fbb.buffer).unpack();\n\n // this is fine even with lazy lists:\n expect(object2.toString(), object2Read.toString());\n\n // this fails with lazy lists:\n expect(object1.toString(), object1Read.toString());\n\n // empty list must be serialized as such (were stored NULL before v2.0)\n fbb.reset();\n final object3 = example.TypeAliasesT(v8: [], vf64: null);\n fbb.finish(object3.pack(fbb));\n final object3Read = example.TypeAliases(fbb.buffer).unpack();\n expect(object3.toString(), object3Read.toString());\n }\n}\n\nclass StringListWrapperImpl {\n final BufferContext bp;\n final int offset;\n\n StringListWrapperImpl(this.bp, this.offset);\n\n List? get items => const ListReader(\n StringReader(),\n ).vTableGetNullable(bp, offset, indexToField(0));\n}\n\nclass StringListWrapperReader extends TableReader {\n const StringListWrapperReader();\n\n @override\n StringListWrapperImpl createObject(BufferContext object, int offset) {\n return StringListWrapperImpl(object, offset);\n }\n}\n\nclass TestPointImpl {\n final BufferContext bp;\n final int offset;\n\n TestPointImpl(this.bp, this.offset);\n\n int get x => const Int32Reader().vTableGet(bp, offset, indexToField(0), 0);\n\n int get y => const Int32Reader().vTableGet(bp, offset, indexToField(1), 0);\n}\n\nclass TestPointReader extends TableReader {\n const TestPointReader();\n\n @override\n TestPointImpl createObject(BufferContext object, int offset) {\n return TestPointImpl(object, offset);\n }\n}\n\n@reflectiveTest\nclass GeneratorTest {\n void test_constantEnumValues() async {\n expect(example.Color.values, same(example.Color.values));\n expect(example.Race.values, same(example.Race.values));\n expect(example.AnyTypeId.values, same(example.AnyTypeId.values));\n expect(\n example.AnyUniqueAliasesTypeId.values,\n same(example.AnyUniqueAliasesTypeId.values),\n );\n expect(\n example.AnyAmbiguousAliasesTypeId.values,\n same(example.AnyAmbiguousAliasesTypeId.values),\n );\n }\n}\n\n// See #6869\n@reflectiveTest\nclass ListOfEnumsTest {\n void test_listOfEnums() async {\n var mytable = example3.MyTableObjectBuilder(\n options: [\n example3.OptionsEnum.A,\n example3.OptionsEnum.B,\n example3.OptionsEnum.C,\n ],\n );\n var bytes = mytable.toBytes();\n var mytable_read = example3.MyTable(bytes);\n expect(mytable_read.options![0].value, example3.OptionsEnum.A.value);\n expect(mytable_read.options![1].value, example3.OptionsEnum.B.value);\n expect(mytable_read.options![2].value, example3.OptionsEnum.C.value);\n }\n}\n\n@reflectiveTest\nclass BoolInStructTest {\n void test_boolInStruct() async {\n var mystruct = example4.FooObjectBuilder(\n myFoo: example4.FooPropertiesObjectBuilder(a: true, b: false),\n );\n var bytes = mystruct.toBytes();\n var mystruct_read = example4.Foo(bytes);\n expect(mystruct_read.myFoo!.a, true);\n expect(mystruct_read.myFoo!.b, false);\n }\n}\n" }, { "path": "dart/test/flex_builder_test.dart", "content": "import 'dart:typed_data';\n\nimport 'package:flat_buffers/flex_buffers.dart' show Builder;\nimport 'package:test/test.dart';\n\nvoid main() {\n test('build with single value', () {\n {\n var flx = Builder();\n flx.addNull();\n expect(flx.finish(), [0, 0, 1]);\n }\n {\n var flx = Builder();\n flx.addBool(true);\n expect(flx.finish(), [1, 104, 1]);\n }\n {\n var flx = Builder();\n flx.addBool(false);\n expect(flx.finish(), [0, 104, 1]);\n }\n {\n var flx = Builder();\n flx.addInt(1);\n expect(flx.finish(), [1, 4, 1]);\n }\n {\n var flx = Builder();\n flx.addInt(230);\n expect(flx.finish(), [230, 0, 5, 2]);\n }\n {\n var flx = Builder();\n flx.addInt(1025);\n expect(flx.finish(), [1, 4, 5, 2]);\n }\n {\n var flx = Builder();\n flx.addInt(-1025);\n expect(flx.finish(), [255, 251, 5, 2]);\n }\n {\n var builder = Builder()..addDouble(1.0);\n expect(builder.finish(), [0, 0, 128, 63, 14, 4]);\n }\n {\n var flx = Builder();\n flx.addDouble(0.1);\n expect(flx.finish(), [154, 153, 153, 153, 153, 153, 185, 63, 15, 8]);\n }\n {\n var flx = Builder();\n flx.addDouble(0.5);\n expect(flx.finish(), [0, 0, 0, 63, 14, 4]);\n }\n {\n var flx = Builder();\n flx.addString('Maxim');\n expect(flx.finish(), [5, 77, 97, 120, 105, 109, 0, 6, 20, 1]);\n }\n {\n var flx = Builder();\n flx.addString('hello 😱');\n expect(flx.finish(), [\n 10,\n 104,\n 101,\n 108,\n 108,\n 111,\n 32,\n 240,\n 159,\n 152,\n 177,\n 0,\n 11,\n 20,\n 1,\n ]);\n }\n });\n\n test('build vector', () {\n {\n var flx = Builder()\n ..startVector()\n ..addInt(1)\n ..addInt(2)\n ..end();\n expect(flx.finish(), [1, 2, 2, 64, 1]);\n }\n {\n var flx = Builder()\n ..startVector()\n ..addInt(-1)\n ..addInt(256)\n ..end();\n expect(flx.finish(), [255, 255, 0, 1, 4, 65, 1]);\n }\n {\n var flx = Builder()\n ..startVector()\n ..addInt(-45)\n ..addInt(256000)\n ..end();\n expect(flx.finish(), [211, 255, 255, 255, 0, 232, 3, 0, 8, 66, 1]);\n }\n {\n var flx = Builder()\n ..startVector()\n ..addDouble(1.1)\n ..addDouble(-256)\n ..end();\n expect(flx.finish(), [\n 154,\n 153,\n 153,\n 153,\n 153,\n 153,\n 241,\n 63,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 112,\n 192,\n 16,\n 75,\n 1,\n ]);\n }\n {\n var flx = Builder()\n ..startVector()\n ..addInt(1)\n ..addInt(2)\n ..addInt(4)\n ..end();\n expect(flx.finish(), [1, 2, 4, 3, 76, 1]);\n }\n {\n var flx = Builder()\n ..startVector()\n ..addInt(-1)\n ..addInt(256)\n ..addInt(4)\n ..end();\n expect(flx.finish(), [255, 255, 0, 1, 4, 0, 6, 77, 1]);\n }\n {\n var flx = Builder()\n ..startVector()\n ..startVector()\n ..addInt(61)\n ..end()\n ..addInt(64)\n ..end();\n expect(flx.finish(), [1, 61, 2, 2, 64, 44, 4, 4, 40, 1]);\n }\n {\n var flx = Builder()\n ..startVector()\n ..addString('foo')\n ..addString('bar')\n ..addString('baz')\n ..end();\n expect(flx.finish(), [\n 3,\n 102,\n 111,\n 111,\n 0,\n 3,\n 98,\n 97,\n 114,\n 0,\n 3,\n 98,\n 97,\n 122,\n 0,\n 3,\n 15,\n 11,\n 7,\n 3,\n 60,\n 1,\n ]);\n }\n {\n var flx = Builder()\n ..startVector()\n ..addString('foo')\n ..addString('bar')\n ..addString('baz')\n ..addString('foo')\n ..addString('bar')\n ..addString('baz')\n ..end();\n expect(flx.finish(), [\n 3,\n 102,\n 111,\n 111,\n 0,\n 3,\n 98,\n 97,\n 114,\n 0,\n 3,\n 98,\n 97,\n 122,\n 0,\n 6,\n 15,\n 11,\n 7,\n 18,\n 14,\n 10,\n 6,\n 60,\n 1,\n ]);\n }\n {\n var flx = Builder()\n ..startVector()\n ..addBool(true)\n ..addBool(false)\n ..addBool(true)\n ..end();\n expect(flx.finish(), [3, 1, 0, 1, 3, 144, 1]);\n }\n {\n var flx = Builder()\n ..startVector()\n ..addString('foo')\n ..addInt(1)\n ..addInt(-5)\n ..addDouble(1.3)\n ..addBool(true)\n ..end();\n expect(flx.finish(), [\n 3,\n 102,\n 111,\n 111,\n 0,\n 0,\n 0,\n 0,\n 5,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 15,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 1,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 251,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 205,\n 204,\n 204,\n 204,\n 204,\n 204,\n 244,\n 63,\n 1,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 20,\n 4,\n 4,\n 15,\n 104,\n 45,\n 43,\n 1,\n ]);\n }\n {\n // Default buffer is 2048 bytes, add 2300 bytes of strings that force it\n // to grow.\n final s1 = 'A' * 1000;\n final s2 = 'B' * 800;\n final s3 = 'C' * 500;\n\n var flx = Builder()\n ..startVector()\n ..addString(s1)\n ..addString(s2)\n ..addString(s3)\n ..end();\n expect(flx.finish().length, 2323);\n }\n });\n\n test('build map', () {\n {\n var flx = Builder()\n ..startMap()\n ..addKey('a')\n ..addInt(12)\n ..end();\n expect(flx.finish(), [97, 0, 1, 3, 1, 1, 1, 12, 4, 2, 36, 1]);\n }\n {\n var flx = Builder()\n ..startMap()\n ..addKey('a')\n ..addInt(12)\n ..addKey('')\n ..addInt(45)\n ..end();\n expect(flx.finish(), [\n 97,\n 0,\n 0,\n 2,\n 2,\n 5,\n 2,\n 1,\n 2,\n 45,\n 12,\n 4,\n 4,\n 4,\n 36,\n 1,\n ]);\n }\n {\n var flx = Builder()\n ..startVector()\n ..startMap()\n ..addKey('something')\n ..addInt(12)\n ..end()\n ..startMap()\n ..addKey('something')\n ..addInt(45)\n ..end()\n ..end();\n expect(flx.finish(), [\n 115,\n 111,\n 109,\n 101,\n 116,\n 104,\n 105,\n 110,\n 103,\n 0,\n 1,\n 11,\n 1,\n 1,\n 1,\n 12,\n 4,\n 6,\n 1,\n 1,\n 45,\n 4,\n 2,\n 8,\n 4,\n 36,\n 36,\n 4,\n 40,\n 1,\n ]);\n }\n });\n\n test('build blob', () {\n {\n var flx = Builder()..addBlob(Uint8List.fromList([1, 2, 3]).buffer);\n expect(flx.finish(), [3, 1, 2, 3, 3, 100, 1]);\n }\n });\n\n test('build from object', () {\n expect(\n Builder.buildFromObject(\n Uint8List.fromList([1, 2, 3]).buffer,\n ).asUint8List(),\n [3, 1, 2, 3, 3, 100, 1],\n );\n expect(Builder.buildFromObject(null).asUint8List(), [0, 0, 1]);\n expect(Builder.buildFromObject(true).asUint8List(), [1, 104, 1]);\n expect(Builder.buildFromObject(false).asUint8List(), [0, 104, 1]);\n expect(Builder.buildFromObject(25).asUint8List(), [25, 4, 1]);\n expect(Builder.buildFromObject(-250).asUint8List(), [6, 255, 5, 2]);\n expect(Builder.buildFromObject(-2.50).asUint8List(), [\n 0,\n 0,\n 32,\n 192,\n 14,\n 4,\n ]);\n expect(Builder.buildFromObject('Maxim').asUint8List(), [\n 5,\n 77,\n 97,\n 120,\n 105,\n 109,\n 0,\n 6,\n 20,\n 1,\n ]);\n expect(\n Builder.buildFromObject([1, 3.3, 'max', true, null, false]).asUint8List(),\n [\n 3,\n 109,\n 97,\n 120,\n 0,\n 0,\n 0,\n 0,\n 6,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 1,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 102,\n 102,\n 102,\n 102,\n 102,\n 102,\n 10,\n 64,\n 31,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 1,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 4,\n 15,\n 20,\n 104,\n 0,\n 104,\n 54,\n 43,\n 1,\n ],\n );\n expect(\n Builder.buildFromObject([\n {'something': 12},\n {'something': 45},\n ]).asUint8List(),\n [\n 115,\n 111,\n 109,\n 101,\n 116,\n 104,\n 105,\n 110,\n 103,\n 0,\n 1,\n 11,\n 1,\n 1,\n 1,\n 12,\n 4,\n 6,\n 1,\n 1,\n 45,\n 4,\n 2,\n 8,\n 4,\n 36,\n 36,\n 4,\n 40,\n 1,\n ],\n );\n });\n\n test('add double indirectly', () {\n var flx = Builder()..addDoubleIndirectly(0.1);\n expect(flx.finish(), [154, 153, 153, 153, 153, 153, 185, 63, 8, 35, 1]);\n });\n\n test('add double indirectly to vector with cache', () {\n var flx = Builder()\n ..startVector()\n ..addDoubleIndirectly(0.1, cache: true)\n ..addDoubleIndirectly(0.1, cache: true)\n ..addDoubleIndirectly(0.1, cache: true)\n ..addDoubleIndirectly(0.1, cache: true)\n ..end();\n expect(flx.finish(), [\n 154,\n 153,\n 153,\n 153,\n 153,\n 153,\n 185,\n 63,\n 4,\n 9,\n 10,\n 11,\n 12,\n 35,\n 35,\n 35,\n 35,\n 8,\n 40,\n 1,\n ]);\n });\n\n test('add int indirectly', () {\n var flx = Builder()..addIntIndirectly(2345234523452345);\n expect(flx.finish(), [185, 115, 175, 118, 250, 84, 8, 0, 8, 27, 1]);\n });\n\n test('add int indirectly to vector with cache', () {\n var flx = Builder()\n ..startVector()\n ..addIntIndirectly(2345234523452345, cache: true)\n ..addIntIndirectly(2345234523452345, cache: true)\n ..addIntIndirectly(2345234523452345, cache: true)\n ..addIntIndirectly(2345234523452345, cache: true)\n ..end();\n expect(flx.finish(), [\n 185,\n 115,\n 175,\n 118,\n 250,\n 84,\n 8,\n 0,\n 4,\n 9,\n 10,\n 11,\n 12,\n 27,\n 27,\n 27,\n 27,\n 8,\n 40,\n 1,\n ]);\n });\n\n test('snapshot', () {\n var flx = Builder();\n flx.startVector();\n flx.addInt(12);\n expect(flx.snapshot().asUint8List(), [1, 12, 1, 44, 1]);\n flx.addInt(24);\n expect(flx.snapshot().asUint8List(), [12, 24, 2, 64, 1]);\n flx.addInt(45);\n expect(flx.snapshot().asUint8List(), [12, 24, 45, 3, 76, 1]);\n });\n}\n" }, { "path": "dart/test/flex_reader_test.dart", "content": "import 'dart:typed_data';\n\nimport 'package:flat_buffers/flex_buffers.dart' show Reference, Builder;\nimport 'package:test/test.dart';\n\nvoid main() {\n test('is null', () {\n expect(Reference.fromBuffer(b([0, 0, 1])).isNull, isTrue);\n });\n\n test('bool value', () {\n expect(Reference.fromBuffer(b([1, 104, 1])).boolValue, isTrue);\n expect(Reference.fromBuffer(b([0, 104, 1])).boolValue, isFalse);\n });\n test('int value', () {\n expect(Reference.fromBuffer(b([25, 4, 1])).intValue, 25);\n expect(Reference.fromBuffer(b([231, 4, 1])).intValue, -25);\n expect(Reference.fromBuffer(b([230, 8, 1])).intValue, 230);\n expect(Reference.fromBuffer(b([230, 0, 5, 2])).intValue, 230);\n expect(Reference.fromBuffer(b([1, 4, 5, 2])).intValue, 1025);\n expect(Reference.fromBuffer(b([255, 251, 5, 2])).intValue, -1025);\n expect(Reference.fromBuffer(b([1, 4, 9, 2])).intValue, 1025);\n expect(\n Reference.fromBuffer(b([255, 255, 255, 127, 6, 4])).intValue,\n 2147483647,\n );\n expect(Reference.fromBuffer(b([0, 0, 0, 128, 6, 4])).intValue, -2147483648);\n expect(\n Reference.fromBuffer(b([255, 255, 255, 255, 0, 0, 0, 0, 7, 8])).intValue,\n 4294967295,\n );\n expect(\n Reference.fromBuffer(\n b([255, 255, 255, 255, 255, 255, 255, 127, 7, 8]),\n ).intValue,\n 9223372036854775807,\n );\n expect(\n Reference.fromBuffer(b([0, 0, 0, 0, 0, 0, 0, 128, 7, 8])).intValue,\n -9223372036854775808,\n );\n // Dart does not really support UInt64\n // expect(FlxValue.fromBuffer(b([255, 255, 255, 255, 255, 255, 255, 255, 11, 8])).intValue, 18446744073709551615);\n });\n test('double value', () {\n expect(Reference.fromBuffer(b([0, 0, 128, 63, 14, 4])).doubleValue, 1.0);\n expect(Reference.fromBuffer(b([0, 0, 144, 64, 14, 4])).doubleValue, 4.5);\n expect(\n Reference.fromBuffer(b([205, 204, 204, 61, 14, 4])).doubleValue,\n closeTo(.1, .001),\n );\n expect(\n Reference.fromBuffer(\n b([154, 153, 153, 153, 153, 153, 185, 63, 15, 8]),\n ).doubleValue,\n .1,\n );\n });\n test('num value', () {\n expect(Reference.fromBuffer(b([0, 0, 144, 64, 14, 4])).numValue, 4.5);\n expect(\n Reference.fromBuffer(b([205, 204, 204, 61, 14, 4])).numValue,\n closeTo(.1, .001),\n );\n expect(\n Reference.fromBuffer(\n b([154, 153, 153, 153, 153, 153, 185, 63, 15, 8]),\n ).numValue,\n .1,\n );\n expect(Reference.fromBuffer(b([255, 251, 5, 2])).numValue, -1025);\n });\n test('string value', () {\n expect(\n Reference.fromBuffer(\n b([5, 77, 97, 120, 105, 109, 0, 6, 20, 1]),\n ).stringValue,\n 'Maxim',\n );\n expect(\n Reference.fromBuffer(\n b([10, 104, 101, 108, 108, 111, 32, 240, 159, 152, 177, 0, 11, 20, 1]),\n ).stringValue,\n 'hello 😱',\n );\n });\n test('blob value', () {\n expect(Reference.fromBuffer(b([3, 1, 2, 3, 3, 100, 1])).blobValue, [\n 1,\n 2,\n 3,\n ]);\n });\n test('bool vector', () {\n var flx = Reference.fromBuffer(b([3, 1, 0, 1, 3, 144, 1]));\n expect(flx[0].boolValue, true);\n expect(flx[1].boolValue, false);\n expect(flx[2].boolValue, true);\n });\n test('number vector', () {\n testNumbers([3, 1, 2, 3, 3, 44, 1], [1, 2, 3]);\n testNumbers([3, 255, 2, 3, 3, 44, 1], [-1, 2, 3]);\n testNumbers([3, 0, 1, 0, 43, 2, 3, 0, 6, 45, 1], [1, 555, 3]);\n testNumbers(\n [3, 0, 0, 0, 1, 0, 0, 0, 204, 216, 0, 0, 3, 0, 0, 0, 12, 46, 1],\n [1, 55500, 3],\n );\n testNumbers(\n [\n 3,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 1,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 172,\n 128,\n 94,\n 239,\n 12,\n 0,\n 0,\n 0,\n 3,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 24,\n 47,\n 1,\n ],\n [1, 55555555500, 3],\n );\n testNumbers(\n [3, 0, 0, 0, 0, 0, 192, 63, 0, 0, 32, 64, 0, 0, 96, 64, 12, 54, 1],\n [1.5, 2.5, 3.5],\n );\n testNumbers(\n [\n 3,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 154,\n 153,\n 153,\n 153,\n 153,\n 153,\n 241,\n 63,\n 154,\n 153,\n 153,\n 153,\n 153,\n 153,\n 1,\n 64,\n 102,\n 102,\n 102,\n 102,\n 102,\n 102,\n 10,\n 64,\n 24,\n 55,\n 1,\n ],\n [1.1, 2.2, 3.3],\n );\n });\n test('number vector, fixed type', () {\n testNumbers([1, 2, 2, 64, 1], [1, 2]);\n testNumbers([255, 255, 0, 1, 4, 65, 1], [-1, 256]);\n testNumbers([211, 255, 255, 255, 0, 232, 3, 0, 8, 66, 1], [-45, 256000]);\n testNumbers(\n [\n 211,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 127,\n 16,\n 67,\n 1,\n ],\n [-45, 9223372036854775807],\n );\n\n testNumbers([1, 2, 2, 68, 1], [1, 2]);\n testNumbers([1, 0, 0, 1, 4, 69, 1], [1, 256]);\n testNumbers([45, 0, 0, 0, 0, 232, 3, 0, 8, 70, 1], [45, 256000]);\n\n testNumbers([205, 204, 140, 63, 0, 0, 0, 192, 8, 74, 1], [1.1, -2]);\n testNumbers(\n [\n 154,\n 153,\n 153,\n 153,\n 153,\n 153,\n 241,\n 63,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 112,\n 192,\n 16,\n 75,\n 1,\n ],\n [1.1, -256],\n );\n\n testNumbers(\n [211, 255, 255, 255, 0, 232, 3, 0, 4, 0, 0, 0, 12, 78, 1],\n [-45, 256000, 4],\n );\n\n testNumbers(\n [\n 211,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 127,\n 4,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 9,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 32,\n 91,\n 1,\n ],\n [-45, 9223372036854775807, 4, 9],\n );\n\n testNumbers(\n [\n 45,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 127,\n 4,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 9,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 32,\n 95,\n 1,\n ],\n [45, 9223372036854775807, 4, 9],\n );\n\n testNumbers(\n [\n 154,\n 153,\n 153,\n 153,\n 153,\n 153,\n 241,\n 63,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 112,\n 64,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 16,\n 64,\n 24,\n 87,\n 1,\n ],\n [1.1, 256, 4],\n );\n\n testNumbers(\n [\n 154,\n 153,\n 153,\n 153,\n 153,\n 153,\n 241,\n 63,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 112,\n 64,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 16,\n 64,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 34,\n 64,\n 32,\n 99,\n 1,\n ],\n [1.1, 256, 4, 9],\n );\n });\n test('string vector', () {\n testStrings(\n [\n 3,\n 102,\n 111,\n 111,\n 0,\n 3,\n 98,\n 97,\n 114,\n 0,\n 3,\n 98,\n 97,\n 122,\n 0,\n 3,\n 15,\n 11,\n 7,\n 3,\n 60,\n 1,\n ],\n ['foo', 'bar', 'baz'],\n );\n testStrings(\n [\n 3,\n 102,\n 111,\n 111,\n 0,\n 3,\n 98,\n 97,\n 114,\n 0,\n 3,\n 98,\n 97,\n 122,\n 0,\n 6,\n 15,\n 11,\n 7,\n 18,\n 14,\n 10,\n 6,\n 60,\n 1,\n ],\n ['foo', 'bar', 'baz', 'foo', 'bar', 'baz'],\n );\n });\n test('mixed vector', () {\n var flx = Reference.fromBuffer(\n b([\n 3,\n 102,\n 111,\n 111,\n 0,\n 0,\n 0,\n 0,\n 5,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 15,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 1,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 251,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 255,\n 205,\n 204,\n 204,\n 204,\n 204,\n 204,\n 244,\n 63,\n 1,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 20,\n 4,\n 4,\n 15,\n 104,\n 45,\n 43,\n 1,\n ]),\n );\n expect(flx.length, 5);\n expect(flx[0].stringValue, 'foo');\n expect(flx[1].numValue, 1);\n expect(flx[2].numValue, -5);\n expect(flx[3].numValue, 1.3);\n expect(flx[4].boolValue, true);\n });\n\n test('single value map', () {\n var flx = Reference.fromBuffer(b([97, 0, 1, 3, 1, 1, 1, 12, 4, 2, 36, 1]));\n expect(flx.length, 1);\n expect(flx['a'].numValue, 12);\n });\n test('two value map', () {\n var flx = Reference.fromBuffer(\n b([0, 97, 0, 2, 4, 4, 2, 1, 2, 45, 12, 4, 4, 4, 36, 1]),\n );\n expect(flx.length, 2);\n expect(flx['a'].numValue, 12);\n expect(flx[''].numValue, 45);\n });\n test('complex map', () {\n var flx = complexMap();\n expect(flx.length, 5);\n expect(flx['age'].numValue, 35);\n expect(flx['weight'].numValue, 72.5);\n expect(flx['name'].stringValue, 'Maxim');\n\n expect(flx['flags'].length, 4);\n expect(flx['flags'][0].boolValue, true);\n expect(flx['flags'][1].boolValue, false);\n expect(flx['flags'][2].boolValue, true);\n expect(flx['flags'][3].boolValue, true);\n\n expect(flx['address'].length, 3);\n expect(flx['address']['city'].stringValue, 'Bla');\n expect(flx['address']['zip'].stringValue, '12345');\n expect(flx['address']['countryCode'].stringValue, 'XX');\n\n expect(\n () => flx['address']['country'].stringValue,\n throwsA(\n predicate(\n (dynamic e) =>\n e is ArgumentError &&\n e.message ==\n 'Key: [country] is not applicable on: //address of: ValueType.Map',\n ),\n ),\n );\n expect(\n () => flx['address']['countryCode'][0],\n throwsA(\n predicate(\n (dynamic e) =>\n e is ArgumentError &&\n e.message ==\n 'Key: [0] is not applicable on: //address/countryCode of: ValueType.String',\n ),\n ),\n );\n expect(\n () => flx[1],\n throwsA(\n predicate(\n (dynamic e) =>\n e is ArgumentError &&\n e.message == 'Key: [1] is not applicable on: / of: ValueType.Map',\n ),\n ),\n );\n expect(\n () => flx['flags'][4],\n throwsA(\n predicate(\n (dynamic e) =>\n e is ArgumentError &&\n e.message ==\n 'Key: [4] is not applicable on: //flags of: ValueType.VectorBool length: 4',\n ),\n ),\n );\n expect(\n () => flx['flags'][-1],\n throwsA(\n predicate(\n (dynamic e) =>\n e is ArgumentError &&\n e.message ==\n 'Key: [-1] is not applicable on: //flags of: ValueType.VectorBool length: 4',\n ),\n ),\n );\n });\n test('complex map to json', () {\n var flx = complexMap();\n expect(\n flx.json,\n '{\"address\":{\"city\":\"Bla\",\"countryCode\":\"XX\",\"zip\":\"12345\"},\"age\":35,\"flags\":[true,false,true,true],\"name\":\"Maxim\",\"weight\":72.5}',\n );\n });\n\n test('complex map iterators', () {\n var flx = complexMap();\n expect(flx.mapKeyIterable.map((e) => e).toList(), [\n 'address',\n 'age',\n 'flags',\n 'name',\n 'weight',\n ]);\n expect(flx.mapValueIterable.map((e) => e.json).toList(), [\n flx['address'].json,\n flx['age'].json,\n flx['flags'].json,\n flx['name'].json,\n flx['weight'].json,\n ]);\n expect(flx['flags'].vectorIterable.map((e) => e.boolValue).toList(), [\n true,\n false,\n true,\n true,\n ]);\n });\n\n test('bug where offest were stored as int instead of uint', () {\n const data = [\n 99,\n 104,\n 97,\n 110,\n 110,\n 101,\n 108,\n 115,\n 95,\n 105,\n 110,\n 0,\n 100,\n 105,\n 108,\n 97,\n 116,\n 105,\n 111,\n 110,\n 95,\n 104,\n 101,\n 105,\n 103,\n 104,\n 116,\n 95,\n 102,\n 97,\n 99,\n 116,\n 111,\n 114,\n 0,\n 100,\n 105,\n 108,\n 97,\n 116,\n 105,\n 111,\n 110,\n 95,\n 119,\n 105,\n 100,\n 116,\n 104,\n 95,\n 102,\n 97,\n 99,\n 116,\n 111,\n 114,\n 0,\n 102,\n 117,\n 115,\n 101,\n 100,\n 95,\n 97,\n 99,\n 116,\n 105,\n 118,\n 97,\n 116,\n 105,\n 111,\n 110,\n 95,\n 102,\n 117,\n 110,\n 99,\n 116,\n 105,\n 111,\n 110,\n 0,\n 112,\n 97,\n 100,\n 95,\n 118,\n 97,\n 108,\n 117,\n 101,\n 115,\n 0,\n 112,\n 97,\n 100,\n 100,\n 105,\n 110,\n 103,\n 0,\n 115,\n 116,\n 114,\n 105,\n 100,\n 101,\n 95,\n 104,\n 101,\n 105,\n 103,\n 104,\n 116,\n 0,\n 115,\n 116,\n 114,\n 105,\n 100,\n 101,\n 95,\n 119,\n 105,\n 100,\n 116,\n 104,\n 0,\n 8,\n 130,\n 119,\n 97,\n 76,\n 51,\n 41,\n 34,\n 21,\n 8,\n 1,\n 8,\n 64,\n 1,\n 1,\n 1,\n 1,\n 0,\n 1,\n 1,\n 4,\n 4,\n 4,\n 4,\n 4,\n 4,\n 4,\n 4,\n 16,\n 36,\n 1,\n ];\n var flx = Reference.fromBuffer(b(data));\n expect(\n flx.json,\n '{\"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}',\n );\n const object = {\n \"channels_in\": 64,\n \"dilation_height_factor\": 1,\n \"dilation_width_factor\": 1,\n \"fused_activation_function\": 1,\n \"pad_values\": 1,\n \"padding\": 0,\n \"stride_height\": 1,\n \"stride_width\": 1,\n };\n var data1 = Builder.buildFromObject(object).asUint8List();\n expect(data1.length, data.length);\n var flx1 = Reference.fromBuffer(b(data1));\n expect(\n flx1.json,\n '{\"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}',\n );\n });\n}\n\nByteBuffer b(List values) {\n var data = Uint8List.fromList(values);\n return data.buffer;\n}\n\nvoid testNumbers(List buffer, List numbers) {\n var flx = Reference.fromBuffer(b(buffer));\n expect(flx.length, numbers.length);\n for (var i = 0; i < flx.length; i++) {\n expect(flx[i].numValue, closeTo(numbers[i], 0.001));\n }\n}\n\nvoid testStrings(List buffer, List numbers) {\n var flx = Reference.fromBuffer(b(buffer));\n expect(flx.length, numbers.length);\n for (var i = 0; i < flx.length; i++) {\n expect(flx[i].stringValue, numbers[i]);\n }\n}\n\nReference complexMap() {\n // {\n // \"age\": 35,\n // \"flags\": [True, False, True, True],\n // \"weight\": 72.5,\n // \"name\": \"Maxim\",\n // \"address\": {\n // \"city\": \"Bla\",\n // \"zip\": \"12345\",\n // \"countryCode\": \"XX\",\n // }\n // }\n return Reference.fromBuffer(\n b([\n 97,\n 100,\n 100,\n 114,\n 101,\n 115,\n 115,\n 0,\n 99,\n 105,\n 116,\n 121,\n 0,\n 3,\n 66,\n 108,\n 97,\n 0,\n 99,\n 111,\n 117,\n 110,\n 116,\n 114,\n 121,\n 67,\n 111,\n 100,\n 101,\n 0,\n 2,\n 88,\n 88,\n 0,\n 122,\n 105,\n 112,\n 0,\n 5,\n 49,\n 50,\n 51,\n 52,\n 53,\n 0,\n 3,\n 38,\n 29,\n 14,\n 3,\n 1,\n 3,\n 38,\n 22,\n 15,\n 20,\n 20,\n 20,\n 97,\n 103,\n 101,\n 0,\n 102,\n 108,\n 97,\n 103,\n 115,\n 0,\n 4,\n 1,\n 0,\n 1,\n 1,\n 110,\n 97,\n 109,\n 101,\n 0,\n 5,\n 77,\n 97,\n 120,\n 105,\n 109,\n 0,\n 119,\n 101,\n 105,\n 103,\n 104,\n 116,\n 0,\n 5,\n 93,\n 36,\n 33,\n 23,\n 12,\n 0,\n 0,\n 7,\n 0,\n 0,\n 0,\n 1,\n 0,\n 0,\n 0,\n 5,\n 0,\n 0,\n 0,\n 60,\n 0,\n 0,\n 0,\n 35,\n 0,\n 0,\n 0,\n 51,\n 0,\n 0,\n 0,\n 45,\n 0,\n 0,\n 0,\n 0,\n 0,\n 145,\n 66,\n 36,\n 4,\n 144,\n 20,\n 14,\n 25,\n 38,\n 1,\n ]),\n );\n}\n" }, { "path": "dart/test/flex_types_test.dart", "content": "import 'package:flat_buffers/src/types.dart';\nimport 'package:test/test.dart';\n\nvoid main() {\n test('is inline', () {\n expect(ValueTypeUtils.isInline(ValueType.Bool), isTrue);\n expect(ValueTypeUtils.isInline(ValueType.Int), isTrue);\n expect(ValueTypeUtils.isInline(ValueType.UInt), isTrue);\n expect(ValueTypeUtils.isInline(ValueType.Float), isTrue);\n expect(ValueTypeUtils.isInline(ValueType.Null), isTrue);\n expect(ValueTypeUtils.isInline(ValueType.String), isFalse);\n });\n test('is type vector element', () {\n expect(ValueTypeUtils.isTypedVectorElement(ValueType.Bool), isTrue);\n expect(ValueTypeUtils.isTypedVectorElement(ValueType.Int), isTrue);\n expect(ValueTypeUtils.isTypedVectorElement(ValueType.UInt), isTrue);\n expect(ValueTypeUtils.isTypedVectorElement(ValueType.Float), isTrue);\n expect(ValueTypeUtils.isTypedVectorElement(ValueType.Key), isTrue);\n expect(ValueTypeUtils.isTypedVectorElement(ValueType.String), isTrue);\n\n expect(ValueTypeUtils.isTypedVectorElement(ValueType.Null), isFalse);\n expect(ValueTypeUtils.isTypedVectorElement(ValueType.Blob), isFalse);\n });\n test('is typed vector', () {\n expect(ValueTypeUtils.isTypedVector(ValueType.VectorInt), isTrue);\n expect(ValueTypeUtils.isTypedVector(ValueType.VectorUInt), isTrue);\n expect(ValueTypeUtils.isTypedVector(ValueType.VectorFloat), isTrue);\n expect(ValueTypeUtils.isTypedVector(ValueType.VectorBool), isTrue);\n expect(ValueTypeUtils.isTypedVector(ValueType.VectorKey), isTrue);\n expect(ValueTypeUtils.isTypedVector(ValueType.VectorString), isTrue);\n\n expect(ValueTypeUtils.isTypedVector(ValueType.Vector), isFalse);\n expect(ValueTypeUtils.isTypedVector(ValueType.Map), isFalse);\n expect(ValueTypeUtils.isTypedVector(ValueType.Bool), isFalse);\n expect(ValueTypeUtils.isTypedVector(ValueType.VectorInt2), isFalse);\n });\n test('is fixed typed vector', () {\n expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorInt2), isTrue);\n expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorInt3), isTrue);\n expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorInt4), isTrue);\n expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorUInt2), isTrue);\n expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorUInt3), isTrue);\n expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorUInt4), isTrue);\n expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorFloat2), isTrue);\n expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorFloat3), isTrue);\n expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorFloat4), isTrue);\n\n expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorInt), isFalse);\n });\n test('to typed vector', () {\n expect(\n ValueTypeUtils.toTypedVector(ValueType.Int, 0),\n equals(ValueType.VectorInt),\n );\n expect(\n ValueTypeUtils.toTypedVector(ValueType.UInt, 0),\n equals(ValueType.VectorUInt),\n );\n expect(\n ValueTypeUtils.toTypedVector(ValueType.Bool, 0),\n equals(ValueType.VectorBool),\n );\n expect(\n ValueTypeUtils.toTypedVector(ValueType.Float, 0),\n equals(ValueType.VectorFloat),\n );\n expect(\n ValueTypeUtils.toTypedVector(ValueType.Key, 0),\n equals(ValueType.VectorKey),\n );\n expect(\n ValueTypeUtils.toTypedVector(ValueType.String, 0),\n equals(ValueType.VectorString),\n );\n\n expect(\n ValueTypeUtils.toTypedVector(ValueType.Int, 2),\n equals(ValueType.VectorInt2),\n );\n expect(\n ValueTypeUtils.toTypedVector(ValueType.UInt, 2),\n equals(ValueType.VectorUInt2),\n );\n expect(\n ValueTypeUtils.toTypedVector(ValueType.Float, 2),\n equals(ValueType.VectorFloat2),\n );\n\n expect(\n ValueTypeUtils.toTypedVector(ValueType.Int, 3),\n equals(ValueType.VectorInt3),\n );\n expect(\n ValueTypeUtils.toTypedVector(ValueType.UInt, 3),\n equals(ValueType.VectorUInt3),\n );\n expect(\n ValueTypeUtils.toTypedVector(ValueType.Float, 3),\n equals(ValueType.VectorFloat3),\n );\n\n expect(\n ValueTypeUtils.toTypedVector(ValueType.Int, 4),\n equals(ValueType.VectorInt4),\n );\n expect(\n ValueTypeUtils.toTypedVector(ValueType.UInt, 4),\n equals(ValueType.VectorUInt4),\n );\n expect(\n ValueTypeUtils.toTypedVector(ValueType.Float, 4),\n equals(ValueType.VectorFloat4),\n );\n });\n test('typed vector element type', () {\n expect(\n ValueTypeUtils.typedVectorElementType(ValueType.VectorInt),\n equals(ValueType.Int),\n );\n expect(\n ValueTypeUtils.typedVectorElementType(ValueType.VectorUInt),\n equals(ValueType.UInt),\n );\n expect(\n ValueTypeUtils.typedVectorElementType(ValueType.VectorFloat),\n equals(ValueType.Float),\n );\n expect(\n ValueTypeUtils.typedVectorElementType(ValueType.VectorString),\n equals(ValueType.String),\n );\n expect(\n ValueTypeUtils.typedVectorElementType(ValueType.VectorKey),\n equals(ValueType.Key),\n );\n expect(\n ValueTypeUtils.typedVectorElementType(ValueType.VectorBool),\n equals(ValueType.Bool),\n );\n });\n test('fixed typed vector element type', () {\n expect(\n ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorInt2),\n equals(ValueType.Int),\n );\n expect(\n ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorInt3),\n equals(ValueType.Int),\n );\n expect(\n ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorInt4),\n equals(ValueType.Int),\n );\n\n expect(\n ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorUInt2),\n equals(ValueType.UInt),\n );\n expect(\n ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorUInt3),\n equals(ValueType.UInt),\n );\n expect(\n ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorUInt4),\n equals(ValueType.UInt),\n );\n\n expect(\n ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorFloat2),\n equals(ValueType.Float),\n );\n expect(\n ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorFloat3),\n equals(ValueType.Float),\n );\n expect(\n ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorFloat4),\n equals(ValueType.Float),\n );\n });\n test('fixed typed vector element size', () {\n expect(\n ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorInt2),\n equals(2),\n );\n expect(\n ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorInt3),\n equals(3),\n );\n expect(\n ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorInt4),\n equals(4),\n );\n\n expect(\n ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorUInt2),\n equals(2),\n );\n expect(\n ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorUInt3),\n equals(3),\n );\n expect(\n ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorUInt4),\n equals(4),\n );\n\n expect(\n ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorFloat2),\n equals(2),\n );\n expect(\n ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorFloat3),\n equals(3),\n );\n expect(\n ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorFloat4),\n equals(4),\n );\n });\n test('packed type', () {\n expect(\n ValueTypeUtils.packedType(ValueType.Null, BitWidth.width8),\n equals(0),\n );\n expect(\n ValueTypeUtils.packedType(ValueType.Null, BitWidth.width16),\n equals(1),\n );\n expect(\n ValueTypeUtils.packedType(ValueType.Null, BitWidth.width32),\n equals(2),\n );\n expect(\n ValueTypeUtils.packedType(ValueType.Null, BitWidth.width64),\n equals(3),\n );\n\n expect(\n ValueTypeUtils.packedType(ValueType.Int, BitWidth.width8),\n equals(4),\n );\n expect(\n ValueTypeUtils.packedType(ValueType.Int, BitWidth.width16),\n equals(5),\n );\n expect(\n ValueTypeUtils.packedType(ValueType.Int, BitWidth.width32),\n equals(6),\n );\n expect(\n ValueTypeUtils.packedType(ValueType.Int, BitWidth.width64),\n equals(7),\n );\n });\n test('bit width', () {\n expect(BitWidthUtil.width(0), BitWidth.width8);\n expect(BitWidthUtil.width(-20), BitWidth.width8);\n expect(BitWidthUtil.width(127), BitWidth.width8);\n expect(BitWidthUtil.width(128), BitWidth.width16);\n expect(BitWidthUtil.width(128123), BitWidth.width32);\n expect(BitWidthUtil.width(12812324534), BitWidth.width64);\n expect(BitWidthUtil.width(-127), BitWidth.width8);\n expect(BitWidthUtil.width(-128), BitWidth.width16);\n expect(BitWidthUtil.width(-12812324534), BitWidth.width64);\n expect(BitWidthUtil.width(-0.1), BitWidth.width64);\n expect(BitWidthUtil.width(0.25), BitWidth.width32);\n });\n test('padding size', () {\n expect(BitWidthUtil.paddingSize(10, 8), 6);\n expect(BitWidthUtil.paddingSize(10, 4), 2);\n expect(BitWidthUtil.paddingSize(15, 4), 1);\n expect(BitWidthUtil.paddingSize(15, 2), 1);\n expect(BitWidthUtil.paddingSize(15, 1), 0);\n expect(BitWidthUtil.paddingSize(16, 8), 0);\n expect(BitWidthUtil.paddingSize(17, 8), 7);\n });\n}\n" }, { "path": "dart/test/include_test1_generated.dart", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable, constant_identifier_names\n\nimport 'dart:typed_data' show Uint8List;\n\nimport 'package:flat_buffers/flat_buffers.dart' as fb;\n\nimport './include_test2_my_game.other_name_space_generated.dart'\n as my_game_other_name_space;\n\nclass TableA {\n TableA._(this._bc, this._bcOffset);\n factory TableA(List bytes) {\n final rootRef = fb.BufferContext.fromBytes(bytes);\n return reader.read(rootRef, 0);\n }\n\n static const fb.Reader reader = _TableAReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n my_game_other_name_space.TableB? get b => my_game_other_name_space\n .TableB\n .reader\n .vTableGetNullable(_bc, _bcOffset, 4);\n\n @override\n String toString() {\n return 'TableA{b: ${b}}';\n }\n\n TableAT unpack() => TableAT(b: b?.unpack());\n\n static int pack(fb.Builder fbBuilder, TableAT? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass TableAT implements fb.Packable {\n my_game_other_name_space.TableBT? b;\n\n TableAT({this.b});\n\n @override\n int pack(fb.Builder fbBuilder) {\n final int? bOffset = b?.pack(fbBuilder);\n fbBuilder.startTable(1);\n fbBuilder.addOffset(0, bOffset);\n return fbBuilder.endTable();\n }\n\n @override\n String toString() {\n return 'TableAT{b: ${b}}';\n }\n}\n\nclass _TableAReader extends fb.TableReader {\n const _TableAReader();\n\n @override\n TableA createObject(fb.BufferContext bc, int offset) => TableA._(bc, offset);\n}\n\nclass TableABuilder {\n TableABuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n void begin() {\n fbBuilder.startTable(1);\n }\n\n int addBOffset(int? offset) {\n fbBuilder.addOffset(0, offset);\n return fbBuilder.offset;\n }\n\n int finish() {\n return fbBuilder.endTable();\n }\n}\n\nclass TableAObjectBuilder extends fb.ObjectBuilder {\n final my_game_other_name_space.TableBObjectBuilder? _b;\n\n TableAObjectBuilder({my_game_other_name_space.TableBObjectBuilder? b})\n : _b = b;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n final int? bOffset = _b?.getOrCreateOffset(fbBuilder);\n fbBuilder.startTable(1);\n fbBuilder.addOffset(0, bOffset);\n return fbBuilder.endTable();\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n" }, { "path": "dart/test/include_test2_my_game.other_name_space_generated.dart", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable, constant_identifier_names\n\nlibrary my_game.other_name_space;\n\nimport 'dart:typed_data' show Uint8List;\n\nimport 'package:flat_buffers/flat_buffers.dart' as fb;\n\nimport './include_test1_generated.dart';\n\nenum FromInclude {\n IncludeVal(0);\n\n final int value;\n const FromInclude(this.value);\n\n factory FromInclude.fromValue(int value) {\n switch (value) {\n case 0:\n return FromInclude.IncludeVal;\n default:\n throw StateError('Invalid value $value for bit flag enum');\n }\n }\n\n static FromInclude? _createOrNull(int? value) =>\n value == null ? null : FromInclude.fromValue(value);\n\n static const int minValue = 0;\n static const int maxValue = 0;\n static const fb.Reader reader = _FromIncludeReader();\n}\n\nclass _FromIncludeReader extends fb.Reader {\n const _FromIncludeReader();\n\n @override\n int get size => 8;\n\n @override\n FromInclude read(fb.BufferContext bc, int offset) =>\n FromInclude.fromValue(const fb.Int64Reader().read(bc, offset));\n}\n\nclass Unused {\n Unused._(this._bc, this._bcOffset);\n\n static const fb.Reader reader = _UnusedReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n int get a => const fb.Int32Reader().read(_bc, _bcOffset + 0);\n\n @override\n String toString() {\n return 'Unused{a: ${a}}';\n }\n\n UnusedT unpack() => UnusedT(a: a);\n\n static int pack(fb.Builder fbBuilder, UnusedT? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass UnusedT implements fb.Packable {\n int a;\n\n UnusedT({required this.a});\n\n @override\n int pack(fb.Builder fbBuilder) {\n fbBuilder.putInt32(a);\n return fbBuilder.offset;\n }\n\n @override\n String toString() {\n return 'UnusedT{a: ${a}}';\n }\n}\n\nclass _UnusedReader extends fb.StructReader {\n const _UnusedReader();\n\n @override\n int get size => 4;\n\n @override\n Unused createObject(fb.BufferContext bc, int offset) => Unused._(bc, offset);\n}\n\nclass UnusedBuilder {\n UnusedBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n int finish(int a) {\n fbBuilder.putInt32(a);\n return fbBuilder.offset;\n }\n}\n\nclass UnusedObjectBuilder extends fb.ObjectBuilder {\n final int _a;\n\n UnusedObjectBuilder({required int a}) : _a = a;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n fbBuilder.putInt32(_a);\n return fbBuilder.offset;\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n\nclass TableB {\n TableB._(this._bc, this._bcOffset);\n factory TableB(List bytes) {\n final rootRef = fb.BufferContext.fromBytes(bytes);\n return reader.read(rootRef, 0);\n }\n\n static const fb.Reader reader = _TableBReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n TableA? get a => TableA.reader.vTableGetNullable(_bc, _bcOffset, 4);\n\n @override\n String toString() {\n return 'TableB{a: ${a}}';\n }\n\n TableBT unpack() => TableBT(a: a?.unpack());\n\n static int pack(fb.Builder fbBuilder, TableBT? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass TableBT implements fb.Packable {\n TableAT? a;\n\n TableBT({this.a});\n\n @override\n int pack(fb.Builder fbBuilder) {\n final int? aOffset = a?.pack(fbBuilder);\n fbBuilder.startTable(1);\n fbBuilder.addOffset(0, aOffset);\n return fbBuilder.endTable();\n }\n\n @override\n String toString() {\n return 'TableBT{a: ${a}}';\n }\n}\n\nclass _TableBReader extends fb.TableReader {\n const _TableBReader();\n\n @override\n TableB createObject(fb.BufferContext bc, int offset) => TableB._(bc, offset);\n}\n\nclass TableBBuilder {\n TableBBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n void begin() {\n fbBuilder.startTable(1);\n }\n\n int addAOffset(int? offset) {\n fbBuilder.addOffset(0, offset);\n return fbBuilder.offset;\n }\n\n int finish() {\n return fbBuilder.endTable();\n }\n}\n\nclass TableBObjectBuilder extends fb.ObjectBuilder {\n final TableAObjectBuilder? _a;\n\n TableBObjectBuilder({TableAObjectBuilder? a}) : _a = a;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n final int? aOffset = _a?.getOrCreateOffset(fbBuilder);\n fbBuilder.startTable(1);\n fbBuilder.addOffset(0, aOffset);\n return fbBuilder.endTable();\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n" }, { "path": "dart/test/keyword_test_keyword_test_generated.dart", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable, constant_identifier_names\n\nlibrary keyword_test;\n\nimport 'dart:typed_data' show Uint8List;\nimport 'package:flat_buffers/flat_buffers.dart' as fb;\n\n\n\nenum Abc {\n $void(0),\n where(1),\n stackalloc(2);\n\n final int value;\n const Abc(this.value);\n\n factory Abc.fromValue(int value) {\n switch (value) {\n case 0: return Abc.$void;\n case 1: return Abc.where;\n case 2: return Abc.stackalloc;\n default: throw StateError('Invalid value $value for bit flag enum');\n }\n }\n\n static Abc? _createOrNull(int? value) =>\n value == null ? null : Abc.fromValue(value);\n\n static const int minValue = 0;\n static const int maxValue = 2;\n static const fb.Reader reader = _AbcReader();\n}\n\nclass _AbcReader extends fb.Reader {\n const _AbcReader();\n\n @override\n int get size => 4;\n\n @override\n Abc read(fb.BufferContext bc, int offset) =>\n Abc.fromValue(const fb.Int32Reader().read(bc, offset));\n}\n\nenum Public {\n NONE(0);\n\n final int value;\n const Public(this.value);\n\n factory Public.fromValue(int value) {\n switch (value) {\n case 0: return Public.NONE;\n default: throw StateError('Invalid value $value for bit flag enum');\n }\n }\n\n static Public? _createOrNull(int? value) =>\n value == null ? null : Public.fromValue(value);\n\n static const int minValue = 0;\n static const int maxValue = 0;\n static const fb.Reader reader = _PublicReader();\n}\n\nclass _PublicReader extends fb.Reader {\n const _PublicReader();\n\n @override\n int get size => 4;\n\n @override\n Public read(fb.BufferContext bc, int offset) =>\n Public.fromValue(const fb.Int32Reader().read(bc, offset));\n}\n\nenum KeywordsInUnionTypeId {\n NONE(0),\n $static(1),\n internal(2);\n\n final int value;\n const KeywordsInUnionTypeId(this.value);\n\n factory KeywordsInUnionTypeId.fromValue(int value) {\n switch (value) {\n case 0: return KeywordsInUnionTypeId.NONE;\n case 1: return KeywordsInUnionTypeId.$static;\n case 2: return KeywordsInUnionTypeId.internal;\n default: throw StateError('Invalid value $value for bit flag enum');\n }\n }\n\n static KeywordsInUnionTypeId? _createOrNull(int? value) =>\n value == null ? null : KeywordsInUnionTypeId.fromValue(value);\n\n static const int minValue = 0;\n static const int maxValue = 2;\n static const fb.Reader reader = _KeywordsInUnionTypeIdReader();\n}\n\nclass _KeywordsInUnionTypeIdReader extends fb.Reader {\n const _KeywordsInUnionTypeIdReader();\n\n @override\n int get size => 1;\n\n @override\n KeywordsInUnionTypeId read(fb.BufferContext bc, int offset) =>\n KeywordsInUnionTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));\n}\n\nclass KeywordsInTable {\n KeywordsInTable._(this._bc, this._bcOffset);\n factory KeywordsInTable(List bytes) {\n final rootRef = fb.BufferContext.fromBytes(bytes);\n return reader.read(rootRef, 0);\n }\n\n static const fb.Reader reader = _KeywordsInTableReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n Abc get $is => Abc.fromValue(const fb.Int32Reader().vTableGet(_bc, _bcOffset, 4, 0));\n Public get private => Public.fromValue(const fb.Int32Reader().vTableGet(_bc, _bcOffset, 6, 0));\n int get type => const fb.Int32Reader().vTableGet(_bc, _bcOffset, 8, 0);\n bool get $default => const fb.BoolReader().vTableGet(_bc, _bcOffset, 10, false);\n\n @override\n String toString() {\n return 'KeywordsInTable{\\$is: ${$is}, private: ${private}, type: ${type}, \\$default: ${$default}}';\n }\n\n KeywordsInTableT unpack() => KeywordsInTableT(\n $is: $is,\n private: private,\n type: type,\n $default: $default);\n\n static int pack(fb.Builder fbBuilder, KeywordsInTableT? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass KeywordsInTableT implements fb.Packable {\n Abc $is;\n Public private;\n int type;\n bool $default;\n\n KeywordsInTableT({\n this.$is = Abc.$void,\n this.private = Public.NONE,\n this.type = 0,\n this.$default = false});\n\n @override\n int pack(fb.Builder fbBuilder) {\n fbBuilder.startTable(4);\n fbBuilder.addInt32(0, $is.value);\n fbBuilder.addInt32(1, private.value);\n fbBuilder.addInt32(2, type);\n fbBuilder.addBool(3, $default);\n return fbBuilder.endTable();\n }\n\n @override\n String toString() {\n return 'KeywordsInTableT{\\$is: ${$is}, private: ${private}, type: ${type}, \\$default: ${$default}}';\n }\n}\n\nclass _KeywordsInTableReader extends fb.TableReader {\n const _KeywordsInTableReader();\n\n @override\n KeywordsInTable createObject(fb.BufferContext bc, int offset) => \n KeywordsInTable._(bc, offset);\n}\n\nclass KeywordsInTableBuilder {\n KeywordsInTableBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n void begin() {\n fbBuilder.startTable(4);\n }\n\n int addIs(Abc? $is) {\n fbBuilder.addInt32(0, $is?.value);\n return fbBuilder.offset;\n }\n int addPrivate(Public? private) {\n fbBuilder.addInt32(1, private?.value);\n return fbBuilder.offset;\n }\n int addType(int? type) {\n fbBuilder.addInt32(2, type);\n return fbBuilder.offset;\n }\n int addDefault(bool? $default) {\n fbBuilder.addBool(3, $default);\n return fbBuilder.offset;\n }\n\n int finish() {\n return fbBuilder.endTable();\n }\n}\n\nclass KeywordsInTableObjectBuilder extends fb.ObjectBuilder {\n final Abc? _$is;\n final Public? _private;\n final int? _type;\n final bool? _$default;\n\n KeywordsInTableObjectBuilder({\n Abc? $is,\n Public? private,\n int? type,\n bool? $default,\n })\n : _$is = $is,\n _private = private,\n _type = type,\n _$default = $default;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n fbBuilder.startTable(4);\n fbBuilder.addInt32(0, _$is?.value);\n fbBuilder.addInt32(1, _private?.value);\n fbBuilder.addInt32(2, _type);\n fbBuilder.addBool(3, _$default);\n return fbBuilder.endTable();\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\nclass Table2 {\n Table2._(this._bc, this._bcOffset);\n factory Table2(List bytes) {\n final rootRef = fb.BufferContext.fromBytes(bytes);\n return reader.read(rootRef, 0);\n }\n\n static const fb.Reader reader = _Table2Reader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n KeywordsInUnionTypeId? get typeType => KeywordsInUnionTypeId._createOrNull(const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 4));\n dynamic get type {\n switch (typeType?.value) {\n case 1: return KeywordsInTable.reader.vTableGetNullable(_bc, _bcOffset, 6);\n case 2: return KeywordsInTable.reader.vTableGetNullable(_bc, _bcOffset, 6);\n default: return null;\n }\n }\n\n @override\n String toString() {\n return 'Table2{typeType: ${typeType}, type: ${type}}';\n }\n\n Table2T unpack() => Table2T(\n typeType: typeType,\n type: type?.unpack());\n\n static int pack(fb.Builder fbBuilder, Table2T? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass Table2T implements fb.Packable {\n KeywordsInUnionTypeId? typeType;\n dynamic type;\n\n Table2T({\n this.typeType,\n this.type});\n\n @override\n int pack(fb.Builder fbBuilder) {\n final int? typeOffset = type?.pack(fbBuilder);\n fbBuilder.startTable(2);\n fbBuilder.addUint8(0, typeType?.value);\n fbBuilder.addOffset(1, typeOffset);\n return fbBuilder.endTable();\n }\n\n @override\n String toString() {\n return 'Table2T{typeType: ${typeType}, type: ${type}}';\n }\n}\n\nclass _Table2Reader extends fb.TableReader {\n const _Table2Reader();\n\n @override\n Table2 createObject(fb.BufferContext bc, int offset) => \n Table2._(bc, offset);\n}\n\nclass Table2Builder {\n Table2Builder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n void begin() {\n fbBuilder.startTable(2);\n }\n\n int addTypeType(KeywordsInUnionTypeId? typeType) {\n fbBuilder.addUint8(0, typeType?.value);\n return fbBuilder.offset;\n }\n int addTypeOffset(int? offset) {\n fbBuilder.addOffset(1, offset);\n return fbBuilder.offset;\n }\n\n int finish() {\n return fbBuilder.endTable();\n }\n}\n\nclass Table2ObjectBuilder extends fb.ObjectBuilder {\n final KeywordsInUnionTypeId? _typeType;\n final dynamic _type;\n\n Table2ObjectBuilder({\n KeywordsInUnionTypeId? typeType,\n dynamic type,\n })\n : _typeType = typeType,\n _type = type;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n final int? typeOffset = _type?.getOrCreateOffset(fbBuilder);\n fbBuilder.startTable(2);\n fbBuilder.addUint8(0, _typeType?.value);\n fbBuilder.addOffset(1, typeOffset);\n return fbBuilder.endTable();\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n" }, { "path": "dart/test/monster_test.fbs", "content": "// test schema file\n\ninclude \"include_test1.fbs\";\n\nnamespace MyGame;\n\ntable InParentNamespace {}\n\nnamespace MyGame.Example2;\n\ntable Monster {} // Test having same name as below, but in different namespace.\n\nnamespace MyGame.Example;\n\nattribute \"priority\";\n\n/// Composite components of Monster color.\nenum Color:ubyte (bit_flags) {\n Red = 0, // color Red = (1u << 0)\n /// \\brief color Green\n /// Green is bit_flag with value (1u << 1)\n Green,\n /// \\brief color Blue (1u << 3)\n Blue = 3,\n}\n\nenum Race:byte {\n None = -1,\n Human = 0,\n Dwarf,\n Elf,\n}\n\nenum LongEnum:ulong (bit_flags) {\n LongOne = 1,\n LongTwo = 2,\n // Because this is a bitflag, 40 will be out of range of a 32-bit integer,\n // allowing us to exercise any logic special to big numbers.\n LongBig = 40,\n}\n\nunion Any { Monster, TestSimpleTableWithEnum, MyGame.Example2.Monster }\n\nunion AnyUniqueAliases { M: Monster, TS: TestSimpleTableWithEnum, M2: MyGame.Example2.Monster }\nunion AnyAmbiguousAliases { M1: Monster, M2: Monster, M3: Monster }\n\nstruct Test { a:short; b:byte; }\n\ntable TestSimpleTableWithEnum (csharp_partial, private) {\n color: Color = Green;\n}\n\nstruct Vec3 (force_align: 8) {\n x:float;\n y:float;\n z:float;\n test1:double;\n test2:Color;\n test3:Test;\n}\n\nstruct Ability {\n id:uint(key);\n distance:uint;\n}\n\nstruct StructOfStructs {\n a: Ability;\n b: Test;\n c: Ability;\n}\n\nstruct StructOfStructsOfStructs {\n a: StructOfStructs;\n}\n\ntable Stat {\n id:string;\n val:long;\n count:ushort (key);\n}\n\ntable Referrable {\n id:ulong(key, hash:\"fnv1a_64\");\n}\n\n/// an example documentation comment: \"monster object\"\ntable Monster {\n pos:Vec3 (id: 0);\n hp:short = 100 (id: 2);\n mana:short = 150 (id: 1);\n name:string (id: 3, key);\n color:Color = Blue (id: 6);\n inventory:[ubyte] (id: 5);\n friendly:bool = false (deprecated, priority: 1, id: 4);\n /// an example documentation comment: this will end up in the generated code\n /// multiline too\n testarrayoftables:[Monster] (id: 11);\n testarrayofstring:[string] (id: 10);\n testarrayofstring2:[string] (id: 28);\n testarrayofbools:[bool] (id: 24);\n testarrayofsortedstruct:[Ability] (id: 29);\n enemy:MyGame.Example.Monster (id:12); // Test referring by full namespace.\n test:Any (id: 8);\n test4:[Test] (id: 9);\n test5:[Test] (id: 31);\n testnestedflatbuffer:[ubyte] (id:13, nested_flatbuffer: \"Monster\");\n testempty:Stat (id:14);\n testbool:bool (id:15);\n testhashs32_fnv1:int (id:16, hash:\"fnv1_32\");\n testhashu32_fnv1:uint (id:17, hash:\"fnv1_32\");\n testhashs64_fnv1:long (id:18, hash:\"fnv1_64\");\n testhashu64_fnv1:ulong (id:19, hash:\"fnv1_64\");\n testhashs32_fnv1a:int (id:20, hash:\"fnv1a_32\");\n testhashu32_fnv1a:uint (id:21, hash:\"fnv1a_32\", cpp_type:\"Stat\");\n testhashs64_fnv1a:long (id:22, hash:\"fnv1a_64\");\n testhashu64_fnv1a:ulong (id:23, hash:\"fnv1a_64\");\n testf:float = 3.14159 (id:25);\n testf2:float = 3 (id:26);\n testf3:float (id:27);\n flex:[ubyte] (id:30, flexbuffer);\n vector_of_longs:[long] (id:32);\n vector_of_doubles:[double] (id:33);\n parent_namespace_test:InParentNamespace (id:34);\n vector_of_referrables:[Referrable](id:35);\n single_weak_reference:ulong(id:36, hash:\"fnv1a_64\", cpp_type:\"ReferrableT\");\n vector_of_weak_references:[ulong](id:37, hash:\"fnv1a_64\", cpp_type:\"ReferrableT\");\n vector_of_strong_referrables:[Referrable](id:38, cpp_ptr_type:\"default_ptr_type\"); //was shared_ptr\n co_owning_reference:ulong(id:39, hash:\"fnv1a_64\", cpp_type:\"ReferrableT\", cpp_ptr_type:\"naked\"); //was shared_ptr as well\n vector_of_co_owning_references:[ulong](id:40, hash:\"fnv1a_64\", cpp_type:\"ReferrableT\", cpp_ptr_type:\"default_ptr_type\", cpp_ptr_type_get:\".get()\"); //was shared_ptr\n non_owning_reference:ulong(id:41, hash:\"fnv1a_64\", cpp_type:\"ReferrableT\", cpp_ptr_type:\"naked\", cpp_ptr_type_get:\"\"); //was weak_ptr\n vector_of_non_owning_references:[ulong](id:42, hash:\"fnv1a_64\", cpp_type:\"ReferrableT\", cpp_ptr_type:\"naked\", cpp_ptr_type_get:\"\"); //was weak_ptr\n any_unique:AnyUniqueAliases(id:44);\n any_ambiguous:AnyAmbiguousAliases (id:46);\n vector_of_enums:[Color] (id:47);\n signed_enum:Race = None (id:48);\n testrequirednestedflatbuffer:[ubyte] (id:49, nested_flatbuffer: \"Monster\");\n scalar_key_sorted_tables:[Stat] (id: 50);\n native_inline:Test (id: 51, native_inline);\n // The default value of this enum will be a numeric zero, which isn't a valid\n // enum value.\n long_enum_non_enum_default:LongEnum (id: 52);\n long_enum_normal_default:LongEnum = LongOne (id: 53);\n // Test that default values nan and +/-inf work.\n nan_default:float = nan (id: 54);\n inf_default:float = inf (id: 55);\n positive_inf_default:float = +inf (id: 56);\n infinity_default:float = infinity (id: 57);\n positive_infinity_default:float = +infinity (id: 58);\n negative_inf_default:float = -inf (id: 59);\n negative_infinity_default:float = -infinity (id: 60);\n double_inf_default:double = inf (id: 61);\n}\n\ntable TypeAliases {\n i8:int8;\n u8:uint8;\n i16:int16;\n u16:uint16;\n i32:int32;\n u32:uint32;\n i64:int64;\n u64:uint64;\n f32:float32;\n f64:float64;\n v8:[int8];\n vf64:[float64];\n}\n\nrpc_service MonsterStorage {\n Store(Monster):Stat (streaming: \"none\");\n Retrieve(Stat):Monster (streaming: \"server\", idempotent);\n GetMaxHitPoint(Monster):Stat (streaming: \"client\");\n GetMinMaxHitPoints(Monster):Stat (streaming: \"bidi\");\n}\n\nroot_type Monster;\n\nfile_identifier \"MONS\";\nfile_extension \"mon\";\n" }, { "path": "dart/test/monster_test_my_game.example2_generated.dart", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable, constant_identifier_names\n\nlibrary my_game.example2;\n\nimport 'dart:typed_data' show Uint8List;\n\nimport 'package:flat_buffers/flat_buffers.dart' as fb;\n\nimport './include_test1_generated.dart';\nimport './monster_test_my_game.example_generated.dart' as my_game_example;\nimport './monster_test_my_game_generated.dart' as my_game;\n\nclass Monster {\n Monster._(this._bc, this._bcOffset);\n factory Monster(List bytes) {\n final rootRef = fb.BufferContext.fromBytes(bytes);\n return reader.read(rootRef, 0);\n }\n\n static const fb.Reader reader = _MonsterReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n @override\n String toString() {\n return 'Monster{}';\n }\n\n MonsterT unpack() => MonsterT();\n\n static int pack(fb.Builder fbBuilder, MonsterT? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass MonsterT implements fb.Packable {\n @override\n int pack(fb.Builder fbBuilder) {\n fbBuilder.startTable(0);\n return fbBuilder.endTable();\n }\n\n @override\n String toString() {\n return 'MonsterT{}';\n }\n}\n\nclass _MonsterReader extends fb.TableReader {\n const _MonsterReader();\n\n @override\n Monster createObject(fb.BufferContext bc, int offset) =>\n Monster._(bc, offset);\n}\n\nclass MonsterObjectBuilder extends fb.ObjectBuilder {\n MonsterObjectBuilder();\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n fbBuilder.startTable(0);\n return fbBuilder.endTable();\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n" }, { "path": "dart/test/monster_test_my_game.example_generated.dart", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable, constant_identifier_names\n\nlibrary my_game.example;\n\nimport 'dart:typed_data' show Uint8List;\n\nimport 'package:flat_buffers/flat_buffers.dart' as fb;\n\nimport './include_test1_generated.dart';\nimport './monster_test_my_game.example2_generated.dart' as my_game_example2;\nimport './monster_test_my_game_generated.dart' as my_game;\n\n/// Composite components of Monster color.\nenum Color {\n Red(1),\n Green(2),\n Blue(8),\n _default(0);\n\n final int value;\n const Color(this.value);\n\n factory Color.fromValue(int value) {\n switch (value) {\n case 1:\n return Color.Red;\n case 2:\n return Color.Green;\n case 8:\n return Color.Blue;\n case 0:\n return Color._default;\n default:\n throw StateError('Invalid value $value for bit flag enum');\n }\n }\n\n static Color? _createOrNull(int? value) =>\n value == null ? null : Color.fromValue(value);\n\n static const fb.Reader reader = _ColorReader();\n}\n\nclass _ColorReader extends fb.Reader {\n const _ColorReader();\n\n @override\n int get size => 1;\n\n @override\n Color read(fb.BufferContext bc, int offset) =>\n Color.fromValue(const fb.Uint8Reader().read(bc, offset));\n}\n\nenum Race {\n None(-1),\n Human(0),\n Dwarf(1),\n Elf(2);\n\n final int value;\n const Race(this.value);\n\n factory Race.fromValue(int value) {\n switch (value) {\n case -1:\n return Race.None;\n case 0:\n return Race.Human;\n case 1:\n return Race.Dwarf;\n case 2:\n return Race.Elf;\n default:\n throw StateError('Invalid value $value for bit flag enum');\n }\n }\n\n static Race? _createOrNull(int? value) =>\n value == null ? null : Race.fromValue(value);\n\n static const int minValue = -1;\n static const int maxValue = 2;\n static const fb.Reader reader = _RaceReader();\n}\n\nclass _RaceReader extends fb.Reader {\n const _RaceReader();\n\n @override\n int get size => 1;\n\n @override\n Race read(fb.BufferContext bc, int offset) =>\n Race.fromValue(const fb.Int8Reader().read(bc, offset));\n}\n\nenum LongEnum {\n LongOne(2),\n LongTwo(4),\n LongBig(1099511627776),\n _default(0);\n\n final int value;\n const LongEnum(this.value);\n\n factory LongEnum.fromValue(int value) {\n switch (value) {\n case 2:\n return LongEnum.LongOne;\n case 4:\n return LongEnum.LongTwo;\n case 1099511627776:\n return LongEnum.LongBig;\n case 0:\n return LongEnum._default;\n default:\n throw StateError('Invalid value $value for bit flag enum');\n }\n }\n\n static LongEnum? _createOrNull(int? value) =>\n value == null ? null : LongEnum.fromValue(value);\n\n static const fb.Reader reader = _LongEnumReader();\n}\n\nclass _LongEnumReader extends fb.Reader {\n const _LongEnumReader();\n\n @override\n int get size => 8;\n\n @override\n LongEnum read(fb.BufferContext bc, int offset) =>\n LongEnum.fromValue(const fb.Uint64Reader().read(bc, offset));\n}\n\nenum AnyTypeId {\n NONE(0),\n Monster(1),\n TestSimpleTableWithEnum(2),\n MyGame_Example2_Monster(3);\n\n final int value;\n const AnyTypeId(this.value);\n\n factory AnyTypeId.fromValue(int value) {\n switch (value) {\n case 0:\n return AnyTypeId.NONE;\n case 1:\n return AnyTypeId.Monster;\n case 2:\n return AnyTypeId.TestSimpleTableWithEnum;\n case 3:\n return AnyTypeId.MyGame_Example2_Monster;\n default:\n throw StateError('Invalid value $value for bit flag enum');\n }\n }\n\n static AnyTypeId? _createOrNull(int? value) =>\n value == null ? null : AnyTypeId.fromValue(value);\n\n static const int minValue = 0;\n static const int maxValue = 3;\n static const fb.Reader reader = _AnyTypeIdReader();\n}\n\nclass _AnyTypeIdReader extends fb.Reader {\n const _AnyTypeIdReader();\n\n @override\n int get size => 1;\n\n @override\n AnyTypeId read(fb.BufferContext bc, int offset) =>\n AnyTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));\n}\n\nenum AnyUniqueAliasesTypeId {\n NONE(0),\n M(1),\n TS(2),\n M2(3);\n\n final int value;\n const AnyUniqueAliasesTypeId(this.value);\n\n factory AnyUniqueAliasesTypeId.fromValue(int value) {\n switch (value) {\n case 0:\n return AnyUniqueAliasesTypeId.NONE;\n case 1:\n return AnyUniqueAliasesTypeId.M;\n case 2:\n return AnyUniqueAliasesTypeId.TS;\n case 3:\n return AnyUniqueAliasesTypeId.M2;\n default:\n throw StateError('Invalid value $value for bit flag enum');\n }\n }\n\n static AnyUniqueAliasesTypeId? _createOrNull(int? value) =>\n value == null ? null : AnyUniqueAliasesTypeId.fromValue(value);\n\n static const int minValue = 0;\n static const int maxValue = 3;\n static const fb.Reader reader =\n _AnyUniqueAliasesTypeIdReader();\n}\n\nclass _AnyUniqueAliasesTypeIdReader extends fb.Reader {\n const _AnyUniqueAliasesTypeIdReader();\n\n @override\n int get size => 1;\n\n @override\n AnyUniqueAliasesTypeId read(fb.BufferContext bc, int offset) =>\n AnyUniqueAliasesTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));\n}\n\nenum AnyAmbiguousAliasesTypeId {\n NONE(0),\n M1(1),\n M2(2),\n M3(3);\n\n final int value;\n const AnyAmbiguousAliasesTypeId(this.value);\n\n factory AnyAmbiguousAliasesTypeId.fromValue(int value) {\n switch (value) {\n case 0:\n return AnyAmbiguousAliasesTypeId.NONE;\n case 1:\n return AnyAmbiguousAliasesTypeId.M1;\n case 2:\n return AnyAmbiguousAliasesTypeId.M2;\n case 3:\n return AnyAmbiguousAliasesTypeId.M3;\n default:\n throw StateError('Invalid value $value for bit flag enum');\n }\n }\n\n static AnyAmbiguousAliasesTypeId? _createOrNull(int? value) =>\n value == null ? null : AnyAmbiguousAliasesTypeId.fromValue(value);\n\n static const int minValue = 0;\n static const int maxValue = 3;\n static const fb.Reader reader =\n _AnyAmbiguousAliasesTypeIdReader();\n}\n\nclass _AnyAmbiguousAliasesTypeIdReader\n extends fb.Reader {\n const _AnyAmbiguousAliasesTypeIdReader();\n\n @override\n int get size => 1;\n\n @override\n AnyAmbiguousAliasesTypeId read(fb.BufferContext bc, int offset) =>\n AnyAmbiguousAliasesTypeId.fromValue(\n const fb.Uint8Reader().read(bc, offset),\n );\n}\n\nclass Test {\n Test._(this._bc, this._bcOffset);\n\n static const fb.Reader reader = _TestReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n int get a => const fb.Int16Reader().read(_bc, _bcOffset + 0);\n int get b => const fb.Int8Reader().read(_bc, _bcOffset + 2);\n\n @override\n String toString() {\n return 'Test{a: ${a}, b: ${b}}';\n }\n\n TestT unpack() => TestT(a: a, b: b);\n\n static int pack(fb.Builder fbBuilder, TestT? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass TestT implements fb.Packable {\n int a;\n int b;\n\n TestT({required this.a, required this.b});\n\n @override\n int pack(fb.Builder fbBuilder) {\n fbBuilder.pad(1);\n fbBuilder.putInt8(b);\n fbBuilder.putInt16(a);\n return fbBuilder.offset;\n }\n\n @override\n String toString() {\n return 'TestT{a: ${a}, b: ${b}}';\n }\n}\n\nclass _TestReader extends fb.StructReader {\n const _TestReader();\n\n @override\n int get size => 4;\n\n @override\n Test createObject(fb.BufferContext bc, int offset) => Test._(bc, offset);\n}\n\nclass TestBuilder {\n TestBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n int finish(int a, int b) {\n fbBuilder.pad(1);\n fbBuilder.putInt8(b);\n fbBuilder.putInt16(a);\n return fbBuilder.offset;\n }\n}\n\nclass TestObjectBuilder extends fb.ObjectBuilder {\n final int _a;\n final int _b;\n\n TestObjectBuilder({required int a, required int b}) : _a = a, _b = b;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n fbBuilder.pad(1);\n fbBuilder.putInt8(_b);\n fbBuilder.putInt16(_a);\n return fbBuilder.offset;\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n\nclass TestSimpleTableWithEnum {\n TestSimpleTableWithEnum._(this._bc, this._bcOffset);\n factory TestSimpleTableWithEnum(List bytes) {\n final rootRef = fb.BufferContext.fromBytes(bytes);\n return reader.read(rootRef, 0);\n }\n\n static const fb.Reader reader =\n _TestSimpleTableWithEnumReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n Color get color =>\n Color.fromValue(const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 4, 2));\n\n @override\n String toString() {\n return 'TestSimpleTableWithEnum{color: ${color}}';\n }\n\n TestSimpleTableWithEnumT unpack() => TestSimpleTableWithEnumT(color: color);\n\n static int pack(fb.Builder fbBuilder, TestSimpleTableWithEnumT? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass TestSimpleTableWithEnumT implements fb.Packable {\n Color color;\n\n TestSimpleTableWithEnumT({this.color = Color.Green});\n\n @override\n int pack(fb.Builder fbBuilder) {\n fbBuilder.startTable(1);\n fbBuilder.addUint8(0, color.value);\n return fbBuilder.endTable();\n }\n\n @override\n String toString() {\n return 'TestSimpleTableWithEnumT{color: ${color}}';\n }\n}\n\nclass _TestSimpleTableWithEnumReader\n extends fb.TableReader {\n const _TestSimpleTableWithEnumReader();\n\n @override\n TestSimpleTableWithEnum createObject(fb.BufferContext bc, int offset) =>\n TestSimpleTableWithEnum._(bc, offset);\n}\n\nclass TestSimpleTableWithEnumBuilder {\n TestSimpleTableWithEnumBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n void begin() {\n fbBuilder.startTable(1);\n }\n\n int addColor(Color? color) {\n fbBuilder.addUint8(0, color?.value);\n return fbBuilder.offset;\n }\n\n int finish() {\n return fbBuilder.endTable();\n }\n}\n\nclass TestSimpleTableWithEnumObjectBuilder extends fb.ObjectBuilder {\n final Color? _color;\n\n TestSimpleTableWithEnumObjectBuilder({Color? color}) : _color = color;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n fbBuilder.startTable(1);\n fbBuilder.addUint8(0, _color?.value);\n return fbBuilder.endTable();\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n\nclass Vec3 {\n Vec3._(this._bc, this._bcOffset);\n\n static const fb.Reader reader = _Vec3Reader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n double get x => const fb.Float32Reader().read(_bc, _bcOffset + 0);\n double get y => const fb.Float32Reader().read(_bc, _bcOffset + 4);\n double get z => const fb.Float32Reader().read(_bc, _bcOffset + 8);\n double get test1 => const fb.Float64Reader().read(_bc, _bcOffset + 16);\n Color get test2 =>\n Color.fromValue(const fb.Uint8Reader().read(_bc, _bcOffset + 24));\n Test get test3 => Test.reader.read(_bc, _bcOffset + 26);\n\n @override\n String toString() {\n return 'Vec3{x: ${x}, y: ${y}, z: ${z}, test1: ${test1}, test2: ${test2}, test3: ${test3}}';\n }\n\n Vec3T unpack() => Vec3T(\n x: x,\n y: y,\n z: z,\n test1: test1,\n test2: test2,\n test3: test3.unpack(),\n );\n\n static int pack(fb.Builder fbBuilder, Vec3T? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass Vec3T implements fb.Packable {\n double x;\n double y;\n double z;\n double test1;\n Color test2;\n TestT test3;\n\n Vec3T({\n required this.x,\n required this.y,\n required this.z,\n required this.test1,\n required this.test2,\n required this.test3,\n });\n\n @override\n int pack(fb.Builder fbBuilder) {\n fbBuilder.pad(2);\n test3.pack(fbBuilder);\n fbBuilder.pad(1);\n fbBuilder.putUint8(test2.value);\n fbBuilder.putFloat64(test1);\n fbBuilder.pad(4);\n fbBuilder.putFloat32(z);\n fbBuilder.putFloat32(y);\n fbBuilder.putFloat32(x);\n return fbBuilder.offset;\n }\n\n @override\n String toString() {\n return 'Vec3T{x: ${x}, y: ${y}, z: ${z}, test1: ${test1}, test2: ${test2}, test3: ${test3}}';\n }\n}\n\nclass _Vec3Reader extends fb.StructReader {\n const _Vec3Reader();\n\n @override\n int get size => 32;\n\n @override\n Vec3 createObject(fb.BufferContext bc, int offset) => Vec3._(bc, offset);\n}\n\nclass Vec3Builder {\n Vec3Builder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n int finish(\n double x,\n double y,\n double z,\n double test1,\n Color test2,\n fb.StructBuilder test3,\n ) {\n fbBuilder.pad(2);\n test3();\n fbBuilder.pad(1);\n fbBuilder.putUint8(test2.value);\n fbBuilder.putFloat64(test1);\n fbBuilder.pad(4);\n fbBuilder.putFloat32(z);\n fbBuilder.putFloat32(y);\n fbBuilder.putFloat32(x);\n return fbBuilder.offset;\n }\n}\n\nclass Vec3ObjectBuilder extends fb.ObjectBuilder {\n final double _x;\n final double _y;\n final double _z;\n final double _test1;\n final Color _test2;\n final TestObjectBuilder _test3;\n\n Vec3ObjectBuilder({\n required double x,\n required double y,\n required double z,\n required double test1,\n required Color test2,\n required TestObjectBuilder test3,\n }) : _x = x,\n _y = y,\n _z = z,\n _test1 = test1,\n _test2 = test2,\n _test3 = test3;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n fbBuilder.pad(2);\n _test3.finish(fbBuilder);\n fbBuilder.pad(1);\n fbBuilder.putUint8(_test2.value);\n fbBuilder.putFloat64(_test1);\n fbBuilder.pad(4);\n fbBuilder.putFloat32(_z);\n fbBuilder.putFloat32(_y);\n fbBuilder.putFloat32(_x);\n return fbBuilder.offset;\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n\nclass Ability {\n Ability._(this._bc, this._bcOffset);\n\n static const fb.Reader reader = _AbilityReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n int get id => const fb.Uint32Reader().read(_bc, _bcOffset + 0);\n int get distance => const fb.Uint32Reader().read(_bc, _bcOffset + 4);\n\n @override\n String toString() {\n return 'Ability{id: ${id}, distance: ${distance}}';\n }\n\n AbilityT unpack() => AbilityT(id: id, distance: distance);\n\n static int pack(fb.Builder fbBuilder, AbilityT? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass AbilityT implements fb.Packable {\n int id;\n int distance;\n\n AbilityT({required this.id, required this.distance});\n\n @override\n int pack(fb.Builder fbBuilder) {\n fbBuilder.putUint32(distance);\n fbBuilder.putUint32(id);\n return fbBuilder.offset;\n }\n\n @override\n String toString() {\n return 'AbilityT{id: ${id}, distance: ${distance}}';\n }\n}\n\nclass _AbilityReader extends fb.StructReader {\n const _AbilityReader();\n\n @override\n int get size => 8;\n\n @override\n Ability createObject(fb.BufferContext bc, int offset) =>\n Ability._(bc, offset);\n}\n\nclass AbilityBuilder {\n AbilityBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n int finish(int id, int distance) {\n fbBuilder.putUint32(distance);\n fbBuilder.putUint32(id);\n return fbBuilder.offset;\n }\n}\n\nclass AbilityObjectBuilder extends fb.ObjectBuilder {\n final int _id;\n final int _distance;\n\n AbilityObjectBuilder({required int id, required int distance})\n : _id = id,\n _distance = distance;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n fbBuilder.putUint32(_distance);\n fbBuilder.putUint32(_id);\n return fbBuilder.offset;\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n\nclass StructOfStructs {\n StructOfStructs._(this._bc, this._bcOffset);\n\n static const fb.Reader reader = _StructOfStructsReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n Ability get a => Ability.reader.read(_bc, _bcOffset + 0);\n Test get b => Test.reader.read(_bc, _bcOffset + 8);\n Ability get c => Ability.reader.read(_bc, _bcOffset + 12);\n\n @override\n String toString() {\n return 'StructOfStructs{a: ${a}, b: ${b}, c: ${c}}';\n }\n\n StructOfStructsT unpack() =>\n StructOfStructsT(a: a.unpack(), b: b.unpack(), c: c.unpack());\n\n static int pack(fb.Builder fbBuilder, StructOfStructsT? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass StructOfStructsT implements fb.Packable {\n AbilityT a;\n TestT b;\n AbilityT c;\n\n StructOfStructsT({required this.a, required this.b, required this.c});\n\n @override\n int pack(fb.Builder fbBuilder) {\n c.pack(fbBuilder);\n b.pack(fbBuilder);\n a.pack(fbBuilder);\n return fbBuilder.offset;\n }\n\n @override\n String toString() {\n return 'StructOfStructsT{a: ${a}, b: ${b}, c: ${c}}';\n }\n}\n\nclass _StructOfStructsReader extends fb.StructReader {\n const _StructOfStructsReader();\n\n @override\n int get size => 20;\n\n @override\n StructOfStructs createObject(fb.BufferContext bc, int offset) =>\n StructOfStructs._(bc, offset);\n}\n\nclass StructOfStructsBuilder {\n StructOfStructsBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n int finish(fb.StructBuilder a, fb.StructBuilder b, fb.StructBuilder c) {\n c();\n b();\n a();\n return fbBuilder.offset;\n }\n}\n\nclass StructOfStructsObjectBuilder extends fb.ObjectBuilder {\n final AbilityObjectBuilder _a;\n final TestObjectBuilder _b;\n final AbilityObjectBuilder _c;\n\n StructOfStructsObjectBuilder({\n required AbilityObjectBuilder a,\n required TestObjectBuilder b,\n required AbilityObjectBuilder c,\n }) : _a = a,\n _b = b,\n _c = c;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n _c.finish(fbBuilder);\n _b.finish(fbBuilder);\n _a.finish(fbBuilder);\n return fbBuilder.offset;\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n\nclass StructOfStructsOfStructs {\n StructOfStructsOfStructs._(this._bc, this._bcOffset);\n\n static const fb.Reader reader =\n _StructOfStructsOfStructsReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n StructOfStructs get a => StructOfStructs.reader.read(_bc, _bcOffset + 0);\n\n @override\n String toString() {\n return 'StructOfStructsOfStructs{a: ${a}}';\n }\n\n StructOfStructsOfStructsT unpack() =>\n StructOfStructsOfStructsT(a: a.unpack());\n\n static int pack(fb.Builder fbBuilder, StructOfStructsOfStructsT? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass StructOfStructsOfStructsT implements fb.Packable {\n StructOfStructsT a;\n\n StructOfStructsOfStructsT({required this.a});\n\n @override\n int pack(fb.Builder fbBuilder) {\n a.pack(fbBuilder);\n return fbBuilder.offset;\n }\n\n @override\n String toString() {\n return 'StructOfStructsOfStructsT{a: ${a}}';\n }\n}\n\nclass _StructOfStructsOfStructsReader\n extends fb.StructReader {\n const _StructOfStructsOfStructsReader();\n\n @override\n int get size => 20;\n\n @override\n StructOfStructsOfStructs createObject(fb.BufferContext bc, int offset) =>\n StructOfStructsOfStructs._(bc, offset);\n}\n\nclass StructOfStructsOfStructsBuilder {\n StructOfStructsOfStructsBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n int finish(fb.StructBuilder a) {\n a();\n return fbBuilder.offset;\n }\n}\n\nclass StructOfStructsOfStructsObjectBuilder extends fb.ObjectBuilder {\n final StructOfStructsObjectBuilder _a;\n\n StructOfStructsOfStructsObjectBuilder({\n required StructOfStructsObjectBuilder a,\n }) : _a = a;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n _a.finish(fbBuilder);\n return fbBuilder.offset;\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n\nclass Stat {\n Stat._(this._bc, this._bcOffset);\n factory Stat(List bytes) {\n final rootRef = fb.BufferContext.fromBytes(bytes);\n return reader.read(rootRef, 0);\n }\n\n static const fb.Reader reader = _StatReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n String? get id =>\n const fb.StringReader().vTableGetNullable(_bc, _bcOffset, 4);\n int get val => const fb.Int64Reader().vTableGet(_bc, _bcOffset, 6, 0);\n int get count => const fb.Uint16Reader().vTableGet(_bc, _bcOffset, 8, 0);\n\n @override\n String toString() {\n return 'Stat{id: ${id}, val: ${val}, count: ${count}}';\n }\n\n StatT unpack() => StatT(id: id, val: val, count: count);\n\n static int pack(fb.Builder fbBuilder, StatT? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass StatT implements fb.Packable {\n String? id;\n int val;\n int count;\n\n StatT({this.id, this.val = 0, this.count = 0});\n\n @override\n int pack(fb.Builder fbBuilder) {\n final int? idOffset = id == null ? null : fbBuilder.writeString(id!);\n fbBuilder.startTable(3);\n fbBuilder.addOffset(0, idOffset);\n fbBuilder.addInt64(1, val);\n fbBuilder.addUint16(2, count);\n return fbBuilder.endTable();\n }\n\n @override\n String toString() {\n return 'StatT{id: ${id}, val: ${val}, count: ${count}}';\n }\n}\n\nclass _StatReader extends fb.TableReader {\n const _StatReader();\n\n @override\n Stat createObject(fb.BufferContext bc, int offset) => Stat._(bc, offset);\n}\n\nclass StatBuilder {\n StatBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n void begin() {\n fbBuilder.startTable(3);\n }\n\n int addIdOffset(int? offset) {\n fbBuilder.addOffset(0, offset);\n return fbBuilder.offset;\n }\n\n int addVal(int? val) {\n fbBuilder.addInt64(1, val);\n return fbBuilder.offset;\n }\n\n int addCount(int? count) {\n fbBuilder.addUint16(2, count);\n return fbBuilder.offset;\n }\n\n int finish() {\n return fbBuilder.endTable();\n }\n}\n\nclass StatObjectBuilder extends fb.ObjectBuilder {\n final String? _id;\n final int? _val;\n final int? _count;\n\n StatObjectBuilder({String? id, int? val, int? count})\n : _id = id,\n _val = val,\n _count = count;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n final int? idOffset = _id == null ? null : fbBuilder.writeString(_id!);\n fbBuilder.startTable(3);\n fbBuilder.addOffset(0, idOffset);\n fbBuilder.addInt64(1, _val);\n fbBuilder.addUint16(2, _count);\n return fbBuilder.endTable();\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n\nclass Referrable {\n Referrable._(this._bc, this._bcOffset);\n factory Referrable(List bytes) {\n final rootRef = fb.BufferContext.fromBytes(bytes);\n return reader.read(rootRef, 0);\n }\n\n static const fb.Reader reader = _ReferrableReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n int get id => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 4, 0);\n\n @override\n String toString() {\n return 'Referrable{id: ${id}}';\n }\n\n ReferrableT unpack() => ReferrableT(id: id);\n\n static int pack(fb.Builder fbBuilder, ReferrableT? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass ReferrableT implements fb.Packable {\n int id;\n\n ReferrableT({this.id = 0});\n\n @override\n int pack(fb.Builder fbBuilder) {\n fbBuilder.startTable(1);\n fbBuilder.addUint64(0, id);\n return fbBuilder.endTable();\n }\n\n @override\n String toString() {\n return 'ReferrableT{id: ${id}}';\n }\n}\n\nclass _ReferrableReader extends fb.TableReader {\n const _ReferrableReader();\n\n @override\n Referrable createObject(fb.BufferContext bc, int offset) =>\n Referrable._(bc, offset);\n}\n\nclass ReferrableBuilder {\n ReferrableBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n void begin() {\n fbBuilder.startTable(1);\n }\n\n int addId(int? id) {\n fbBuilder.addUint64(0, id);\n return fbBuilder.offset;\n }\n\n int finish() {\n return fbBuilder.endTable();\n }\n}\n\nclass ReferrableObjectBuilder extends fb.ObjectBuilder {\n final int? _id;\n\n ReferrableObjectBuilder({int? id}) : _id = id;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n fbBuilder.startTable(1);\n fbBuilder.addUint64(0, _id);\n return fbBuilder.endTable();\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n\n/// an example documentation comment: \"monster object\"\nclass Monster {\n Monster._(this._bc, this._bcOffset);\n factory Monster(List bytes) {\n final rootRef = fb.BufferContext.fromBytes(bytes);\n return reader.read(rootRef, 0);\n }\n\n static const fb.Reader reader = _MonsterReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n Vec3? get pos => Vec3.reader.vTableGetNullable(_bc, _bcOffset, 4);\n int get mana => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 6, 150);\n int get hp => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 8, 100);\n String? get name =>\n const fb.StringReader().vTableGetNullable(_bc, _bcOffset, 10);\n List? get inventory =>\n const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 14);\n Color get color =>\n Color.fromValue(const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 16, 8));\n AnyTypeId? get testType => AnyTypeId._createOrNull(\n const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 18),\n );\n dynamic get test {\n switch (testType?.value) {\n case 1:\n return Monster.reader.vTableGetNullable(_bc, _bcOffset, 20);\n case 2:\n return TestSimpleTableWithEnum.reader.vTableGetNullable(\n _bc,\n _bcOffset,\n 20,\n );\n case 3:\n return my_game_example2.Monster.reader.vTableGetNullable(\n _bc,\n _bcOffset,\n 20,\n );\n default:\n return null;\n }\n }\n\n List? get test4 => const fb.ListReader(\n Test.reader,\n ).vTableGetNullable(_bc, _bcOffset, 22);\n List? get testarrayofstring => const fb.ListReader(\n fb.StringReader(),\n ).vTableGetNullable(_bc, _bcOffset, 24);\n\n /// an example documentation comment: this will end up in the generated code\n /// multiline too\n List? get testarrayoftables => const fb.ListReader(\n Monster.reader,\n ).vTableGetNullable(_bc, _bcOffset, 26);\n Monster? get enemy => Monster.reader.vTableGetNullable(_bc, _bcOffset, 28);\n List? get testnestedflatbuffer =>\n const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 30);\n Stat? get testempty => Stat.reader.vTableGetNullable(_bc, _bcOffset, 32);\n bool get testbool =>\n const fb.BoolReader().vTableGet(_bc, _bcOffset, 34, false);\n int get testhashs32Fnv1 =>\n const fb.Int32Reader().vTableGet(_bc, _bcOffset, 36, 0);\n int get testhashu32Fnv1 =>\n const fb.Uint32Reader().vTableGet(_bc, _bcOffset, 38, 0);\n int get testhashs64Fnv1 =>\n const fb.Int64Reader().vTableGet(_bc, _bcOffset, 40, 0);\n int get testhashu64Fnv1 =>\n const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 42, 0);\n int get testhashs32Fnv1a =>\n const fb.Int32Reader().vTableGet(_bc, _bcOffset, 44, 0);\n int get testhashu32Fnv1a =>\n const fb.Uint32Reader().vTableGet(_bc, _bcOffset, 46, 0);\n int get testhashs64Fnv1a =>\n const fb.Int64Reader().vTableGet(_bc, _bcOffset, 48, 0);\n int get testhashu64Fnv1a =>\n const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 50, 0);\n List? get testarrayofbools => const fb.ListReader(\n fb.BoolReader(),\n ).vTableGetNullable(_bc, _bcOffset, 52);\n double get testf =>\n const fb.Float32Reader().vTableGet(_bc, _bcOffset, 54, 3.14159);\n double get testf2 =>\n const fb.Float32Reader().vTableGet(_bc, _bcOffset, 56, 3.0);\n double get testf3 =>\n const fb.Float32Reader().vTableGet(_bc, _bcOffset, 58, 0.0);\n List? get testarrayofstring2 => const fb.ListReader(\n fb.StringReader(),\n ).vTableGetNullable(_bc, _bcOffset, 60);\n List? get testarrayofsortedstruct => const fb.ListReader(\n Ability.reader,\n ).vTableGetNullable(_bc, _bcOffset, 62);\n List? get flex =>\n const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 64);\n List? get test5 => const fb.ListReader(\n Test.reader,\n ).vTableGetNullable(_bc, _bcOffset, 66);\n List? get vectorOfLongs => const fb.ListReader(\n fb.Int64Reader(),\n ).vTableGetNullable(_bc, _bcOffset, 68);\n List? get vectorOfDoubles => const fb.ListReader(\n fb.Float64Reader(),\n ).vTableGetNullable(_bc, _bcOffset, 70);\n my_game.InParentNamespace? get parentNamespaceTest =>\n my_game.InParentNamespace.reader.vTableGetNullable(_bc, _bcOffset, 72);\n List? get vectorOfReferrables => const fb.ListReader(\n Referrable.reader,\n ).vTableGetNullable(_bc, _bcOffset, 74);\n int get singleWeakReference =>\n const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 76, 0);\n List? get vectorOfWeakReferences => const fb.ListReader(\n fb.Uint64Reader(),\n ).vTableGetNullable(_bc, _bcOffset, 78);\n List? get vectorOfStrongReferrables =>\n const fb.ListReader(\n Referrable.reader,\n ).vTableGetNullable(_bc, _bcOffset, 80);\n int get coOwningReference =>\n const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 82, 0);\n List? get vectorOfCoOwningReferences => const fb.ListReader(\n fb.Uint64Reader(),\n ).vTableGetNullable(_bc, _bcOffset, 84);\n int get nonOwningReference =>\n const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 86, 0);\n List? get vectorOfNonOwningReferences => const fb.ListReader(\n fb.Uint64Reader(),\n ).vTableGetNullable(_bc, _bcOffset, 88);\n AnyUniqueAliasesTypeId? get anyUniqueType =>\n AnyUniqueAliasesTypeId._createOrNull(\n const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 90),\n );\n dynamic get anyUnique {\n switch (anyUniqueType?.value) {\n case 1:\n return Monster.reader.vTableGetNullable(_bc, _bcOffset, 92);\n case 2:\n return TestSimpleTableWithEnum.reader.vTableGetNullable(\n _bc,\n _bcOffset,\n 92,\n );\n case 3:\n return my_game_example2.Monster.reader.vTableGetNullable(\n _bc,\n _bcOffset,\n 92,\n );\n default:\n return null;\n }\n }\n\n AnyAmbiguousAliasesTypeId? get anyAmbiguousType =>\n AnyAmbiguousAliasesTypeId._createOrNull(\n const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 94),\n );\n dynamic get anyAmbiguous {\n switch (anyAmbiguousType?.value) {\n case 1:\n return Monster.reader.vTableGetNullable(_bc, _bcOffset, 96);\n case 2:\n return Monster.reader.vTableGetNullable(_bc, _bcOffset, 96);\n case 3:\n return Monster.reader.vTableGetNullable(_bc, _bcOffset, 96);\n default:\n return null;\n }\n }\n\n List? get vectorOfEnums => const fb.ListReader(\n Color.reader,\n ).vTableGetNullable(_bc, _bcOffset, 98);\n Race get signedEnum =>\n Race.fromValue(const fb.Int8Reader().vTableGet(_bc, _bcOffset, 100, -1));\n List? get testrequirednestedflatbuffer =>\n const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 102);\n List? get scalarKeySortedTables => const fb.ListReader(\n Stat.reader,\n ).vTableGetNullable(_bc, _bcOffset, 104);\n Test? get nativeInline => Test.reader.vTableGetNullable(_bc, _bcOffset, 106);\n LongEnum get longEnumNonEnumDefault => LongEnum.fromValue(\n const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 108, 0),\n );\n LongEnum get longEnumNormalDefault => LongEnum.fromValue(\n const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 110, 2),\n );\n double get nanDefault =>\n const fb.Float32Reader().vTableGet(_bc, _bcOffset, 112, double.nan);\n double get infDefault =>\n const fb.Float32Reader().vTableGet(_bc, _bcOffset, 114, double.infinity);\n double get positiveInfDefault =>\n const fb.Float32Reader().vTableGet(_bc, _bcOffset, 116, double.infinity);\n double get infinityDefault =>\n const fb.Float32Reader().vTableGet(_bc, _bcOffset, 118, double.infinity);\n double get positiveInfinityDefault =>\n const fb.Float32Reader().vTableGet(_bc, _bcOffset, 120, double.infinity);\n double get negativeInfDefault => const fb.Float32Reader().vTableGet(\n _bc,\n _bcOffset,\n 122,\n double.negativeInfinity,\n );\n double get negativeInfinityDefault => const fb.Float32Reader().vTableGet(\n _bc,\n _bcOffset,\n 124,\n double.negativeInfinity,\n );\n double get doubleInfDefault =>\n const fb.Float64Reader().vTableGet(_bc, _bcOffset, 126, double.infinity);\n\n @override\n String toString() {\n 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}, nativeInline: ${nativeInline}, longEnumNonEnumDefault: ${longEnumNonEnumDefault}, longEnumNormalDefault: ${longEnumNormalDefault}, nanDefault: ${nanDefault}, infDefault: ${infDefault}, positiveInfDefault: ${positiveInfDefault}, infinityDefault: ${infinityDefault}, positiveInfinityDefault: ${positiveInfinityDefault}, negativeInfDefault: ${negativeInfDefault}, negativeInfinityDefault: ${negativeInfinityDefault}, doubleInfDefault: ${doubleInfDefault}}';\n }\n\n MonsterT unpack() => MonsterT(\n pos: pos?.unpack(),\n mana: mana,\n hp: hp,\n name: name,\n inventory: inventory?.toList(),\n color: color,\n testType: testType,\n test: test?.unpack(),\n test4: test4?.map((e) => e.unpack()).toList(),\n testarrayofstring: testarrayofstring?.toList(),\n testarrayoftables: testarrayoftables?.map((e) => e.unpack()).toList(),\n enemy: enemy?.unpack(),\n testnestedflatbuffer: testnestedflatbuffer?.toList(),\n testempty: testempty?.unpack(),\n testbool: testbool,\n testhashs32Fnv1: testhashs32Fnv1,\n testhashu32Fnv1: testhashu32Fnv1,\n testhashs64Fnv1: testhashs64Fnv1,\n testhashu64Fnv1: testhashu64Fnv1,\n testhashs32Fnv1a: testhashs32Fnv1a,\n testhashu32Fnv1a: testhashu32Fnv1a,\n testhashs64Fnv1a: testhashs64Fnv1a,\n testhashu64Fnv1a: testhashu64Fnv1a,\n testarrayofbools: testarrayofbools?.toList(),\n testf: testf,\n testf2: testf2,\n testf3: testf3,\n testarrayofstring2: testarrayofstring2?.toList(),\n testarrayofsortedstruct: testarrayofsortedstruct?.map((e) => e.unpack()).toList(),\n flex: flex?.toList(),\n test5: test5?.map((e) => e.unpack()).toList(),\n vectorOfLongs: vectorOfLongs?.toList(),\n vectorOfDoubles: vectorOfDoubles?.toList(),\n parentNamespaceTest: parentNamespaceTest?.unpack(),\n vectorOfReferrables: vectorOfReferrables?.map((e) => e.unpack()).toList(),\n singleWeakReference: singleWeakReference,\n vectorOfWeakReferences: vectorOfWeakReferences?.toList(),\n vectorOfStrongReferrables: vectorOfStrongReferrables?.map((e) => e.unpack()).toList(),\n coOwningReference: coOwningReference,\n vectorOfCoOwningReferences: vectorOfCoOwningReferences?.toList(),\n nonOwningReference: nonOwningReference,\n vectorOfNonOwningReferences: vectorOfNonOwningReferences?.toList(),\n anyUniqueType: anyUniqueType,\n anyUnique: anyUnique?.unpack(),\n anyAmbiguousType: anyAmbiguousType,\n anyAmbiguous: anyAmbiguous?.unpack(),\n vectorOfEnums: vectorOfEnums?.toList(),\n signedEnum: signedEnum,\n testrequirednestedflatbuffer: testrequirednestedflatbuffer?.toList(),\n scalarKeySortedTables: scalarKeySortedTables?.map((e) => e.unpack()).toList(),\n nativeInline: nativeInline?.unpack(),\n longEnumNonEnumDefault: longEnumNonEnumDefault,\n longEnumNormalDefault: longEnumNormalDefault,\n nanDefault: nanDefault,\n infDefault: infDefault,\n positiveInfDefault: positiveInfDefault,\n infinityDefault: infinityDefault,\n positiveInfinityDefault: positiveInfinityDefault,\n negativeInfDefault: negativeInfDefault,\n negativeInfinityDefault: negativeInfinityDefault,\n doubleInfDefault: doubleInfDefault,\n );\n\n static int pack(fb.Builder fbBuilder, MonsterT? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\n/// an example documentation comment: \"monster object\"\nclass MonsterT implements fb.Packable {\n Vec3T? pos;\n int mana;\n int hp;\n String? name;\n List? inventory;\n Color color;\n AnyTypeId? testType;\n dynamic test;\n List? test4;\n List? testarrayofstring;\n\n /// an example documentation comment: this will end up in the generated code\n /// multiline too\n List? testarrayoftables;\n MonsterT? enemy;\n List? testnestedflatbuffer;\n StatT? testempty;\n bool testbool;\n int testhashs32Fnv1;\n int testhashu32Fnv1;\n int testhashs64Fnv1;\n int testhashu64Fnv1;\n int testhashs32Fnv1a;\n int testhashu32Fnv1a;\n int testhashs64Fnv1a;\n int testhashu64Fnv1a;\n List? testarrayofbools;\n double testf;\n double testf2;\n double testf3;\n List? testarrayofstring2;\n List? testarrayofsortedstruct;\n List? flex;\n List? test5;\n List? vectorOfLongs;\n List? vectorOfDoubles;\n my_game.InParentNamespaceT? parentNamespaceTest;\n List? vectorOfReferrables;\n int singleWeakReference;\n List? vectorOfWeakReferences;\n List? vectorOfStrongReferrables;\n int coOwningReference;\n List? vectorOfCoOwningReferences;\n int nonOwningReference;\n List? vectorOfNonOwningReferences;\n AnyUniqueAliasesTypeId? anyUniqueType;\n dynamic anyUnique;\n AnyAmbiguousAliasesTypeId? anyAmbiguousType;\n dynamic anyAmbiguous;\n List? vectorOfEnums;\n Race signedEnum;\n List? testrequirednestedflatbuffer;\n List? scalarKeySortedTables;\n TestT? nativeInline;\n LongEnum longEnumNonEnumDefault;\n LongEnum longEnumNormalDefault;\n double nanDefault;\n double infDefault;\n double positiveInfDefault;\n double infinityDefault;\n double positiveInfinityDefault;\n double negativeInfDefault;\n double negativeInfinityDefault;\n double doubleInfDefault;\n\n MonsterT({\n this.pos,\n this.mana = 150,\n this.hp = 100,\n this.name,\n this.inventory,\n this.color = Color.Blue,\n this.testType,\n this.test,\n this.test4,\n this.testarrayofstring,\n this.testarrayoftables,\n this.enemy,\n this.testnestedflatbuffer,\n this.testempty,\n this.testbool = false,\n this.testhashs32Fnv1 = 0,\n this.testhashu32Fnv1 = 0,\n this.testhashs64Fnv1 = 0,\n this.testhashu64Fnv1 = 0,\n this.testhashs32Fnv1a = 0,\n this.testhashu32Fnv1a = 0,\n this.testhashs64Fnv1a = 0,\n this.testhashu64Fnv1a = 0,\n this.testarrayofbools,\n this.testf = 3.14159,\n this.testf2 = 3.0,\n this.testf3 = 0.0,\n this.testarrayofstring2,\n this.testarrayofsortedstruct,\n this.flex,\n this.test5,\n this.vectorOfLongs,\n this.vectorOfDoubles,\n this.parentNamespaceTest,\n this.vectorOfReferrables,\n this.singleWeakReference = 0,\n this.vectorOfWeakReferences,\n this.vectorOfStrongReferrables,\n this.coOwningReference = 0,\n this.vectorOfCoOwningReferences,\n this.nonOwningReference = 0,\n this.vectorOfNonOwningReferences,\n this.anyUniqueType,\n this.anyUnique,\n this.anyAmbiguousType,\n this.anyAmbiguous,\n this.vectorOfEnums,\n this.signedEnum = Race.None,\n this.testrequirednestedflatbuffer,\n this.scalarKeySortedTables,\n this.nativeInline,\n this.longEnumNonEnumDefault = LongEnum._default,\n this.longEnumNormalDefault = LongEnum.LongOne,\n this.nanDefault = double.nan,\n this.infDefault = double.infinity,\n this.positiveInfDefault = double.infinity,\n this.infinityDefault = double.infinity,\n this.positiveInfinityDefault = double.infinity,\n this.negativeInfDefault = double.negativeInfinity,\n this.negativeInfinityDefault = double.negativeInfinity,\n this.doubleInfDefault = double.infinity,\n });\n\n @override\n int pack(fb.Builder fbBuilder) {\n final int? nameOffset = name == null ? null : fbBuilder.writeString(name!);\n final int? inventoryOffset = inventory == null\n ? null\n : fbBuilder.writeListUint8(inventory!);\n final int? testOffset = test?.pack(fbBuilder);\n int? test4Offset;\n if (test4 != null) {\n for (var e in test4!.reversed) {\n e.pack(fbBuilder);\n }\n test4Offset = fbBuilder.endStructVector(test4!.length);\n }\n final int? testarrayofstringOffset = testarrayofstring == null\n ? null\n : fbBuilder.writeList(\n testarrayofstring!.map(fbBuilder.writeString).toList(),\n );\n final int? testarrayoftablesOffset = testarrayoftables == null\n ? null\n : fbBuilder.writeList(\n testarrayoftables!.map((b) => b.pack(fbBuilder)).toList(),\n );\n final int? enemyOffset = enemy?.pack(fbBuilder);\n final int? testnestedflatbufferOffset = testnestedflatbuffer == null\n ? null\n : fbBuilder.writeListUint8(testnestedflatbuffer!);\n final int? testemptyOffset = testempty?.pack(fbBuilder);\n final int? testarrayofboolsOffset = testarrayofbools == null\n ? null\n : fbBuilder.writeListBool(testarrayofbools!);\n final int? testarrayofstring2Offset = testarrayofstring2 == null\n ? null\n : fbBuilder.writeList(\n testarrayofstring2!.map(fbBuilder.writeString).toList(),\n );\n int? testarrayofsortedstructOffset;\n if (testarrayofsortedstruct != null) {\n for (var e in testarrayofsortedstruct!.reversed) {\n e.pack(fbBuilder);\n }\n testarrayofsortedstructOffset = fbBuilder.endStructVector(\n testarrayofsortedstruct!.length,\n );\n }\n final int? flexOffset = flex == null\n ? null\n : fbBuilder.writeListUint8(flex!);\n int? test5Offset;\n if (test5 != null) {\n for (var e in test5!.reversed) {\n e.pack(fbBuilder);\n }\n test5Offset = fbBuilder.endStructVector(test5!.length);\n }\n final int? vectorOfLongsOffset = vectorOfLongs == null\n ? null\n : fbBuilder.writeListInt64(vectorOfLongs!);\n final int? vectorOfDoublesOffset = vectorOfDoubles == null\n ? null\n : fbBuilder.writeListFloat64(vectorOfDoubles!);\n final int? parentNamespaceTestOffset = parentNamespaceTest?.pack(fbBuilder);\n final int? vectorOfReferrablesOffset = vectorOfReferrables == null\n ? null\n : fbBuilder.writeList(\n vectorOfReferrables!.map((b) => b.pack(fbBuilder)).toList(),\n );\n final int? vectorOfWeakReferencesOffset = vectorOfWeakReferences == null\n ? null\n : fbBuilder.writeListUint64(vectorOfWeakReferences!);\n final int? vectorOfStrongReferrablesOffset =\n vectorOfStrongReferrables == null\n ? null\n : fbBuilder.writeList(\n vectorOfStrongReferrables!.map((b) => b.pack(fbBuilder)).toList(),\n );\n final int? vectorOfCoOwningReferencesOffset =\n vectorOfCoOwningReferences == null\n ? null\n : fbBuilder.writeListUint64(vectorOfCoOwningReferences!);\n final int? vectorOfNonOwningReferencesOffset =\n vectorOfNonOwningReferences == null\n ? null\n : fbBuilder.writeListUint64(vectorOfNonOwningReferences!);\n final int? anyUniqueOffset = anyUnique?.pack(fbBuilder);\n final int? anyAmbiguousOffset = anyAmbiguous?.pack(fbBuilder);\n final int? vectorOfEnumsOffset = vectorOfEnums == null\n ? null\n : fbBuilder.writeListUint8(vectorOfEnums!.map((f) => f.value).toList());\n final int? testrequirednestedflatbufferOffset =\n testrequirednestedflatbuffer == null\n ? null\n : fbBuilder.writeListUint8(testrequirednestedflatbuffer!);\n final int? scalarKeySortedTablesOffset = scalarKeySortedTables == null\n ? null\n : fbBuilder.writeList(\n scalarKeySortedTables!.map((b) => b.pack(fbBuilder)).toList(),\n );\n fbBuilder.startTable(62);\n if (pos != null) {\n fbBuilder.addStruct(0, pos!.pack(fbBuilder));\n }\n fbBuilder.addInt16(1, mana);\n fbBuilder.addInt16(2, hp);\n fbBuilder.addOffset(3, nameOffset);\n fbBuilder.addOffset(5, inventoryOffset);\n fbBuilder.addUint8(6, color.value);\n fbBuilder.addUint8(7, testType?.value);\n fbBuilder.addOffset(8, testOffset);\n fbBuilder.addOffset(9, test4Offset);\n fbBuilder.addOffset(10, testarrayofstringOffset);\n fbBuilder.addOffset(11, testarrayoftablesOffset);\n fbBuilder.addOffset(12, enemyOffset);\n fbBuilder.addOffset(13, testnestedflatbufferOffset);\n fbBuilder.addOffset(14, testemptyOffset);\n fbBuilder.addBool(15, testbool);\n fbBuilder.addInt32(16, testhashs32Fnv1);\n fbBuilder.addUint32(17, testhashu32Fnv1);\n fbBuilder.addInt64(18, testhashs64Fnv1);\n fbBuilder.addUint64(19, testhashu64Fnv1);\n fbBuilder.addInt32(20, testhashs32Fnv1a);\n fbBuilder.addUint32(21, testhashu32Fnv1a);\n fbBuilder.addInt64(22, testhashs64Fnv1a);\n fbBuilder.addUint64(23, testhashu64Fnv1a);\n fbBuilder.addOffset(24, testarrayofboolsOffset);\n fbBuilder.addFloat32(25, testf);\n fbBuilder.addFloat32(26, testf2);\n fbBuilder.addFloat32(27, testf3);\n fbBuilder.addOffset(28, testarrayofstring2Offset);\n fbBuilder.addOffset(29, testarrayofsortedstructOffset);\n fbBuilder.addOffset(30, flexOffset);\n fbBuilder.addOffset(31, test5Offset);\n fbBuilder.addOffset(32, vectorOfLongsOffset);\n fbBuilder.addOffset(33, vectorOfDoublesOffset);\n fbBuilder.addOffset(34, parentNamespaceTestOffset);\n fbBuilder.addOffset(35, vectorOfReferrablesOffset);\n fbBuilder.addUint64(36, singleWeakReference);\n fbBuilder.addOffset(37, vectorOfWeakReferencesOffset);\n fbBuilder.addOffset(38, vectorOfStrongReferrablesOffset);\n fbBuilder.addUint64(39, coOwningReference);\n fbBuilder.addOffset(40, vectorOfCoOwningReferencesOffset);\n fbBuilder.addUint64(41, nonOwningReference);\n fbBuilder.addOffset(42, vectorOfNonOwningReferencesOffset);\n fbBuilder.addUint8(43, anyUniqueType?.value);\n fbBuilder.addOffset(44, anyUniqueOffset);\n fbBuilder.addUint8(45, anyAmbiguousType?.value);\n fbBuilder.addOffset(46, anyAmbiguousOffset);\n fbBuilder.addOffset(47, vectorOfEnumsOffset);\n fbBuilder.addInt8(48, signedEnum.value);\n fbBuilder.addOffset(49, testrequirednestedflatbufferOffset);\n fbBuilder.addOffset(50, scalarKeySortedTablesOffset);\n if (nativeInline != null) {\n fbBuilder.addStruct(51, nativeInline!.pack(fbBuilder));\n }\n fbBuilder.addUint64(52, longEnumNonEnumDefault.value);\n fbBuilder.addUint64(53, longEnumNormalDefault.value);\n fbBuilder.addFloat32(54, nanDefault);\n fbBuilder.addFloat32(55, infDefault);\n fbBuilder.addFloat32(56, positiveInfDefault);\n fbBuilder.addFloat32(57, infinityDefault);\n fbBuilder.addFloat32(58, positiveInfinityDefault);\n fbBuilder.addFloat32(59, negativeInfDefault);\n fbBuilder.addFloat32(60, negativeInfinityDefault);\n fbBuilder.addFloat64(61, doubleInfDefault);\n return fbBuilder.endTable();\n }\n\n @override\n String toString() {\n return 'MonsterT{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}, nativeInline: ${nativeInline}, longEnumNonEnumDefault: ${longEnumNonEnumDefault}, longEnumNormalDefault: ${longEnumNormalDefault}, nanDefault: ${nanDefault}, infDefault: ${infDefault}, positiveInfDefault: ${positiveInfDefault}, infinityDefault: ${infinityDefault}, positiveInfinityDefault: ${positiveInfinityDefault}, negativeInfDefault: ${negativeInfDefault}, negativeInfinityDefault: ${negativeInfinityDefault}, doubleInfDefault: ${doubleInfDefault}}';\n }\n}\n\nclass _MonsterReader extends fb.TableReader {\n const _MonsterReader();\n\n @override\n Monster createObject(fb.BufferContext bc, int offset) =>\n Monster._(bc, offset);\n}\n\nclass MonsterBuilder {\n MonsterBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n void begin() {\n fbBuilder.startTable(62);\n }\n\n int addPos(int offset) {\n fbBuilder.addStruct(0, offset);\n return fbBuilder.offset;\n }\n\n int addMana(int? mana) {\n fbBuilder.addInt16(1, mana);\n return fbBuilder.offset;\n }\n\n int addHp(int? hp) {\n fbBuilder.addInt16(2, hp);\n return fbBuilder.offset;\n }\n\n int addNameOffset(int? offset) {\n fbBuilder.addOffset(3, offset);\n return fbBuilder.offset;\n }\n\n int addInventoryOffset(int? offset) {\n fbBuilder.addOffset(5, offset);\n return fbBuilder.offset;\n }\n\n int addColor(Color? color) {\n fbBuilder.addUint8(6, color?.value);\n return fbBuilder.offset;\n }\n\n int addTestType(AnyTypeId? testType) {\n fbBuilder.addUint8(7, testType?.value);\n return fbBuilder.offset;\n }\n\n int addTestOffset(int? offset) {\n fbBuilder.addOffset(8, offset);\n return fbBuilder.offset;\n }\n\n int addTest4Offset(int? offset) {\n fbBuilder.addOffset(9, offset);\n return fbBuilder.offset;\n }\n\n int addTestarrayofstringOffset(int? offset) {\n fbBuilder.addOffset(10, offset);\n return fbBuilder.offset;\n }\n\n int addTestarrayoftablesOffset(int? offset) {\n fbBuilder.addOffset(11, offset);\n return fbBuilder.offset;\n }\n\n int addEnemyOffset(int? offset) {\n fbBuilder.addOffset(12, offset);\n return fbBuilder.offset;\n }\n\n int addTestnestedflatbufferOffset(int? offset) {\n fbBuilder.addOffset(13, offset);\n return fbBuilder.offset;\n }\n\n int addTestemptyOffset(int? offset) {\n fbBuilder.addOffset(14, offset);\n return fbBuilder.offset;\n }\n\n int addTestbool(bool? testbool) {\n fbBuilder.addBool(15, testbool);\n return fbBuilder.offset;\n }\n\n int addTesthashs32Fnv1(int? testhashs32Fnv1) {\n fbBuilder.addInt32(16, testhashs32Fnv1);\n return fbBuilder.offset;\n }\n\n int addTesthashu32Fnv1(int? testhashu32Fnv1) {\n fbBuilder.addUint32(17, testhashu32Fnv1);\n return fbBuilder.offset;\n }\n\n int addTesthashs64Fnv1(int? testhashs64Fnv1) {\n fbBuilder.addInt64(18, testhashs64Fnv1);\n return fbBuilder.offset;\n }\n\n int addTesthashu64Fnv1(int? testhashu64Fnv1) {\n fbBuilder.addUint64(19, testhashu64Fnv1);\n return fbBuilder.offset;\n }\n\n int addTesthashs32Fnv1a(int? testhashs32Fnv1a) {\n fbBuilder.addInt32(20, testhashs32Fnv1a);\n return fbBuilder.offset;\n }\n\n int addTesthashu32Fnv1a(int? testhashu32Fnv1a) {\n fbBuilder.addUint32(21, testhashu32Fnv1a);\n return fbBuilder.offset;\n }\n\n int addTesthashs64Fnv1a(int? testhashs64Fnv1a) {\n fbBuilder.addInt64(22, testhashs64Fnv1a);\n return fbBuilder.offset;\n }\n\n int addTesthashu64Fnv1a(int? testhashu64Fnv1a) {\n fbBuilder.addUint64(23, testhashu64Fnv1a);\n return fbBuilder.offset;\n }\n\n int addTestarrayofboolsOffset(int? offset) {\n fbBuilder.addOffset(24, offset);\n return fbBuilder.offset;\n }\n\n int addTestf(double? testf) {\n fbBuilder.addFloat32(25, testf);\n return fbBuilder.offset;\n }\n\n int addTestf2(double? testf2) {\n fbBuilder.addFloat32(26, testf2);\n return fbBuilder.offset;\n }\n\n int addTestf3(double? testf3) {\n fbBuilder.addFloat32(27, testf3);\n return fbBuilder.offset;\n }\n\n int addTestarrayofstring2Offset(int? offset) {\n fbBuilder.addOffset(28, offset);\n return fbBuilder.offset;\n }\n\n int addTestarrayofsortedstructOffset(int? offset) {\n fbBuilder.addOffset(29, offset);\n return fbBuilder.offset;\n }\n\n int addFlexOffset(int? offset) {\n fbBuilder.addOffset(30, offset);\n return fbBuilder.offset;\n }\n\n int addTest5Offset(int? offset) {\n fbBuilder.addOffset(31, offset);\n return fbBuilder.offset;\n }\n\n int addVectorOfLongsOffset(int? offset) {\n fbBuilder.addOffset(32, offset);\n return fbBuilder.offset;\n }\n\n int addVectorOfDoublesOffset(int? offset) {\n fbBuilder.addOffset(33, offset);\n return fbBuilder.offset;\n }\n\n int addParentNamespaceTestOffset(int? offset) {\n fbBuilder.addOffset(34, offset);\n return fbBuilder.offset;\n }\n\n int addVectorOfReferrablesOffset(int? offset) {\n fbBuilder.addOffset(35, offset);\n return fbBuilder.offset;\n }\n\n int addSingleWeakReference(int? singleWeakReference) {\n fbBuilder.addUint64(36, singleWeakReference);\n return fbBuilder.offset;\n }\n\n int addVectorOfWeakReferencesOffset(int? offset) {\n fbBuilder.addOffset(37, offset);\n return fbBuilder.offset;\n }\n\n int addVectorOfStrongReferrablesOffset(int? offset) {\n fbBuilder.addOffset(38, offset);\n return fbBuilder.offset;\n }\n\n int addCoOwningReference(int? coOwningReference) {\n fbBuilder.addUint64(39, coOwningReference);\n return fbBuilder.offset;\n }\n\n int addVectorOfCoOwningReferencesOffset(int? offset) {\n fbBuilder.addOffset(40, offset);\n return fbBuilder.offset;\n }\n\n int addNonOwningReference(int? nonOwningReference) {\n fbBuilder.addUint64(41, nonOwningReference);\n return fbBuilder.offset;\n }\n\n int addVectorOfNonOwningReferencesOffset(int? offset) {\n fbBuilder.addOffset(42, offset);\n return fbBuilder.offset;\n }\n\n int addAnyUniqueType(AnyUniqueAliasesTypeId? anyUniqueType) {\n fbBuilder.addUint8(43, anyUniqueType?.value);\n return fbBuilder.offset;\n }\n\n int addAnyUniqueOffset(int? offset) {\n fbBuilder.addOffset(44, offset);\n return fbBuilder.offset;\n }\n\n int addAnyAmbiguousType(AnyAmbiguousAliasesTypeId? anyAmbiguousType) {\n fbBuilder.addUint8(45, anyAmbiguousType?.value);\n return fbBuilder.offset;\n }\n\n int addAnyAmbiguousOffset(int? offset) {\n fbBuilder.addOffset(46, offset);\n return fbBuilder.offset;\n }\n\n int addVectorOfEnumsOffset(int? offset) {\n fbBuilder.addOffset(47, offset);\n return fbBuilder.offset;\n }\n\n int addSignedEnum(Race? signedEnum) {\n fbBuilder.addInt8(48, signedEnum?.value);\n return fbBuilder.offset;\n }\n\n int addTestrequirednestedflatbufferOffset(int? offset) {\n fbBuilder.addOffset(49, offset);\n return fbBuilder.offset;\n }\n\n int addScalarKeySortedTablesOffset(int? offset) {\n fbBuilder.addOffset(50, offset);\n return fbBuilder.offset;\n }\n\n int addNativeInline(int offset) {\n fbBuilder.addStruct(51, offset);\n return fbBuilder.offset;\n }\n\n int addLongEnumNonEnumDefault(LongEnum? longEnumNonEnumDefault) {\n fbBuilder.addUint64(52, longEnumNonEnumDefault?.value);\n return fbBuilder.offset;\n }\n\n int addLongEnumNormalDefault(LongEnum? longEnumNormalDefault) {\n fbBuilder.addUint64(53, longEnumNormalDefault?.value);\n return fbBuilder.offset;\n }\n\n int addNanDefault(double? nanDefault) {\n fbBuilder.addFloat32(54, nanDefault);\n return fbBuilder.offset;\n }\n\n int addInfDefault(double? infDefault) {\n fbBuilder.addFloat32(55, infDefault);\n return fbBuilder.offset;\n }\n\n int addPositiveInfDefault(double? positiveInfDefault) {\n fbBuilder.addFloat32(56, positiveInfDefault);\n return fbBuilder.offset;\n }\n\n int addInfinityDefault(double? infinityDefault) {\n fbBuilder.addFloat32(57, infinityDefault);\n return fbBuilder.offset;\n }\n\n int addPositiveInfinityDefault(double? positiveInfinityDefault) {\n fbBuilder.addFloat32(58, positiveInfinityDefault);\n return fbBuilder.offset;\n }\n\n int addNegativeInfDefault(double? negativeInfDefault) {\n fbBuilder.addFloat32(59, negativeInfDefault);\n return fbBuilder.offset;\n }\n\n int addNegativeInfinityDefault(double? negativeInfinityDefault) {\n fbBuilder.addFloat32(60, negativeInfinityDefault);\n return fbBuilder.offset;\n }\n\n int addDoubleInfDefault(double? doubleInfDefault) {\n fbBuilder.addFloat64(61, doubleInfDefault);\n return fbBuilder.offset;\n }\n\n int finish() {\n return fbBuilder.endTable();\n }\n}\n\nclass MonsterObjectBuilder extends fb.ObjectBuilder {\n final Vec3ObjectBuilder? _pos;\n final int? _mana;\n final int? _hp;\n final String? _name;\n final List? _inventory;\n final Color? _color;\n final AnyTypeId? _testType;\n final dynamic _test;\n final List? _test4;\n final List? _testarrayofstring;\n final List? _testarrayoftables;\n final MonsterObjectBuilder? _enemy;\n final List? _testnestedflatbuffer;\n final StatObjectBuilder? _testempty;\n final bool? _testbool;\n final int? _testhashs32Fnv1;\n final int? _testhashu32Fnv1;\n final int? _testhashs64Fnv1;\n final int? _testhashu64Fnv1;\n final int? _testhashs32Fnv1a;\n final int? _testhashu32Fnv1a;\n final int? _testhashs64Fnv1a;\n final int? _testhashu64Fnv1a;\n final List? _testarrayofbools;\n final double? _testf;\n final double? _testf2;\n final double? _testf3;\n final List? _testarrayofstring2;\n final List? _testarrayofsortedstruct;\n final List? _flex;\n final List? _test5;\n final List? _vectorOfLongs;\n final List? _vectorOfDoubles;\n final my_game.InParentNamespaceObjectBuilder? _parentNamespaceTest;\n final List? _vectorOfReferrables;\n final int? _singleWeakReference;\n final List? _vectorOfWeakReferences;\n final List? _vectorOfStrongReferrables;\n final int? _coOwningReference;\n final List? _vectorOfCoOwningReferences;\n final int? _nonOwningReference;\n final List? _vectorOfNonOwningReferences;\n final AnyUniqueAliasesTypeId? _anyUniqueType;\n final dynamic _anyUnique;\n final AnyAmbiguousAliasesTypeId? _anyAmbiguousType;\n final dynamic _anyAmbiguous;\n final List? _vectorOfEnums;\n final Race? _signedEnum;\n final List? _testrequirednestedflatbuffer;\n final List? _scalarKeySortedTables;\n final TestObjectBuilder? _nativeInline;\n final LongEnum? _longEnumNonEnumDefault;\n final LongEnum? _longEnumNormalDefault;\n final double? _nanDefault;\n final double? _infDefault;\n final double? _positiveInfDefault;\n final double? _infinityDefault;\n final double? _positiveInfinityDefault;\n final double? _negativeInfDefault;\n final double? _negativeInfinityDefault;\n final double? _doubleInfDefault;\n\n MonsterObjectBuilder({\n Vec3ObjectBuilder? pos,\n int? mana,\n int? hp,\n String? name,\n List? inventory,\n Color? color,\n AnyTypeId? testType,\n dynamic test,\n List? test4,\n List? testarrayofstring,\n List? testarrayoftables,\n MonsterObjectBuilder? enemy,\n List? testnestedflatbuffer,\n StatObjectBuilder? testempty,\n bool? testbool,\n int? testhashs32Fnv1,\n int? testhashu32Fnv1,\n int? testhashs64Fnv1,\n int? testhashu64Fnv1,\n int? testhashs32Fnv1a,\n int? testhashu32Fnv1a,\n int? testhashs64Fnv1a,\n int? testhashu64Fnv1a,\n List? testarrayofbools,\n double? testf,\n double? testf2,\n double? testf3,\n List? testarrayofstring2,\n List? testarrayofsortedstruct,\n List? flex,\n List? test5,\n List? vectorOfLongs,\n List? vectorOfDoubles,\n my_game.InParentNamespaceObjectBuilder? parentNamespaceTest,\n List? vectorOfReferrables,\n int? singleWeakReference,\n List? vectorOfWeakReferences,\n List? vectorOfStrongReferrables,\n int? coOwningReference,\n List? vectorOfCoOwningReferences,\n int? nonOwningReference,\n List? vectorOfNonOwningReferences,\n AnyUniqueAliasesTypeId? anyUniqueType,\n dynamic anyUnique,\n AnyAmbiguousAliasesTypeId? anyAmbiguousType,\n dynamic anyAmbiguous,\n List? vectorOfEnums,\n Race? signedEnum,\n List? testrequirednestedflatbuffer,\n List? scalarKeySortedTables,\n TestObjectBuilder? nativeInline,\n LongEnum? longEnumNonEnumDefault,\n LongEnum? longEnumNormalDefault,\n double? nanDefault,\n double? infDefault,\n double? positiveInfDefault,\n double? infinityDefault,\n double? positiveInfinityDefault,\n double? negativeInfDefault,\n double? negativeInfinityDefault,\n double? doubleInfDefault,\n }) : _pos = pos,\n _mana = mana,\n _hp = hp,\n _name = name,\n _inventory = inventory,\n _color = color,\n _testType = testType,\n _test = test,\n _test4 = test4,\n _testarrayofstring = testarrayofstring,\n _testarrayoftables = testarrayoftables,\n _enemy = enemy,\n _testnestedflatbuffer = testnestedflatbuffer,\n _testempty = testempty,\n _testbool = testbool,\n _testhashs32Fnv1 = testhashs32Fnv1,\n _testhashu32Fnv1 = testhashu32Fnv1,\n _testhashs64Fnv1 = testhashs64Fnv1,\n _testhashu64Fnv1 = testhashu64Fnv1,\n _testhashs32Fnv1a = testhashs32Fnv1a,\n _testhashu32Fnv1a = testhashu32Fnv1a,\n _testhashs64Fnv1a = testhashs64Fnv1a,\n _testhashu64Fnv1a = testhashu64Fnv1a,\n _testarrayofbools = testarrayofbools,\n _testf = testf,\n _testf2 = testf2,\n _testf3 = testf3,\n _testarrayofstring2 = testarrayofstring2,\n _testarrayofsortedstruct = testarrayofsortedstruct,\n _flex = flex,\n _test5 = test5,\n _vectorOfLongs = vectorOfLongs,\n _vectorOfDoubles = vectorOfDoubles,\n _parentNamespaceTest = parentNamespaceTest,\n _vectorOfReferrables = vectorOfReferrables,\n _singleWeakReference = singleWeakReference,\n _vectorOfWeakReferences = vectorOfWeakReferences,\n _vectorOfStrongReferrables = vectorOfStrongReferrables,\n _coOwningReference = coOwningReference,\n _vectorOfCoOwningReferences = vectorOfCoOwningReferences,\n _nonOwningReference = nonOwningReference,\n _vectorOfNonOwningReferences = vectorOfNonOwningReferences,\n _anyUniqueType = anyUniqueType,\n _anyUnique = anyUnique,\n _anyAmbiguousType = anyAmbiguousType,\n _anyAmbiguous = anyAmbiguous,\n _vectorOfEnums = vectorOfEnums,\n _signedEnum = signedEnum,\n _testrequirednestedflatbuffer = testrequirednestedflatbuffer,\n _scalarKeySortedTables = scalarKeySortedTables,\n _nativeInline = nativeInline,\n _longEnumNonEnumDefault = longEnumNonEnumDefault,\n _longEnumNormalDefault = longEnumNormalDefault,\n _nanDefault = nanDefault,\n _infDefault = infDefault,\n _positiveInfDefault = positiveInfDefault,\n _infinityDefault = infinityDefault,\n _positiveInfinityDefault = positiveInfinityDefault,\n _negativeInfDefault = negativeInfDefault,\n _negativeInfinityDefault = negativeInfinityDefault,\n _doubleInfDefault = doubleInfDefault;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n final int? nameOffset = _name == null\n ? null\n : fbBuilder.writeString(_name!);\n final int? inventoryOffset = _inventory == null\n ? null\n : fbBuilder.writeListUint8(_inventory!);\n final int? testOffset = _test?.getOrCreateOffset(fbBuilder);\n final int? test4Offset = _test4 == null\n ? null\n : fbBuilder.writeListOfStructs(_test4!);\n final int? testarrayofstringOffset = _testarrayofstring == null\n ? null\n : fbBuilder.writeList(\n _testarrayofstring!.map(fbBuilder.writeString).toList(),\n );\n final int? testarrayoftablesOffset = _testarrayoftables == null\n ? null\n : fbBuilder.writeList(\n _testarrayoftables!\n .map((b) => b.getOrCreateOffset(fbBuilder))\n .toList(),\n );\n final int? enemyOffset = _enemy?.getOrCreateOffset(fbBuilder);\n final int? testnestedflatbufferOffset = _testnestedflatbuffer == null\n ? null\n : fbBuilder.writeListUint8(_testnestedflatbuffer!);\n final int? testemptyOffset = _testempty?.getOrCreateOffset(fbBuilder);\n final int? testarrayofboolsOffset = _testarrayofbools == null\n ? null\n : fbBuilder.writeListBool(_testarrayofbools!);\n final int? testarrayofstring2Offset = _testarrayofstring2 == null\n ? null\n : fbBuilder.writeList(\n _testarrayofstring2!.map(fbBuilder.writeString).toList(),\n );\n final int? testarrayofsortedstructOffset = _testarrayofsortedstruct == null\n ? null\n : fbBuilder.writeListOfStructs(_testarrayofsortedstruct!);\n final int? flexOffset = _flex == null\n ? null\n : fbBuilder.writeListUint8(_flex!);\n final int? test5Offset = _test5 == null\n ? null\n : fbBuilder.writeListOfStructs(_test5!);\n final int? vectorOfLongsOffset = _vectorOfLongs == null\n ? null\n : fbBuilder.writeListInt64(_vectorOfLongs!);\n final int? vectorOfDoublesOffset = _vectorOfDoubles == null\n ? null\n : fbBuilder.writeListFloat64(_vectorOfDoubles!);\n final int? parentNamespaceTestOffset = _parentNamespaceTest\n ?.getOrCreateOffset(fbBuilder);\n final int? vectorOfReferrablesOffset = _vectorOfReferrables == null\n ? null\n : fbBuilder.writeList(\n _vectorOfReferrables!\n .map((b) => b.getOrCreateOffset(fbBuilder))\n .toList(),\n );\n final int? vectorOfWeakReferencesOffset = _vectorOfWeakReferences == null\n ? null\n : fbBuilder.writeListUint64(_vectorOfWeakReferences!);\n final int? vectorOfStrongReferrablesOffset =\n _vectorOfStrongReferrables == null\n ? null\n : fbBuilder.writeList(\n _vectorOfStrongReferrables!\n .map((b) => b.getOrCreateOffset(fbBuilder))\n .toList(),\n );\n final int? vectorOfCoOwningReferencesOffset =\n _vectorOfCoOwningReferences == null\n ? null\n : fbBuilder.writeListUint64(_vectorOfCoOwningReferences!);\n final int? vectorOfNonOwningReferencesOffset =\n _vectorOfNonOwningReferences == null\n ? null\n : fbBuilder.writeListUint64(_vectorOfNonOwningReferences!);\n final int? anyUniqueOffset = _anyUnique?.getOrCreateOffset(fbBuilder);\n final int? anyAmbiguousOffset = _anyAmbiguous?.getOrCreateOffset(fbBuilder);\n final int? vectorOfEnumsOffset = _vectorOfEnums == null\n ? null\n : fbBuilder.writeListUint8(\n _vectorOfEnums!.map((f) => f.value).toList(),\n );\n final int? testrequirednestedflatbufferOffset =\n _testrequirednestedflatbuffer == null\n ? null\n : fbBuilder.writeListUint8(_testrequirednestedflatbuffer!);\n final int? scalarKeySortedTablesOffset = _scalarKeySortedTables == null\n ? null\n : fbBuilder.writeList(\n _scalarKeySortedTables!\n .map((b) => b.getOrCreateOffset(fbBuilder))\n .toList(),\n );\n fbBuilder.startTable(62);\n if (_pos != null) {\n fbBuilder.addStruct(0, _pos!.finish(fbBuilder));\n }\n fbBuilder.addInt16(1, _mana);\n fbBuilder.addInt16(2, _hp);\n fbBuilder.addOffset(3, nameOffset);\n fbBuilder.addOffset(5, inventoryOffset);\n fbBuilder.addUint8(6, _color?.value);\n fbBuilder.addUint8(7, _testType?.value);\n fbBuilder.addOffset(8, testOffset);\n fbBuilder.addOffset(9, test4Offset);\n fbBuilder.addOffset(10, testarrayofstringOffset);\n fbBuilder.addOffset(11, testarrayoftablesOffset);\n fbBuilder.addOffset(12, enemyOffset);\n fbBuilder.addOffset(13, testnestedflatbufferOffset);\n fbBuilder.addOffset(14, testemptyOffset);\n fbBuilder.addBool(15, _testbool);\n fbBuilder.addInt32(16, _testhashs32Fnv1);\n fbBuilder.addUint32(17, _testhashu32Fnv1);\n fbBuilder.addInt64(18, _testhashs64Fnv1);\n fbBuilder.addUint64(19, _testhashu64Fnv1);\n fbBuilder.addInt32(20, _testhashs32Fnv1a);\n fbBuilder.addUint32(21, _testhashu32Fnv1a);\n fbBuilder.addInt64(22, _testhashs64Fnv1a);\n fbBuilder.addUint64(23, _testhashu64Fnv1a);\n fbBuilder.addOffset(24, testarrayofboolsOffset);\n fbBuilder.addFloat32(25, _testf);\n fbBuilder.addFloat32(26, _testf2);\n fbBuilder.addFloat32(27, _testf3);\n fbBuilder.addOffset(28, testarrayofstring2Offset);\n fbBuilder.addOffset(29, testarrayofsortedstructOffset);\n fbBuilder.addOffset(30, flexOffset);\n fbBuilder.addOffset(31, test5Offset);\n fbBuilder.addOffset(32, vectorOfLongsOffset);\n fbBuilder.addOffset(33, vectorOfDoublesOffset);\n fbBuilder.addOffset(34, parentNamespaceTestOffset);\n fbBuilder.addOffset(35, vectorOfReferrablesOffset);\n fbBuilder.addUint64(36, _singleWeakReference);\n fbBuilder.addOffset(37, vectorOfWeakReferencesOffset);\n fbBuilder.addOffset(38, vectorOfStrongReferrablesOffset);\n fbBuilder.addUint64(39, _coOwningReference);\n fbBuilder.addOffset(40, vectorOfCoOwningReferencesOffset);\n fbBuilder.addUint64(41, _nonOwningReference);\n fbBuilder.addOffset(42, vectorOfNonOwningReferencesOffset);\n fbBuilder.addUint8(43, _anyUniqueType?.value);\n fbBuilder.addOffset(44, anyUniqueOffset);\n fbBuilder.addUint8(45, _anyAmbiguousType?.value);\n fbBuilder.addOffset(46, anyAmbiguousOffset);\n fbBuilder.addOffset(47, vectorOfEnumsOffset);\n fbBuilder.addInt8(48, _signedEnum?.value);\n fbBuilder.addOffset(49, testrequirednestedflatbufferOffset);\n fbBuilder.addOffset(50, scalarKeySortedTablesOffset);\n if (_nativeInline != null) {\n fbBuilder.addStruct(51, _nativeInline!.finish(fbBuilder));\n }\n fbBuilder.addUint64(52, _longEnumNonEnumDefault?.value);\n fbBuilder.addUint64(53, _longEnumNormalDefault?.value);\n fbBuilder.addFloat32(54, _nanDefault);\n fbBuilder.addFloat32(55, _infDefault);\n fbBuilder.addFloat32(56, _positiveInfDefault);\n fbBuilder.addFloat32(57, _infinityDefault);\n fbBuilder.addFloat32(58, _positiveInfinityDefault);\n fbBuilder.addFloat32(59, _negativeInfDefault);\n fbBuilder.addFloat32(60, _negativeInfinityDefault);\n fbBuilder.addFloat64(61, _doubleInfDefault);\n return fbBuilder.endTable();\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n\nclass TypeAliases {\n TypeAliases._(this._bc, this._bcOffset);\n factory TypeAliases(List bytes) {\n final rootRef = fb.BufferContext.fromBytes(bytes);\n return reader.read(rootRef, 0);\n }\n\n static const fb.Reader reader = _TypeAliasesReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n int get i8 => const fb.Int8Reader().vTableGet(_bc, _bcOffset, 4, 0);\n int get u8 => const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 6, 0);\n int get i16 => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 8, 0);\n int get u16 => const fb.Uint16Reader().vTableGet(_bc, _bcOffset, 10, 0);\n int get i32 => const fb.Int32Reader().vTableGet(_bc, _bcOffset, 12, 0);\n int get u32 => const fb.Uint32Reader().vTableGet(_bc, _bcOffset, 14, 0);\n int get i64 => const fb.Int64Reader().vTableGet(_bc, _bcOffset, 16, 0);\n int get u64 => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 18, 0);\n double get f32 => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 20, 0.0);\n double get f64 => const fb.Float64Reader().vTableGet(_bc, _bcOffset, 22, 0.0);\n List? get v8 =>\n const fb.Int8ListReader().vTableGetNullable(_bc, _bcOffset, 24);\n List? get vf64 => const fb.ListReader(\n fb.Float64Reader(),\n ).vTableGetNullable(_bc, _bcOffset, 26);\n\n @override\n String toString() {\n return 'TypeAliases{i8: ${i8}, u8: ${u8}, i16: ${i16}, u16: ${u16}, i32: ${i32}, u32: ${u32}, i64: ${i64}, u64: ${u64}, f32: ${f32}, f64: ${f64}, v8: ${v8}, vf64: ${vf64}}';\n }\n\n TypeAliasesT unpack() => TypeAliasesT(\n i8: i8,\n u8: u8,\n i16: i16,\n u16: u16,\n i32: i32,\n u32: u32,\n i64: i64,\n u64: u64,\n f32: f32,\n f64: f64,\n v8: v8?.toList(),\n vf64: vf64?.toList(),\n );\n\n static int pack(fb.Builder fbBuilder, TypeAliasesT? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass TypeAliasesT implements fb.Packable {\n int i8;\n int u8;\n int i16;\n int u16;\n int i32;\n int u32;\n int i64;\n int u64;\n double f32;\n double f64;\n List? v8;\n List? vf64;\n\n TypeAliasesT({\n this.i8 = 0,\n this.u8 = 0,\n this.i16 = 0,\n this.u16 = 0,\n this.i32 = 0,\n this.u32 = 0,\n this.i64 = 0,\n this.u64 = 0,\n this.f32 = 0.0,\n this.f64 = 0.0,\n this.v8,\n this.vf64,\n });\n\n @override\n int pack(fb.Builder fbBuilder) {\n final int? v8Offset = v8 == null ? null : fbBuilder.writeListInt8(v8!);\n final int? vf64Offset = vf64 == null\n ? null\n : fbBuilder.writeListFloat64(vf64!);\n fbBuilder.startTable(12);\n fbBuilder.addInt8(0, i8);\n fbBuilder.addUint8(1, u8);\n fbBuilder.addInt16(2, i16);\n fbBuilder.addUint16(3, u16);\n fbBuilder.addInt32(4, i32);\n fbBuilder.addUint32(5, u32);\n fbBuilder.addInt64(6, i64);\n fbBuilder.addUint64(7, u64);\n fbBuilder.addFloat32(8, f32);\n fbBuilder.addFloat64(9, f64);\n fbBuilder.addOffset(10, v8Offset);\n fbBuilder.addOffset(11, vf64Offset);\n return fbBuilder.endTable();\n }\n\n @override\n String toString() {\n return 'TypeAliasesT{i8: ${i8}, u8: ${u8}, i16: ${i16}, u16: ${u16}, i32: ${i32}, u32: ${u32}, i64: ${i64}, u64: ${u64}, f32: ${f32}, f64: ${f64}, v8: ${v8}, vf64: ${vf64}}';\n }\n}\n\nclass _TypeAliasesReader extends fb.TableReader {\n const _TypeAliasesReader();\n\n @override\n TypeAliases createObject(fb.BufferContext bc, int offset) =>\n TypeAliases._(bc, offset);\n}\n\nclass TypeAliasesBuilder {\n TypeAliasesBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n void begin() {\n fbBuilder.startTable(12);\n }\n\n int addI8(int? i8) {\n fbBuilder.addInt8(0, i8);\n return fbBuilder.offset;\n }\n\n int addU8(int? u8) {\n fbBuilder.addUint8(1, u8);\n return fbBuilder.offset;\n }\n\n int addI16(int? i16) {\n fbBuilder.addInt16(2, i16);\n return fbBuilder.offset;\n }\n\n int addU16(int? u16) {\n fbBuilder.addUint16(3, u16);\n return fbBuilder.offset;\n }\n\n int addI32(int? i32) {\n fbBuilder.addInt32(4, i32);\n return fbBuilder.offset;\n }\n\n int addU32(int? u32) {\n fbBuilder.addUint32(5, u32);\n return fbBuilder.offset;\n }\n\n int addI64(int? i64) {\n fbBuilder.addInt64(6, i64);\n return fbBuilder.offset;\n }\n\n int addU64(int? u64) {\n fbBuilder.addUint64(7, u64);\n return fbBuilder.offset;\n }\n\n int addF32(double? f32) {\n fbBuilder.addFloat32(8, f32);\n return fbBuilder.offset;\n }\n\n int addF64(double? f64) {\n fbBuilder.addFloat64(9, f64);\n return fbBuilder.offset;\n }\n\n int addV8Offset(int? offset) {\n fbBuilder.addOffset(10, offset);\n return fbBuilder.offset;\n }\n\n int addVf64Offset(int? offset) {\n fbBuilder.addOffset(11, offset);\n return fbBuilder.offset;\n }\n\n int finish() {\n return fbBuilder.endTable();\n }\n}\n\nclass TypeAliasesObjectBuilder extends fb.ObjectBuilder {\n final int? _i8;\n final int? _u8;\n final int? _i16;\n final int? _u16;\n final int? _i32;\n final int? _u32;\n final int? _i64;\n final int? _u64;\n final double? _f32;\n final double? _f64;\n final List? _v8;\n final List? _vf64;\n\n TypeAliasesObjectBuilder({\n int? i8,\n int? u8,\n int? i16,\n int? u16,\n int? i32,\n int? u32,\n int? i64,\n int? u64,\n double? f32,\n double? f64,\n List? v8,\n List? vf64,\n }) : _i8 = i8,\n _u8 = u8,\n _i16 = i16,\n _u16 = u16,\n _i32 = i32,\n _u32 = u32,\n _i64 = i64,\n _u64 = u64,\n _f32 = f32,\n _f64 = f64,\n _v8 = v8,\n _vf64 = vf64;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n final int? v8Offset = _v8 == null ? null : fbBuilder.writeListInt8(_v8!);\n final int? vf64Offset = _vf64 == null\n ? null\n : fbBuilder.writeListFloat64(_vf64!);\n fbBuilder.startTable(12);\n fbBuilder.addInt8(0, _i8);\n fbBuilder.addUint8(1, _u8);\n fbBuilder.addInt16(2, _i16);\n fbBuilder.addUint16(3, _u16);\n fbBuilder.addInt32(4, _i32);\n fbBuilder.addUint32(5, _u32);\n fbBuilder.addInt64(6, _i64);\n fbBuilder.addUint64(7, _u64);\n fbBuilder.addFloat32(8, _f32);\n fbBuilder.addFloat64(9, _f64);\n fbBuilder.addOffset(10, v8Offset);\n fbBuilder.addOffset(11, vf64Offset);\n return fbBuilder.endTable();\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n" }, { "path": "dart/test/monster_test_my_game_generated.dart", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable, constant_identifier_names\n\nlibrary my_game;\n\nimport 'dart:typed_data' show Uint8List;\n\nimport 'package:flat_buffers/flat_buffers.dart' as fb;\n\nimport './include_test1_generated.dart';\nimport './monster_test_my_game.example2_generated.dart' as my_game_example2;\nimport './monster_test_my_game.example_generated.dart' as my_game_example;\n\nclass InParentNamespace {\n InParentNamespace._(this._bc, this._bcOffset);\n factory InParentNamespace(List bytes) {\n final rootRef = fb.BufferContext.fromBytes(bytes);\n return reader.read(rootRef, 0);\n }\n\n static const fb.Reader reader = _InParentNamespaceReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n @override\n String toString() {\n return 'InParentNamespace{}';\n }\n\n InParentNamespaceT unpack() => InParentNamespaceT();\n\n static int pack(fb.Builder fbBuilder, InParentNamespaceT? object) {\n if (object == null) return 0;\n return object.pack(fbBuilder);\n }\n}\n\nclass InParentNamespaceT implements fb.Packable {\n @override\n int pack(fb.Builder fbBuilder) {\n fbBuilder.startTable(0);\n return fbBuilder.endTable();\n }\n\n @override\n String toString() {\n return 'InParentNamespaceT{}';\n }\n}\n\nclass _InParentNamespaceReader extends fb.TableReader {\n const _InParentNamespaceReader();\n\n @override\n InParentNamespace createObject(fb.BufferContext bc, int offset) =>\n InParentNamespace._(bc, offset);\n}\n\nclass InParentNamespaceObjectBuilder extends fb.ObjectBuilder {\n InParentNamespaceObjectBuilder();\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n fbBuilder.startTable(0);\n return fbBuilder.endTable();\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n" }, { "path": "docs/README.md", "content": "# Documentation\n\nThis is the source of the FlatBuffers documentation, that is served at\nhttps://flatbuffers.dev.\n\n\n## Local Building\n\nThe documentation can be built and served locally during development, see for full details.\n\n__tl;dr__\n\nInstall:\n\n```\npip install mkdocs-material\npip install mkdocs-redirects\n```\n\nBuild and Serve:\n\n```\nmkdocs serve -f docs/mkdocs.yml\n```\n" }, { "path": "docs/mkdocs.yml", "content": "site_name: FlatBuffers Docs\ndocs_dir: source\nsite_url: https://flatbuffers.dev\nrepo_name: google/FlatBuffers\nrepo_url: https://github.com/google/flatbuffers\nedit_uri: edit/master/docs/source/\ncopyright: Copyright © 2025 Google\ntheme:\n name: material\n logo: assets/flatbuffers_logo.svg\n icon:\n repo: fontawesome/brands/github\n custom_dir: overrides\n palette:\n # Palette toggle for light mode\n - scheme: default\n toggle:\n icon: material/brightness-7\n name: Switch to dark mode\n\n # Palette toggle for dark mode\n - scheme: slate\n toggle:\n icon: material/brightness-4\n name: Switch to light mode\n\n features:\n # Allows code block annotations\n - content.code.annotate\n\n # Allows content tabs to link together\n - content.tabs.link\n \n # Expand nav folders by default\n - navigation.expand\n\n # Enable the footer\n - navigation.footer\n \n # Auto hide the header after scrolling\n - header.autohide\n\n - content.action.edit\n\nextra:\n social:\n - icon: fontawesome/brands/github\n link: https://github.com/google/flatbuffers\n\n - icon: fontawesome/brands/discord\n link: https:///discord.gg/6qgKs3R\n\n - icon: fontawesome/brands/x-twitter\n link: https://twitter.com/dbaileychess\n\nplugins:\n # Use redirects to update links from the original docs to the new ones.\n #\n # https://github.com/mkdocs/mkdocs-redirects\n - redirects:\n # Note the .html are suffixed with .md to avoid warnings. Got from \n # https://github.com/mkdocs/mkdocs-redirects/issues/51#issuecomment-2408548029\n redirect_maps:\n 'flatbuffers_guide_building.html.md': 'building.md'\n 'flatbuffers_guide_tutorial.html.md': 'tutorial.md'\n 'flatbuffers_guide_using_schema_compiler.html.md': 'flatc.md'\n 'flatbuffers_guide_writing_schema.html.md': 'schema.md'\n 'md__schemas.html.md': 'schema.md' # issue #8485\n 'flatbuffers_guide_use_c.html.md': 'languages/c.md'\n 'flatbuffers_guide_use_cpp.html.md': 'languages/cpp.md'\n 'flatbuffers_guide_use_c-sharp.html.md': 'languages/c_sharp.md'\n 'flatbuffers_guide_use_dart.html.md': 'languages/dart.md'\n 'flatbuffers_guide_use_go.html.md': 'languages/go.md'\n 'flatbuffers_guide_use_java.html.md': 'languages/java.md'\n 'flatbuffers_guide_use_javascript.html.md': 'languages/javascript.md'\n 'flatbuffers_guide_use_lobster.html.md': 'languages/lobster.md'\n 'flatbuffers_guide_use_lua.html.md': 'languages/lua.md'\n 'flatbuffers_guide_use_php.html.md': 'languages/php.md'\n 'flatbuffers_guide_use_python.html.md': 'languages/python.md'\n 'flatbuffers_guide_use_rust.html.md': 'languages/rust.md'\n 'flatbuffers_guide_use_swift.html.md': 'languages/swift.md'\n 'flatbuffers_guide_use_typescript.html.md': 'languages/typescript.md'\n 'flatbuffers_grpc_guide_use_cpp.html.md' : \"languages/cpp.md#grpc\"\n 'flatbuffers_support.html.md': 'support.md'\n 'flatbuffers_white_paper.html.md': 'white_paper.md'\n 'flatbuffers_grammar.html.md': 'grammar.md'\n 'flatbuffers_internals.html.md': 'internals.md'\n 'intermediate_representation.html.md': 'intermediate_representation.md'\n 'flatbuffers_benchmarks.html.md': 'benchmarks.md'\n 'flexbuffers.html.md': 'flexbuffers.md'\n 'contributing.html.md': 'contributing.md'\n\n\nmarkdown_extensions:\n - admonition\n - attr_list\n - md_in_html\n - pymdownx.critic\n - pymdownx.details\n - pymdownx.emoji:\n emoji_index: !!python/name:material.extensions.emoji.twemoji\n emoji_generator: !!python/name:material.extensions.emoji.to_svg\n - pymdownx.snippets:\n # Allows direct embedded of remote files\n url_download: true\n - pymdownx.superfences\n - pymdownx.tabbed:\n alternate_style: true\n slugify: !!python/object/apply:pymdownx.slugs.slugify\n kwds:\n case: lower\n - pymdownx.highlight:\n extend_pygments_lang:\n # PHP wasn't highlighting correctly. This is a work around found\n # https://github.com/squidfunk/mkdocs-material/issues/138#issuecomment-2294025627\n - name: php\n lang: php\n options:\n startinline: true\n - tables\n\n\n\nnav:\n - Overview: \"index.md\"\n - Quick Start: \"quick_start.md\"\n - Tutorial: \"tutorial.md\"\n - Compiler (flatc): \n - Building: \"building.md\"\n - Using: \"flatc.md\"\n - Schema (.fbs): \n - Overview: \"schema.md\"\n - Evolution: \"evolution.md\"\n - Grammar: \"grammar.md\"\n - Language Guides:\n - C: \"languages/c.md\"\n - C++: \"languages/cpp.md\"\n - C#: \"languages/c_sharp.md\"\n - Dart: \"languages/dart.md\"\n - Go: \"languages/go.md\"\n - Java: \"languages/java.md\"\n - JavaScript: \"languages/javascript.md\"\n - Kotlin: \"languages/kotlin.md\"\n - Lobster: \"languages/lobster.md\"\n - Lua: \"languages/lua.md\"\n - PHP: \"languages/php.md\"\n - Python: \"languages/python.md\"\n - Rust: \"languages/rust.md\"\n - Swift: \"languages/swift.md\"\n - TypeScript: \"languages/typescript.md\"\n - Supported Configurations: \"support.md\"\n - White Paper: \"white_paper.md\"\n - Advanced:\n - FlatBuffers Internals: \"internals.md\"\n - Intermediate Representation: \"intermediate_representation.md\"\n - Annotating Buffers (.afb): \"annotation.md\"\n - Benchmarks: \"benchmarks.md\"\n - FlexBuffers (Schema-less version): \"flexbuffers.md\"\n - Contributing: \"contributing.md\"\n" }, { "path": "docs/overrides/404.html", "content": "{% extends \"main.html\" %}\n\n\n{% block content %}\n

404 - Not found

\n
\n FlatBuffers has migrated their documentation system recently.\n \n Please file an issue indicating the broken link.\n{% endblock %}" }, { "path": "docs/overrides/main.html", "content": "{% extends \"base.html\" %}\n" }, { "path": "docs/source/CNAME", "content": "flatbuffers.dev" }, { "path": "docs/source/annotation.md", "content": "# Annotating FlatBuffers\n\nThis provides a way to annotate flatbuffer binary data, byte-by-byte, with a\nschema. It is useful for development purposes and understanding the details of\nthe internal format.\n\n## Annotating\n\nGiven a `schema`, as either a plain-text (`.fbs`) or a binary schema (`.bfbs`),\nand `binary` file(s) that were created by the `schema`. You can annotate them\nusing:\n\n```sh\nflatc --annotate SCHEMA -- BINARY_FILES...\n```\n\nThis will produce a set of annotated files (`.afb` Annotated FlatBuffer)\ncorresponding to the input binary files.\n\n### Example\n\nTaken from the [tests/annotated_binary](https://github.com/google/flatbuffers/tree/master/tests/annotated_binary).\n\n```sh\ncd tests/annotated_binary\n../../flatc --annotate annotated_binary.fbs -- annotated_binary.bin\n```\n\nWhich will produce a `annotated_binary.afb` file in the current directory.\n\nThe `annotated_binary.bin` is the flatbufer binary of the data contained within\n`annotated_binary.json`, which was made by the following command:\n\n```sh\n..\\..\\flatc -b annotated_binary.fbs annotated_binary.json\n```\n\n## .afb Text Format\n\nCurrently there is a built-in text-based format for outputting the annotations.\nA full example is shown here:\n[`annotated_binary.afb`](https://github.com/google/flatbuffers/blob/master/tests/annotated_binary/annotated_binary.afb)\n\nThe data is organized as a table with fixed [columns](#columns) grouped into\nBinary [sections](#binary-sections) and [regions](#binary-regions), starting\nfrom the beginning of the binary (offset `0`).\n\n### Columns\n\nThe columns are as follows:\n\n1. The offset from the start of the binary, expressed in hexadecimal format\n (e.g. `+0x003c`).\n\n The prefix `+` is added to make searching for the offset (compared to some\n random value) a bit easier.\n\n2. The raw binary data, expressed in hexadecimal format.\n\n This is in the little endian format the buffer uses internally and what you\n would see with a normal binary text viewer.\n\n3. The type of the data.\n\n This may be the type specified in the schema or some internally defined\n types:\n\n\n | Internal Type | Purpose |\n |---------------|----------------------------------------------------|\n | `VOffset16` | Virtual table offset, relative to the table offset |\n | `UOffset32` | Unsigned offset, relative to the current offset |\n | `SOffset32` | Signed offset, relative to the current offset |\n\n\n4. The value of the data.\n\n This is shown in big endian format that is generally written for humans to\n consume (e.g. `0x0013`). As well as the \"casted\" value (e.g. `0x0013 `is\n `19` in decimal) in parentheses.\n\n5. Notes about the particular data.\n\n This describes what the data is about, either some internal usage, or tied\n to the schema.\n\n### Binary Sections\n\nThe file is broken up into Binary Sections, which are comprised of contiguous\n[binary regions](#binary-regions) that are logically grouped together. For\nexample, a binary section may be a single instance of a flatbuffer `Table` or\nits `vtable`. The sections may be labelled with the name of the associated type,\nas defined in the input schema.\n\nAn example of a `vtable` Binary Section that is associated with the user-defined\n`AnnotateBinary.Bar` table.\n\n```\nvtable (AnnotatedBinary.Bar):\n +0x00A0 | 08 00 | uint16_t | 0x0008 (8) | size of this vtable\n +0x00A2 | 13 00 | uint16_t | 0x0013 (19) | size of referring table\n +0x00A4 | 08 00 | VOffset16 | 0x0008 (8) | offset to field `a` (id: 0)\n +0x00A6 | 04 00 | VOffset16 | 0x0004 (4) | offset to field `b` (id: 1)\n```\n\nThese are purely annotative, there is no embedded information about these\nregions in the flatbuffer itself.\n\n### Binary Regions\n\nBinary regions are contiguous bytes regions that are grouped together to form\nsome sort of value, e.g. a `scalar` or an array of scalars. A binary region may\nbe split up over multiple text lines, if the size of the region is large.\n\n#### Annotation Example\n\nLooking at an example binary region:\n\n```\nvtable (AnnotatedBinary.Bar):\n +0x00A0 | 08 00 | uint16_t | 0x0008 (8) | size of this vtable\n```\n\nThe first column (`+0x00A0`) is the offset to this region from the beginning of\nthe buffer.\n\nThe second column are the raw bytes (hexadecimal) that make up this region.\nThese are expressed in the little-endian format that flatbuffers uses for the\nwire format.\n\nThe third column is the type to interpret the bytes as. For the above example,\nthe type is `uint16_t` which is a 16-bit unsigned integer type.\n\nThe fourth column shows the raw bytes as a compacted, big-endian value. The raw\nbytes are duplicated in this fashion since it is more intuitive to read the data\nin the big-endian format (e.g., `0x0008`). This value is followed by the decimal\nrepresentation of the value (e.g., `(8)`). For strings, the raw string value is\nshown instead.\n\nThe fifth column is a textual comment on what the value is. As much metadata as\nknown is provided.\n\n### Offsets\n\nIf the type in the 3rd column is of an absolute offset (`SOffet32` or\n`Offset32`), the fourth column also shows an `Loc: +0x025A` value which shows\nwhere in the binary this region is pointing to. These values are absolute from\nthe beginning of the file, their calculation from the raw value in the 4th\ncolumn depends on the context.\n" }, { "path": "docs/source/benchmarks.md", "content": "C++ Benchmarks {#flatbuffers_benchmarks}\n==========\n\nComparing against other serialization solutions, running on Windows 7\n64bit. We use the LITE runtime for Protocol Buffers (less code / lower\noverhead), Rapid JSON (one of the fastest C++ JSON parsers around),\nand pugixml, also one of the fastest XML parsers.\n\nWe also compare against code that doesn't use a serialization library\nat all (the column \"Raw structs\"), which is what you get if you write\nhardcoded code that just writes structs. This is the fastest possible,\nbut of course is not cross platform nor has any kind of forwards /\nbackwards compatibility.\n\nWe compare against Flatbuffers with the binary wire format (as\nintended), and also with JSON as the wire format with the optional JSON\nparser (which, using a schema, parses JSON into a binary buffer that can\nthen be accessed as before).\n\nThe benchmark object is a set of about 10 objects containing an array, 4\nstrings, and a large variety of int/float scalar values of all sizes,\nmeant to be representative of game data, e.g. a scene format.\n\n| | FlatBuffers (binary) | Protocol Buffers LITE | Rapid JSON | FlatBuffers (JSON) | pugixml | Raw structs |\n|--------------------------------------------------------|-----------------------|-----------------------|-----------------------|------------------------| ----------------------| ----------------------|\n| Decode + Traverse + Dealloc (1 million times, seconds) | 0.08 | 302 | 583 | 105 | 196 | 0.02 |\n| Decode / Traverse / Dealloc (breakdown) | 0 / 0.08 / 0 | 220 / 0.15 / 81 | 294 / 0.9 / 287 | 70 / 0.08 / 35 | 41 / 3.9 / 150 | 0 / 0.02 / 0 |\n| Encode (1 million times, seconds) | 3.2 | 185 | 650 | 169 | 273 | 0.15 |\n| Wire format size (normal / zlib, bytes) | 344 / 220 | 228 / 174 | 1475 / 322 | 1029 / 298 | 1137 / 341 | 312 / 187 |\n| Memory needed to store decoded wire (bytes / blocks) | 0 / 0 | 760 / 20 | 65689 / 4 | 328 / 1 | 34194 / 3 | 0 / 0 |\n| Transient memory allocated during decode (KB) | 0 | 1 | 131 | 4 | 34 | 0 |\n| Generated source code size (KB) | 4 | 61 | 0 | 4 | 0 | 0 |\n| Field access in handwritten traversal code | typed accessors | typed accessors | manual error checking | typed accessors | manual error checking | typed but no safety |\n| Library source code (KB) | 15 | some subset of 3800 | 87 | 43 | 327 | 0 |\n\n### Some other serialization systems we compared against but did not benchmark (yet), in rough order of applicability:\n\n- Cap'n'Proto promises to reduce Protocol Buffers much like FlatBuffers does,\n though with a more complicated binary encoding and less flexibility (no\n optional fields to allow deprecating fields or serializing with missing\n fields for which defaults exist).\n It currently also isn't fully cross-platform portable (lack of VS support).\n- msgpack: has very minimal forwards/backwards compatibility support when used\n with the typed C++ interface. Also lacks VS2010 support.\n- Thrift: very similar to Protocol Buffers, but appears to be less efficient,\n and have more dependencies.\n- YAML: a superset of JSON and otherwise very similar. Used by e.g. Unity.\n- C# comes with built-in serialization functionality, as used by Unity also.\n Being tied to the language, and having no automatic versioning support\n limits its applicability.\n- Project Anarchy (the free mobile engine by Havok) comes with a serialization\n system, that however does no automatic versioning (have to code around new\n fields manually), is very much tied to the rest of the engine, and works\n without a schema to generate code (tied to your C++ class definition).\n\n### Code for benchmarks\n\nCode for these benchmarks sits in `benchmarks/` in git branch `benchmarks`.\nIt sits in its own branch because it has submodule dependencies that the main\nproject doesn't need, and the code standards do not meet those of the main\nproject. Please read `benchmarks/cpp/README.txt` before working with the code.\n\n
\n" }, { "path": "docs/source/building.md", "content": "# Building\n\n## Building with CMake\n\nThe distribution main build system is configured by\n[`cmake`](https://www.cmake.org) which allows you to build the project for any\nplatform.\n\n### Configuration\n\nUse `cmake` to configure a project based on your environment and platform.\n\n=== \"Unix\"\n\n ```sh\n cmake -G \"Unix Makefiles\" -DCMAKE_BUILD_TYPE=Release\n ```\n\nTo use `clang` instead of `gcc` you may need to set prepend some environment\nvariables e.g. `CC=/usr/bin/clang CXX=/usr/bin/clang++ cmake -G \"Unix\nMakeFiles\"`\n\n=== \"Windows\"\n\n ```sh\n cmake -G \"Visual Studio 17 2022\" -DCMAKE_BUILD_TYPE=Release\n ```\n\n=== \"MacOS\"\n\n ```sh\n cmake -G \"Xcode\" -DCMAKE_BUILD_TYPE=Release\n ```\n\n#### Strict Mode\n\nBy default, `cmake` will configure targets to **not** build with strict warnings\non (e.g. `-Werror` or `/WX`). This may cause into issues when submitting code\nchanges since our CI requires the code to compile in strict mode.\n\nTo enable the extra warnings, turn on strict mode with the\n`FLATBUFFERS_STRICT_MODE` cmake option.\n\n```cmake\ncmake -DFLATBUFFERS_STRICT_MODE=ON\n```\n\n\n### Building\n\nOnce the project files are generated, build as normal for your platform.\n\n=== \"Unix\"\n\n ```sh\n make -j\n ```\n\n=== \"Windows\"\n\n ```sh\n msbuild.exe FlatBuffers.sln\n ```\n\n=== \"MacOS\"\n\n ```sh\n xcodebuild -toolchain clang -configuration Release\n ```\n\n\n\n\n\n\n## Building with Bazel\n\nYou can use [Bazelisk](https://github.com/bazelbuild/bazelisk) to manage your Bazel environment.\nFor Swift support, you also need Clang and [Swift SDK](https://download.swift.org/).\n\n```sh\ncurl -sL --fail https://github.com/bazelbuild/bazelisk/releases/download/v1.25.0/bazelisk-linux-amd64 -o bazelisk && chmod +x bazelisk\nsudo apt install -y clang\nSWIFT_VERSION=\"6.0.3\"\ncurl -L https://download.swift.org/swift-${SWIFT_VERSION}-release/debian12/swift-${SWIFT_VERSION}-RELEASE/swift-${SWIFT_VERSION}-RELEASE-debian12.tar.gz | tar xz\nCC=clang PATH=$PATH:$(pwd)/swift-${SWIFT_VERSION}-RELEASE-debian12/usr/bin bazel build //...\nCC=clang PATH=$PATH:$(pwd)/swift-${SWIFT_VERSION}-RELEASE-debian12/usr/bin bazel test //...\n```\n\nIf you are unsure which versions to use, check our CI config at `.bazelci/presubmit.yml`.\n\n## Building with Conan\n\nYou can download and install flatbuffers using the [Conan](https://conan.io/) dependency manager:\n\n conan install --requires=\"flatbuffers/[*]\" --build=missing\n\nThe flatbuffers package in Conan Center is maintained by\n[ConanCenterIndex](https://github.com/conan-io/conan-center-index) community.\nIf the version is out of date or the package does not work,\nplease create an issue or pull request on the [Conan Center Index repository](https://github.com/conan-io/conan-center-index).\n\n## Building with VCPKG\n\nYou can download and install flatbuffers using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager:\n\n git clone https://github.com/Microsoft/vcpkg.git\n cd vcpkg\n ./bootstrap-vcpkg.sh\n ./vcpkg integrate install\n ./vcpkg install flatbuffers\n\nThe flatbuffers port in vcpkg is kept up to date by Microsoft team members and community contributors.\nIf the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.\n\n\n\n## Building for Android\n\nThere is a `flatbuffers/android` directory that contains all you need to build\nthe test executable on android (use the included `build_apk.sh` script, or use\n`ndk_build` / `adb` etc. as usual). Upon running, it will output to the log\nif tests succeeded or not.\n\nYou may also run an android sample from inside the `flatbuffers/samples`, by\nrunning the `android_sample.sh` script. Optionally, you may go to the\n`flatbuffers/samples/android` folder and build the sample with the\n`build_apk.sh` script or `ndk_build` / `adb` etc.\n\n## Using FlatBuffers in your own projects\n\nFor C++, there is usually no runtime to compile, as the code consists of a\nsingle header, `include/flatbuffers/flatbuffers.h`. You should add the\n`include` folder to your include paths. If you wish to be\nable to load schemas and/or parse text into binary buffers at runtime,\nyou additionally need the other headers in `include/flatbuffers`. You must\nalso compile/link `src/idl_parser.cpp` (and `src/idl_gen_text.cpp` if you\nalso want to be able convert binary to text).\n\nTo see how to include FlatBuffers in any of our supported languages, please\nview the [Tutorial](tutorial.md) and select your appropriate\nlanguage using the radio buttons.\n\n### Using in CMake-based projects\nIf you want to use FlatBuffers in a project which already uses CMake, then a more\nrobust and flexible approach is to build FlatBuffers as part of that project directly.\nThis is done by making the FlatBuffers source code available to the main build\nand adding it using CMake's `add_subdirectory()` command. This has the\nsignificant advantage that the same compiler and linker settings are used\nbetween FlatBuffers and the rest of your project, so issues associated with using\nincompatible libraries (eg debug/release), etc. are avoided. This is\nparticularly useful on Windows.\n\nSuppose you put FlatBuffers source code in directory `${FLATBUFFERS_SRC_DIR}`.\nTo build it as part of your project, add following code to your `CMakeLists.txt` file:\n```cmake\n# Add FlatBuffers directly to our build. This defines the `flatbuffers` target.\nadd_subdirectory(${FLATBUFFERS_SRC_DIR}\n ${CMAKE_CURRENT_BINARY_DIR}/flatbuffers-build\n EXCLUDE_FROM_ALL)\n\n# Now simply link against flatbuffers as needed to your already declared target.\n# The flatbuffers target carry header search path automatically if CMake > 2.8.11.\ntarget_link_libraries(own_project_target PRIVATE flatbuffers)\n```\nWhen build your project the `flatbuffers` library will be compiled and linked\nto a target as part of your project.\n\n#### Override default depth limit of nested objects\nTo override [the depth limit of recursion](languages/cpp.md),\nadd this directive:\n```cmake\nset(FLATBUFFERS_MAX_PARSING_DEPTH 16)\n```\nto `CMakeLists.txt` file before `add_subdirectory(${FLATBUFFERS_SRC_DIR})` line.\n\n## Downloading binaries\nYou can download the binaries from the\n[GitHub release page](https://github.com/google/flatbuffers/releases).\n\nWe generate [SLSA3 signatures](http://slsa.dev) using the OpenSSF's [slsa-framework/slsa-github-generator](https://github.com/slsa-framework/slsa-github-generator). To verify the binaries:\n1. Install the verification tool from [slsa-framework/slsa-verifier#installation](https://github.com/slsa-framework/slsa-verifier#installation)\n1. Download the file named `attestation.intoto.jsonl` from the GitHub release\n1. Run:\n```shell\n$ slsa-verifier -artifact-path -provenance attestation.intoto.jsonl -source github.com/google/flatbuffers -tag \n PASSED: Verified SLSA provenance\n```\n" }, { "path": "docs/source/contributing.md", "content": "# Contributing\n\nWe encourage community contributions to FlatBuffers through pull requests at the\nmain\n[http://github.com/google/flatbuffers](http://github.com/google/flatbuffers)\nrepository.\n\n!!! note\n\n The FlatBuffers project is not staffed by any full time Google employee, and\n is managed by a small team of 20%ers. So response time and expertise vary.\n\n## Before you contribute\n\nBefore we can use your contributions, you __must__ sign one of the following license agreements. The agreements are self-served at the following links.\n\nOur code review process will automatically check if you have signed the CLA, so\ndon't fret. Though it may be prudent to check before spending a lot of time on\ncontribution.\n\n### Individual Contributions\n\nFor individuals, the [Google Individual\nContributor License Agreement\n(CLA)](https://cla.developers.google.com/about/google-individual?csw=1) which is\nself served at the link. The CLA is required since you own the copyright to your\nchanges, even after your contribution becomes part of our codebase, so we need\nyour permission to use and distribute your code.\n\n### Corporate Contributions\n\nContributions made by corporations are covered by the [Google Software Grant and\nCorporate Contributor License\nAgreement](https://cla.developers.google.com/about/google-corporate).\n\n## Code Reviews\n\nAll submissions require a code review via Github Pull Requests.\n\n1. Please adhere to the [Google Style Guide](https://google.github.io/styleguide/cppguide.html) for the language(s) you are submitting in.\n2. Keep PRs small and focused. Its good practice and makes it more likely your PR will be approved.\n3. Please add tests if possible.\n4. Include descriptive commit messages and context to the change/issues fixed.\n\n## Documentation\n\nFlatBuffers uses [MkDocs](https://www.mkdocs.org/) to generate the static\ndocumentation pages served at\n[https://flatbuffers.dev](https://flatbuffers.dev). Specifically, we use the\n[Material for MkDocs](https://squidfunk.github.io/mkdocs-material/) framework.\n\nThe documentation source is contained in the main repo under the\n[docs/](https://github.com/google/flatbuffers/tree/master/docs) directory. This\n[automatically](https://github.com/google/flatbuffers/blob/46cc3d6432da17cca7694777dcce12e49dd48387/.github/workflows/docs.yml#L6-L11) get built and published when the commit is made.\n\n### Local Development\n\nWe encourage contributors to keep the documentation up-to-date as well, and it\nis easy to with `MkDocs` local building and serving tools.\n\nFirst install `mkdocs-material` (see\n[Installation](https://squidfunk.github.io/mkdocs-material/getting-started/) for\nother ways)\n\n```\npip install mkdocs-material\npip install mkdocs-redirects\n```\n\nThen, in the `root` directory of flatbuffers, run\n\n```\nmkdocs serve -f docs/mkdocs.yml\n```\n\nThis will continually watch the repo for changes to the documentation and serve\nthe rendered pages locally.\n\nSubmit your documentation changes with your code changes and they will\nautomatically get published when your code is submitted.\n" }, { "path": "docs/source/evolution.md", "content": "# Evolution\n\nFlatBuffers enables the [schema](schema.md) to evolve over time while still\nmaintaining forwards and backwards compatibility with old flatbuffers.\n\nSome rules must be followed to ensure the evolution of a schema is valid.\n\n## Rules\n\nAdding new tables, vectors, structs to the schema is always allowed. Its only\nwhen you add a new field to a [`table`](schema.md#tables) that certain rules\nmust be followed.\n\n### Addition\n\n**New fields MUST be added to the end of the table definition.**\n\nThis allows older data to still be read correctly (giving you the default value\nof the added field if accessed).\n\nOlder code will simply ignore the new field in the flatbuffer.\n\nYou can ignore this rule if you use the `id` attribute on all the fields of a\ntable.\n\n### Removal\n\n**You MUST not remove a field from the schema, even if you don't use it\nanymore.** You simply stop writing them to the buffer.\n\nIts encouraged to mark the field deprecated by adding the `deprecated`\nattribute. This will skip the generation of accessors and setters in the code,\nto enforce the field not to be used any more.\n\n### Name Changes\n\nIts generally OK to change the name of tables and fields, as these are not\nserialized to the buffer. It may break code that would have to be refactored\nwith the updated name.\n\n## Examples\n\nThe following examples uses a base schema and attempts to evolve it a few times.\nThe versions are tracked by `V1`, `V2`, etc.. and `CodeV1` means code compiled\nagainst the `V1` schema.\n\n### Table Evolution\n\nLets start with a simple table `T` with two fields.\n\n```c++ title=\"Schema V1\"\ntable T {\n a:int;\n b:int;\n}\n```\n\n=== \"Well Evolved\"\n\n First lets extend the table with a new field.\n\n ```c++ title=\"Schema V2\"\n table T {\n a:int;\n b:int;\n c:int;\n }\n ```\n\n This is OK. `CodeV1` reading `V2` data will simply ignore the presence of the\n new field `c`. `CodeV2` reading `V1` data will get a default value (0) when\n reading `c`.\n\n ```c++ title=\"Schema V3\"\n table T {\n a:int (deprecated);\n b:int;\n c:int;\n }\n ```\n\n This is OK, removing field `a` via deprecation. `CodeV1`, `CodeV2` and `CodeV3`\n reading `V3` data will now always get the default value of `a`, since it is not\n present. `CodeV3` cannot write `a` anymore. `CodeV3` reading old data (`V1` or\n `V2`) will not be able to access the field anymore, since no generated accessors\n are omitted.\n\n=== \"Improper Addition\"\n\n Add a new field, but this time at the beginning.\n\n ```c++ title=\"Schema V2\"\n table T {\n c:int;\n a:int;\n b:int;\n }\n ```\n\n This is NOT OK, as it makes `V2` incompatible. `CodeV1` reading `V2` data\n will access `a` but will read `c` data.\n\n `CodeV2` reading `V1` data will access `c` but will read `a` data.\n\n=== \"Improper Deletion\"\n\n Remove a field from the schema.\n\n ```c++ title=\"Schema V2\"\n table T {\n b:int;\n }\n ```\n\n This is NOT OK. `CodeV1` reading `V2` data will access `a` but read `b` data.\n\n `CodeV2` reading `V1` data will access `b` but will read `a` data.\n\n=== \"Proper Reordering\"\n\n Lets add a new field to the beginning, but use `id` attributes.\n\n ```c++ title=\"Schema V2\"\n table T {\n c:int (id: 2);\n a:int (id: 0);\n b:int (id: 1);\n }\n ```\n\n This is OK. This adds the a new field in the beginning, but because all the\n `id` attributes were added, it is OK.\n\n=== \"Changing Types\"\n\n Let change the types of the fields.\n\n ```c++ title=\"Schema V2\"\n table T {\n a:uint;\n b:uint;\n }\n ```\n\n This is MAYBE OK, and only in the case where the type change is the same\n width. This is tricky if the `V1` data contained any negative numbers. So\n this should be done with care.\n\n=== \"Changing Defaults\"\n\n Lets change the default values of the existing fields.\n\n ```c++ title=\"Schema V2\"\n table T {\n a:int = 1;\n b:int = 2;\n }\n ```\n\n This is NOT OK. Any `V1` data that did not have a value written to the\n buffer relied on generated code to provide the default value.\n\n There MAY be cases where this is OK, if you control all the producers and\n consumers, and you can update them in tandem.\n\n=== \"Renaming Fields\"\n\n Lets change the name of the fields\n\n ```c++ title=\"Schema V2\"\n table T {\n aa:int;\n bb:int;\n }\n ```\n\n This is generally OK. You've renamed fields will break all code and JSON\n files that use this schema, but you can refactor those without affecting the\n binary data, since the binary only address fields by id and offset, not by\n names.\n\n### Union Evolution\n\nLets start with a simple union `U` with two members.\n\n```c++ title=\"Schema V1\"\nunion U {\n A,\n B\n}\n```\n\n=== \"Well Evolved\"\n\n Lets add a another variant to the end.\n\n ```c++ title=\"Schema V2\"\n union U {\n A,\n B,\n another_a: A\n }\n ```\n\n This is OK. `CodeV1` will not recognize the `another_a`.\n\n=== \"Improper Evolved\"\n\n Lets add a another variant to the middle.\n\n ```c++ title=\"Schema V2\"\n union U {\n A,\n another_a: A,\n B\n }\n ```\n\n This is NOT OK. `CodeV1` reading `V2` data will interpret `B` as `another_a`.\n `CodeV2` reading `V1` data will interpret `another_a` as `B`.\n\n=== \"Evolved With Discriminant\"\n\n Lets add a another variant to the middle, this time adding a union \"discriminant\".\n\n ```c++ title=\"Schema V2\"\n union U {\n A = 1,\n another_a: A = 3,\n B = 2\n }\n ```\n\n This is OK. Its like you added it to the end, but using the discriminant\n value to physically place it elsewhere in the union.\n\n## Version Control\n\nFlatBuffers relies on new field declarations being added at the end, and earlier\ndeclarations to not be removed, but be marked deprecated when needed. We think\nthis is an improvement over the manual number assignment that happens in\nProtocol Buffers (and which is still an option using the `id` attribute\nmentioned above).\n\nOne place where this is possibly problematic however is source control. If user\n`A` adds a field, generates new binary data with this new schema, then tries to\ncommit both to source control after user `B` already committed a new field also,\nand just auto-merges the schema, the binary files are now invalid compared to\nthe new schema.\n\nThe solution of course is that you should not be generating binary data before\nyour schema changes have been committed, ensuring consistency with the rest of\nthe world. If this is not practical for you, use explicit field `id`s, which\nshould always generate a merge conflict if two people try to allocate the same\nid.\n\n## Checking Conformity\n\nTo check that schema are properly evolved, the [`flatc`](flatc.md) compiler has\na [option](flatc.md#additional-options) to do just that:\n\n```sh\n--conform FILE\n```\n\nWhere `FILE` is the base schema the rest of the input schemas must evolve from.\nIt returns `0` if they are properly evolved, otherwise returns a non-zero value\nand provides errors on the reason why the schema are not properly evolved.\n\nAs an example, the following checks if `schema_v2.fbs` is properly evolved from\n`schema_v1.fbs`.\n\n```sh\nflatc --conform schema_v1.fbs schema_v2.fbs\n```\n\n" }, { "path": "docs/source/flatc.md", "content": "# FlatBuffers Compiler (`flatc`)\n\nThe main compiler for FlatBuffers is called `flatc` and is used to convert\nschema definitions into generated code files for a variety of languages.\n\nAfter [building](building.md) `flatc`, it is used as follows:\n\n```sh\nflatc [ GENERATOR_OPTIONS ] [ -o PATH ] [- I PATH ]\n FILES...\n [ -- BINARY_FILES... ]\n```\n\n* The `GENERATOR_OPTIONS` specify the language(s) to compile code for as well as\nvarious features to enable/disable.\n\n* The `-o PATH` specifies the path where the generated files are placed. It\ndefaults to the current path if not specified.\n\n* The `-I PATH` specifies the paths where included schema files are located. It\n defaults to the current path if not specified.\n\n## Input Files\n\n`FILES...` specifies one or more schema or data files to process. They are\nprocessed in the order provided.\n\n### Schema Files\n\nFor schema files, language specifiers indicate what languages to generate code\nfor.\n\n * `--cpp`: C++\n * `--java`: Java\n * `--kotlin`: Kotlin\n * `--csharp`: C#\n * `--go`: Golang\n * `--python`: Python\n * `--js`: JavaScript\n * `--ts`: TypeScript\n * `--php`: PHP\n * `--dart`: Dart\n * `--lua`: Lua\n * `--lobster`: Lobster\n * `--rust`: Rust\n * `--swift`: Swift\n * `--nim`: Nim\n\nAdditionally, adding:\n\n * `--grpc` Will generate RPC stub code for gRPC (not available in all\n languages)\n\n### Data Files\n\nIf `FILES...` contain data files, they can be exported to either a binary or\nJSON representation.\n\n* `--binary`, `-b`: Generate a binary file containing a serialized flatbuffer.\n* `--json`, `-j`: Generate JSON file from a serialized flatbuffer.\n\nBoth options require the corresponding schema file to be included first in the\nlist of `FILES...`.\n\n=== \"To Binary\"\n\n To serialize the JSON data in `mydata.json` using the schema `myschema.fbs`:\n\n ```sh\n flatc --binary myschema.fbs mydata.json\n ```\n\n This will generate a `mydata_wire.bin` file containing the serialized\n flatbuffer data.\n\n=== \"To JSON\"\n\n To convert the serialized binary flatbuffer `mydata.bin` using the schema\n `myschema.fbs` to JSON:\n\n ```sh\n flatc --json myschema.fbs -- mydata.bin\n ```\n\n This will generate a `mydata.json` file. If there is no\n [`file_identifier`](schema.md/#file-identification-and-extension) defined\n for this schema, you will need to use the `--raw-binary` option.\n\n### Additional options\n\n- `-o PATH` : Output all generated files to PATH (either absolute, or\n relative to the current directory). If omitted, PATH will be the\n current directory. PATH should end in your systems path separator,\n e.g. `/` or `\\`.\n\n- `-I PATH` : when encountering `include` statements, attempt to load the\n files from this path. Paths will be tried in the order given, and if all\n fail (or none are specified) it will try to load relative to the path of\n the schema file being parsed.\n\n- `-M` : Print make rules for generated files.\n\n- `--strict-json` : Require & generate strict JSON (field names are enclosed\n in quotes, no trailing commas in tables/vectors). By default, no quotes are\n required/generated, and trailing commas are allowed.\n\n- `--allow-non-utf8` : Pass non-UTF-8 input through parser and emit nonstandard\n \\x escapes in JSON. (Default is to raise parse error on non-UTF-8 input.)\n\n- `--natural-utf8` : Output strings with UTF-8 as human-readable strings.\n By default, UTF-8 characters are printed as \\uXXXX escapes.\"\n\n- `--defaults-json` : Output fields whose value is equal to the default value\n when writing JSON text.\n\n- `--no-prefix` : Don't prefix enum values in generated C++ by their enum\n type.\n\n- `--scoped-enums` : Use C++11 style scoped and strongly typed enums in\n generated C++. This also implies `--no-prefix`.\n\n- `--no-emit-min-max-enum-values` : Disable generation of MIN and MAX\n enumerated values for scoped enums and prefixed enums.\n\n- `--gen-includes` : (deprecated), this is the default behavior.\n If the original behavior is required (no include\n\t statements) use `--no-includes.`\n\n- `--no-includes` : Don't generate include statements for included schemas the\n generated file depends on (C++ / Python).\n\n- `--gen-mutable` : Generate additional non-const accessors for mutating\n FlatBuffers in-place.\n\n- `--gen-onefile` : Generate a single output file for C#, Go, Java, Kotlin and Python.\n\n- `--gen-name-strings` : Generate type name functions for C++.\n\n- `--gen-object-api` : Generate an additional object-based API. This API is\n more convenient for object construction and mutation than the base API,\n at the cost of efficiency (object allocation). Recommended only to be used\n if other options are insufficient.\n\n- `--gen-compare` : Generate operator== for object-based API types.\n\n- `--gen-nullable` : Add Clang \\_Nullable for C++ pointer. or @Nullable for Java.\n\n- `--gen-generated` : Add @Generated annotation for Java.\n\n- `--gen-jvmstatic` : Add @JvmStatic annotation for Kotlin methods\n in companion object for interop from Java to Kotlin.\n\n- `--gen-all` : Generate not just code for the current schema files, but\n for all files it includes as well. If the language uses a single file for\n output (by default the case for C++ and JS), all code will end up in\n this one file.\n\n- `--cpp-include` : Adds an #include in generated file\n\n- `--cpp-ptr-type T` : Set object API pointer type (default std::unique_ptr)\n\n- `--cpp-str-type T` : Set object API string type (default std::string)\n T::c_str(), T::length() and T::empty() must be supported.\n The custom type also needs to be constructible from std::string (see the\n\t--cpp-str-flex-ctor option to change this behavior).\n\n- `--cpp-str-flex-ctor` : Don't construct custom string types by passing\n std::string from Flatbuffers, but (char* + length). This allows efficient\n\tconstruction of custom string types, including zero-copy construction.\n\n- `--no-cpp-direct-copy` : Don't generate direct copy methods for C++\n object-based API.\n\n- `--cpp-std CPP_STD` : Generate a C++ code using features of selected C++ standard.\n Supported `CPP_STD` values:\n * `c++0x` - generate code compatible with old compilers (VS2010),\n * `c++11` - use C++11 code generator (default),\n * `c++17` - use C++17 features in generated code (experimental).\n\n- `--object-prefix` : Customise class prefix for C++ object-based API.\n\n- `--object-suffix` : Customise class suffix for C++ object-based API.\n\n- `--go-namespace` : Generate the overrided namespace in Golang.\n\n- `--go-import` : Generate the overrided import for flatbuffers in Golang.\n (default is \"github.com/google/flatbuffers/go\").\n\n- `--raw-binary` : Allow binaries without a file_indentifier to be read.\n This may crash flatc given a mismatched schema.\n\n- `--size-prefixed` : Input binaries are size prefixed buffers.\n\n- `--proto`: Expect input files to be .proto files (protocol buffers).\n Output the corresponding .fbs file.\n Currently supports: `package`, `message`, `enum`, nested declarations,\n `import` (use `-I` for paths), `extend`, `oneof`, `group`.\n Does not support, but will skip without error: `option`, `service`,\n `extensions`, and most everything else.\n\n- `--oneof-union` : Translate .proto oneofs to flatbuffer unions.\n\n- `--grpc` : Generate GRPC interfaces for the specified languages.\n\n- `--schema`: Serialize schemas instead of JSON (use with -b). This will\n output a binary version of the specified schema that itself corresponds\n to the reflection/reflection.fbs schema. Loading this binary file is the\n basis for reflection functionality.\n\n- `--bfbs-comments`: Add doc comments to the binary schema files.\n\n- `--conform FILE` : Specify a schema the following schemas should be\n an evolution of. Gives errors if not. Useful to check if schema\n modifications don't break schema evolution rules.\n\n- `--conform-includes PATH` : Include path for the schema given with\n `--conform PATH`.\n\n- `--filename-suffix SUFFIX` : The suffix appended to the generated\n file names. Default is '\\_generated'.\n\n- `--filename-ext EXTENSION` : The extension appended to the generated\n file names. Default is language-specific (e.g. \"h\" for C++). This\n should not be used when multiple languages are specified.\n\n- `--include-prefix PATH` : Prefix this path to any generated include\n statements.\n\n- `--keep-prefix` : Keep original prefix of schema include statement.\n\n- `--reflect-types` : Add minimal type reflection to code generation.\n\n- `--reflect-names` : Add minimal type/name reflection.\n\n- `--root-type T` : Select or override the default root_type.\n\n- `--require-explicit-ids` : When parsing schemas, require explicit ids (id: x).\n\n- `--force-defaults` : Emit default values in binary output from JSON.\n\n- `--force-empty` : When serializing from object API representation, force\n strings and vectors to empty rather than null.\n\n- `--force-empty-vectors` : When serializing from object API representation, force\n vectors to empty rather than null.\n\n- `--flexbuffers` : Used with \"binary\" and \"json\" options, it generates\n data using schema-less FlexBuffers.\n\n- `--no-warnings` : Inhibit all warning messages.\n\n- `--cs-global-alias` : Prepend `global::` to all user generated csharp classes and structs.\n\n- `--json-nested-bytes` : Allow a nested_flatbuffer field to be parsed as a\n vector of bytes in JSON, which is unsafe unless checked by a verifier\n afterwards.\n\n- `--python-no-type-prefix-suffix` : Skip emission of Python functions that are prefixed\n with typenames\n\n- `--python-typing` : Generate Python type annotations\n\n- `--python-decode-obj-api-strings` : Decode bytes automaticaly with utf-8\n\n- `--file-names-only` : Prints out files which would be generated by this command, one per\n line, to `stdout`. No actual files are generated. This is useful for various CI checks.\n\nAdditional gRPC options:\n\n- `--grpc-filename-suffix`: `[C++]` An optional suffix for the generated\n files' names. For example, compiling gRPC for C++ with\n `--grpc-filename-suffix=.fbs` will generate `{name}.fbs.h` and\n `{name}.fbs.cc` files.\n\n- `--grpc-additional-header`: `[C++]` Additional headers to include in the\n generated files.\n\n- `--grpc-search-path`: `[C++]` An optional prefix for the gRPC runtime path.\n For example, compiling gRPC for C++ with `--grpc-search-path=some/path` will\n generate the following includes:\n\n ```cpp\n #include \"some/path/grpcpp/impl/codegen/async_stream.h\"\n #include \"some/path/grpcpp/impl/codegen/async_unary_call.h\"\n #include \"some/path/grpcpp/impl/codegen/method_handler.h\"\n ...\n ```\n\n- `--grpc-use-system-headers`: `[C++]` Whether to generate `#include
`\n instead of `#include \"header.h\"` for all headers when compiling gRPC for\n C++. For example, compiling gRPC for C++ with `--grpc-use-system-headers`\n will generate the following includes:\n\n ```cpp\n #include \n #include \n #include \n ...\n ```\n\n NOTE: This option can be negated with `--no-grpc-use-system-headers`.\n\n- `--grpc-python-typed-handlers`: `[Python]` Whether to generate the typed\n handlers that use the generated Python classes instead of raw bytes for\n requests/responses.\n\nNOTE: short-form options for generators are deprecated, use the long form\nwhenever possible.\n\n" }, { "path": "docs/source/flexbuffers.md", "content": "FlexBuffers {#flexbuffers}\n==========\n\nFlatBuffers was designed around schemas, because when you want maximum\nperformance and data consistency, strong typing is helpful.\n\nThere are however times when you want to store data that doesn't fit a\nschema, because you can't know ahead of time what all needs to be stored.\n\nFor this, FlatBuffers has a dedicated format, called FlexBuffers.\nThis is a binary format that can be used in conjunction\nwith FlatBuffers (by storing a part of a buffer in FlexBuffers\nformat), or also as its own independent serialization format.\n\nWhile it loses the strong typing, you retain the most unique advantage\nFlatBuffers has over other serialization formats (schema-based or not):\nFlexBuffers can also be accessed without parsing / copying / object allocation.\nThis is a huge win in efficiency / memory friendly-ness, and allows unique\nuse cases such as mmap-ing large amounts of free-form data.\n\nFlexBuffers' design and implementation allows for a very compact encoding,\ncombining automatic pooling of strings with automatic sizing of containers to\ntheir smallest possible representation (8/16/32/64 bits). Many values and\noffsets can be encoded in just 8 bits. While a schema-less representation is\nusually more bulky because of the need to be self-descriptive, FlexBuffers\ngenerates smaller binaries for many cases than regular FlatBuffers.\n\nFlexBuffers is still slower than regular FlatBuffers though, so we recommend to\nonly use it if you need it.\n\n\n# Usage in C++\n\nInclude the header `flexbuffers.h`, which in turn depends on `flatbuffers.h`\nand `util.h`.\n\nTo create a buffer:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}\nflexbuffers::Builder fbb;\nfbb.Int(13);\nfbb.Finish();\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nYou create any value, followed by `Finish`. Unlike FlatBuffers which requires\nthe root value to be a table, here any value can be the root, including a lonely\nint value.\n\nYou can now access the `std::vector` that contains the encoded value\nas `fbb.GetBuffer()`. Write it, send it, or store it in a parent FlatBuffer. In\nthis case, the buffer is just 3 bytes in size.\n\nTo read this value back, you could just say:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}\nauto root = flexbuffers::GetRoot(my_buffer);\nint64_t i = root.AsInt64();\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nFlexBuffers stores ints only as big as needed, so it doesn't differentiate\nbetween different sizes of ints. You can ask for the 64 bit version,\nregardless of what you put in. In fact, since you demand to read the root\nas an int, if you supply a buffer that actually contains a float, or a\nstring with numbers in it, it will convert it for you on the fly as well,\nor return 0 if it can't. If instead you actually want to know what is inside\nthe buffer before you access it, you can call `root.GetType()` or `root.IsInt()`\netc.\n\nHere's a slightly more complex value you could write instead of `fbb.Int` above:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}\nfbb.Map([&]() {\n fbb.Vector(\"vec\", [&]() {\n fbb.Int(-100);\n fbb.String(\"Fred\");\n fbb.IndirectFloat(4.0f);\n });\n fbb.UInt(\"foo\", 100);\n});\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThis stores the equivalent of the JSON value\n`{ vec: [ -100, \"Fred\", 4.0 ], foo: 100 }`. The root is a dictionary that has\njust two key-value pairs, with keys `vec` and `foo`. Unlike FlatBuffers, it\nactually has to store these keys in the buffer (which it does only once if\nyou store multiple such objects, by pooling key values), but also unlike\nFlatBuffers it has no restriction on the keys (fields) that you use.\n\nThe map constructor uses a C++11 Lambda to group its children, but you can\nalso use more conventional start/end calls if you prefer.\n\nThe first value in the map is a vector. You'll notice that unlike FlatBuffers,\nyou can use mixed types. There is also a `TypedVector` variant that only\nallows a single type, and uses a bit less memory.\n\n`IndirectFloat` is an interesting feature that allows you to store values\nby offset rather than inline. Though that doesn't make any visible change\nto the user, the consequence is that large values (especially doubles or\n64 bit ints) that occur more than once can be shared (see ReuseValue).\nAnother use case is inside of vectors, where the largest element makes\nup the size of all elements (e.g. a single double forces all elements to\n64bit), so storing a lot of small integers together with a double is more efficient if the double is indirect.\n\nAccessing it:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}\nauto map = flexbuffers::GetRoot(my_buffer).AsMap();\nmap.size(); // 2\nauto vec = map[\"vec\"].AsVector();\nvec.size(); // 3\nvec[0].AsInt64(); // -100;\nvec[1].AsString().c_str(); // \"Fred\";\nvec[1].AsInt64(); // 0 (Number parsing failed).\nvec[2].AsDouble(); // 4.0\nvec[2].AsString().IsTheEmptyString(); // true (Wrong Type).\nvec[2].AsString().c_str(); // \"\" (This still works though).\nvec[2].ToString().c_str(); // \"4\" (Or have it converted).\nmap[\"foo\"].AsUInt8(); // 100\nmap[\"unknown\"].IsNull(); // true\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n\n# Usage in Java\n\nJava implementation follows the C++ one, closely.\n\nFor creating the equivalent of the same JSON `{ vec: [ -100, \"Fred\", 4.0 ], foo: 100 }`,\none could use the following code:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.java}\nFlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(512),\n\t\t FlexBuffersBuilder.BUILDER_FLAG_SHARE_KEYS_AND_STRINGS);\nint smap = builder.startMap();\nint svec = builder.startVector();\nbuilder.putInt(-100);\nbuilder.putString(\"Fred\");\nbuilder.putFloat(4.0);\nbuilder.endVector(\"vec\", svec, false, false);\nbuilder.putInt(\"foo\", 100);\nbuilder.endMap(null, smap);\nByteBuffer bb = builder.finish();\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nSimilarly, to read the data, just:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.java}\nFlexBuffers.Map map = FlexBuffers.getRoot(bb).asMap();\nmap.size(); // 2\nFlexBuffers.Vector vec = map.get(\"vec\").asVector();\nvec.size(); // 3\nvec.get(0).asLong(); // -100;\nvec.get(1).asString(); // \"Fred\";\nvec.get(1).asLong(); // 0 (Number parsing failed).\nvec.get(2).asFloat(); // 4.0\nvec.get(2).asString().isEmpty(); // true (Wrong Type).\nvec.get(2).asString(); // \"\" (This still works though).\nvec.get(2).toString(); // \"4.0\" (Or have it converted).\nmap.get(\"foo\").asUInt(); // 100\nmap.get(\"unknown\").isNull(); // true\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n\n# Binary encoding\n\nA description of how FlexBuffers are encoded is in the\n[internals](internals.md) document.\n\n\n# Nesting inside a FlatBuffer\n\nYou can mark a field as containing a FlexBuffer, e.g.\n\n a:[ubyte] (flexbuffer);\n\nA special accessor will be generated that allows you to access the root value\ndirectly, e.g. `a_flexbuffer_root().AsInt64()`.\n\n\n# Efficiency tips\n\n* Vectors generally are a lot more efficient than maps, so prefer them over maps\n when possible for small objects. Instead of a map with keys `x`, `y` and `z`,\n use a vector. Better yet, use a typed vector. Or even better, use a fixed\n size typed vector.\n* Maps are backwards compatible with vectors, and can be iterated as such.\n You can iterate either just the values (`map.Values()`), or in parallel with\n the keys vector (`map.Keys()`). If you intend\n to access most or all elements, this is faster than looking up each element\n by key, since that involves a binary search of the key vector.\n* When possible, don't mix values that require a big bit width (such as double)\n in a large vector of smaller values, since all elements will take on this\n width. Use `IndirectDouble` when this is a possibility. Note that\n integers automatically use the smallest width possible, i.e. if you ask\n to serialize an int64_t whose value is actually small, you will use less\n bits. Doubles are represented as floats whenever possible losslessly, but\n this is only possible for few values.\n Since nested vectors/maps are stored over offsets, they typically don't\n affect the vector width.\n* To store large arrays of byte data, use a blob. If you'd use a typed\n vector, the bit width of the size field may make it use more space than\n expected, and may not be compatible with `memcpy`.\n Similarly, large arrays of (u)int16_t may be better off stored as a\n binary blob if their size could exceed 64k elements.\n Construction and use are otherwise similar to strings.\n" }, { "path": "docs/source/grammar.md", "content": "## EBNF\n\n```ebnf\nschema = include* ( namespace_decl | type_decl | enum_decl | root_decl |\n file_extension_decl | file_identifier_decl |\n attribute_decl | rpc_decl | object )*\n\ninclude = `include` string_constant `;`\n\nnamespace_decl = `namespace` ident ( `.` ident )* `;`\n\nattribute_decl = `attribute` ident | `\"` ident `\"` `;`\n\ntype_decl = ( `table` | `struct` ) ident metadata `{` field_decl+ `}`\n\nenum_decl = ( `enum` ident `:` type | `union` ident ) metadata `{`\ncommasep( enumval_decl ) `}`\n\nroot_decl = `root_type` ident `;`\n\nfield_decl = ident `:` type [ `=` scalar ] metadata `;`\n\nrpc_decl = `rpc_service` ident `{` rpc_method+ `}`\n\nrpc_method = ident `(` ident `)` `:` ident metadata `;`\n\ntype = `bool` | `byte` | `ubyte` | `short` | `ushort` | `int` | `uint` |\n `float` | `long` | `ulong` | `double` | `int8` | `uint8` | `int16` |\n `uint16` | `int32` | `uint32`| `int64` | `uint64` | `float32` |\n `float64` | `string` | `[` type `]` | ident\n\nenumval_decl = ident [ `=` integer_constant ] metadata\n\nmetadata = [ `(` commasep( ident [ `:` single_value ] ) `)` ]\n\nscalar = boolean_constant | integer_constant | float_constant\n\nobject = `{` commasep( ident `:` value ) `}`\n\nsingle_value = scalar | string_constant\n\nvalue = single_value | object | `[` commasep( value ) `]`\n\ncommasep(x) = [ x ( `,` x )\\* ]\n\nfile_extension_decl = `file_extension` string_constant `;`\n\nfile_identifier_decl = `file_identifier` string_constant `;`\n\nstring_constant = `\\\".*?\\\"`\n\nident = `[a-zA-Z_][a-zA-Z0-9_]*`\n\n`[:digit:]` = `[0-9]`\n\n`[:xdigit:]` = `[0-9a-fA-F]`\n\ndec_integer_constant = `[-+]?[:digit:]+`\n\nhex_integer_constant = `[-+]?0[xX][:xdigit:]+`\n\ninteger_constant = dec_integer_constant | hex_integer_constant\n\ndec_float_constant = `[-+]?(([.][:digit:]+)|([:digit:]+[.][:digit:]*)|([:digit:]+))([eE][-+]?[:digit:]+)?`\n\nhex_float_constant = `[-+]?0[xX](([.][:xdigit:]+)|([:xdigit:]+[.][:xdigit:]*)|([:xdigit:]+))([pP][-+]?[:digit:]+)`\n\nspecial_float_constant = `[-+]?(nan|inf|infinity)`\n\nfloat_constant = dec_float_constant | hex_float_constant | special_float_constant\n\nboolean_constant = `true` | `false`\n```\n" }, { "path": "docs/source/index.md", "content": "# Overview\n\nFlatBuffers is an efficient cross platform serialization library for C++, C#, C,\nGo, Java, Kotlin, JavaScript, Lobster, Lua, TypeScript, PHP, Python, Rust and\nSwift. It was originally created at Google for game development and other\nperformance-critical applications.\n\nIt is available as Open Source on\n[GitHub](https://github.com/google/flatbuffers) under the Apache license v2.0.\n\n## Why Use FlatBuffers?\n\n
\n\n- :material-clock-fast:{ .lg .middle } **Access to serialized data without\n parsing/unpacking**\n\n ---\n Access the data directly without unpacking or parsing.\n\n- :material-memory:{ .lg .middle } **Memory Efficiency and Speed**\n\n ---\n The only memory needed to access your data is that of the buffer.\n No heap is required.\n\n- :material-compare-horizontal:{ .lg .middle } **Backwards and Forwards\n Compatibility**\n\n ---\n FlatBuffers enables the schema to evolve over time while still maintaining\n forwards and backwards compatibility with old flatbuffers.\n\n- :material-scale-off:{ .lg .middle } **Small Footprint**\n\n ---\n Minimal dependencies and small code footprint.\n\n
\n\n## Why not use...\n\n=== \"Protocol Buffers\"\n\n Protocol Buffers is indeed relatively similar to FlatBuffers, with the primary\n difference being that FlatBuffers does not need a parsing/unpacking step to a\n secondary representation before you can access data, often coupled with\n per-object memory allocation. The code is an order of magnitude bigger, too.\n\n=== \"JSON\"\n\n JSON is very readable (which is why we use it as our optional text format) and\n very convenient when used together with dynamically typed languages (such as\n JavaScript). When serializing data from statically typed languages, however,\n JSON not only has the obvious drawback of runtime inefficiency, but also forces\n you to write more code to access data (counterintuitively) due to its\n dynamic-typing serialization system. In this context, it is only a better choice\n for systems that have very little to no information ahead of time about what\n data needs to be stored.\n" }, { "path": "docs/source/intermediate_representation.md", "content": "# Flatbuffers Intermediate Representation {#intermediate_representation}\n\nWe use [reflection.fbs](https://github.com/google/flatbuffers/blob/master/reflection/reflection.fbs)\nas our intermediate representation. `flatc` parses `.fbs` files, checks them for\nerrors and stores the resulting data in this IR, outputting `.bfbs` files.\nSince this IR is a Flatbuffer, you can load and use it at runtime for runtime\nreflection purposes.\n\nThere are some quirks:\n- Tables and Structs are serialized as `Object`s.\n- Unions and Enums are serialized as `Enum`s.\n- It is the responsibility of the code generator to check the `advanced_features`\n field of `Schema`. These mark the presence of new, backwards incompatible,\n schema features. Code generators must error if generating a schema with\n unrecognized advanced features.\n- Filenames are relative to a \"project root\" denoted by \"//\" in the path. This\n may be specified in flatc with `--bfbs-filenames=$PROJECT_ROOT`, or it will be\n inferred to be the directory containing the first provided schema file.\n\n\n## Invocation\nYou can invoke it like so\n```{.sh}\nflatc -b --schema ${your_fbs_files}\n```\nThis generates `.bfbs` (binary flatbuffer schema) files.\n\nSome information is not included by default. See the `--bfbs-filenames` and\n`--bfbs-comments` flags. These may be necessary for code-generators, so they can\nadd documentation and maybe name generated files (depending on the generator).\n\n\nTODO(cneo): Flags to output bfbs as flexbuffers or json.\n\nTODO(cneo): Tutorial for building a flatc plugin.\n" }, { "path": "docs/source/internals.md", "content": "FlatBuffer Internals {#flatbuffers_internals}\n====================\n\nThis section is entirely optional for the use of FlatBuffers. In normal\nusage, you should never need the information contained herein. If you're\ninterested however, it should give you more of an appreciation of why\nFlatBuffers is both efficient and convenient.\n\n### Format components\n\nA FlatBuffer is a binary file and in-memory format consisting mostly of\nscalars of various sizes, all aligned to their own size. Each scalar is\nalso always represented in little-endian format, as this corresponds to\nall commonly used CPUs today. FlatBuffers will also work on big-endian\nmachines, but will be slightly slower because of additional\nbyte-swap intrinsics.\n\nIt is assumed that the following conditions are met, to ensure\ncross-platform interoperability:\n- The binary `IEEE-754` format is used for floating-point numbers.\n- The `two's complemented` representation is used for signed integers.\n- The endianness is the same for floating-point numbers as for integers.\n\nOn purpose, the format leaves a lot of details about where exactly\nthings live in memory undefined, e.g. fields in a table can have any\norder, and objects to some extent can be stored in many orders. This is\nbecause the format doesn't need this information to be efficient, and it\nleaves room for optimization and extension (for example, fields can be\npacked in a way that is most compact). Instead, the format is defined in\nterms of offsets and adjacency only. This may mean two different\nimplementations may produce different binaries given the same input\nvalues, and this is perfectly valid.\n\n### Format identification\n\nThe format also doesn't contain information for format identification\nand versioning, which is also by design. FlatBuffers is a statically typed\nsystem, meaning the user of a buffer needs to know what kind of buffer\nit is. FlatBuffers can of course be wrapped inside other containers\nwhere needed, or you can use its union feature to dynamically identify\nmultiple possible sub-objects stored. Additionally, it can be used\ntogether with the schema parser if full reflective capabilities are\ndesired.\n\nVersioning is something that is intrinsically part of the format (the\noptionality / extensibility of fields), so the format itself does not\nneed a version number (it's a meta-format, in a sense). We're hoping\nthat this format can accommodate all data needed. If format breaking\nchanges are ever necessary, it would become a new kind of format rather\nthan just a variation.\n\n### Offsets\n\nThe most important and generic offset type (see `flatbuffers.h`) is\n`uoffset_t`, which is currently always a `uint32_t`, and is used to\nrefer to all tables/unions/strings/vectors (these are never stored\nin-line). 32bit is\nintentional, since we want to keep the format binary compatible between\n32 and 64bit systems, and a 64bit offset would bloat the size for almost\nall uses. A version of this format with 64bit (or 16bit) offsets is easy to set\nwhen needed. Unsigned means they can only point in one direction, which\ntypically is forward (towards a higher memory location). Any backwards\noffsets will be explicitly marked as such.\n\nThe format starts with an `uoffset_t` to the root table in the buffer.\n\nWe have two kinds of objects, structs and tables.\n\n### Structs\n\nThese are the simplest, and as mentioned, intended for simple data that\nbenefits from being extra efficient and doesn't need versioning /\nextensibility. They are always stored inline in their parent (a struct,\ntable, or vector) for maximum compactness. Structs define a consistent\nmemory layout where all components are aligned to their size, and\nstructs aligned to their largest scalar member. This is done independent\nof the alignment rules of the underlying compiler to guarantee a cross\nplatform compatible layout. This layout is then enforced in the generated\ncode.\n\n### Tables\n\nUnlike structs, these are not stored in inline in their parent, but are\nreferred to by offset.\n\nThey start with an `soffset_t` to a vtable. This is a signed version of\n`uoffset_t`, since vtables may be stored anywhere relative to the object.\nThis offset is subtracted (not added) from the object start to arrive at\nthe vtable start. This offset is followed by all the\nfields as aligned scalars (or offsets). Unlike structs, not all fields\nneed to be present. There is no set order and layout. A table may contain\nfield offsets that point to the same value if the user explicitly\nserializes the same offset twice.\n\nTo be able to access fields regardless of these uncertainties, we go\nthrough a vtable of offsets. Vtables are shared between any objects that\nhappen to have the same vtable values.\n\nThe elements of a vtable are all of type `voffset_t`, which is\na `uint16_t`. The first element is the size of the vtable in bytes,\nincluding the size element. The second one is the size of the object, in bytes\n(including the vtable offset). This size could be used for streaming, to know\nhow many bytes to read to be able to access all *inline* fields of the object.\nThe remaining elements are the N offsets, where N is the amount of fields\ndeclared in the schema when the code that constructed this buffer was\ncompiled (thus, the size of the table is N + 2).\n\nAll accessor functions in the generated code for tables contain the\noffset into this table as a constant. This offset is checked against the\nfirst field (the number of elements), to protect against newer code\nreading older data. If this offset is out of range, or the vtable entry\nis 0, that means the field is not present in this object, and the\ndefault value is return. Otherwise, the entry is used as offset to the\nfield to be read.\n\n### Unions\n\nUnions are encoded as the combination of two fields: an enum representing the\nunion choice and the offset to the actual element. FlatBuffers reserves the\nenumeration constant `NONE` (encoded as 0) to mean that the union field is not\nset.\n\n### Strings and Vectors\n\nStrings are simply a vector of bytes, and are always\nnull-terminated. Vectors are stored as contiguous aligned scalar\nelements prefixed by a 32bit element count (not including any\nnull termination). Neither is stored inline in their parent, but are referred to\nby offset. A vector may consist of more than one offset pointing to the same\nvalue if the user explicitly serializes the same offset twice.\n\n### Construction\n\nThe current implementation constructs these buffers backwards (starting\nat the highest memory address of the buffer), since\nthat significantly reduces the amount of bookkeeping and simplifies the\nconstruction API.\n\n### Code example\n\nHere's an example of the code that gets generated for the `samples/monster.fbs`.\nWhat follows is the entire file, broken up by comments:\n\n // automatically generated, do not modify\n\n #include \"flatbuffers/flatbuffers.h\"\n\n namespace MyGame {\n namespace Sample {\n\nNested namespace support.\n\n enum {\n Color_Red = 0,\n Color_Green = 1,\n Color_Blue = 2,\n };\n\n inline const char **EnumNamesColor() {\n static const char *names[] = { \"Red\", \"Green\", \"Blue\", nullptr };\n return names;\n }\n\n inline const char *EnumNameColor(int e) { return EnumNamesColor()[e]; }\n\nEnums and convenient reverse lookup.\n\n enum {\n Any_NONE = 0,\n Any_Monster = 1,\n };\n\n inline const char **EnumNamesAny() {\n static const char *names[] = { \"NONE\", \"Monster\", nullptr };\n return names;\n }\n\n inline const char *EnumNameAny(int e) { return EnumNamesAny()[e]; }\n\nUnions share a lot with enums.\n\n struct Vec3;\n struct Monster;\n\nPredeclare all data types since circular references between types are allowed\n(circular references between object are not, though).\n\n FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vec3 {\n private:\n float x_;\n float y_;\n float z_;\n\n public:\n Vec3(float x, float y, float z)\n : x_(flatbuffers::EndianScalar(x)), y_(flatbuffers::EndianScalar(y)), z_(flatbuffers::EndianScalar(z)) {}\n\n float x() const { return flatbuffers::EndianScalar(x_); }\n float y() const { return flatbuffers::EndianScalar(y_); }\n float z() const { return flatbuffers::EndianScalar(z_); }\n };\n FLATBUFFERS_STRUCT_END(Vec3, 12);\n\nThese ugly macros do a couple of things: they turn off any padding the compiler\nmight normally do, since we add padding manually (though none in this example),\nand they enforce alignment chosen by FlatBuffers. This ensures the layout of\nthis struct will look the same regardless of compiler and platform. Note that\nthe fields are private: this is because these store little endian scalars\nregardless of platform (since this is part of the serialized data).\n`EndianScalar` then converts back and forth, which is a no-op on all current\nmobile and desktop platforms, and a single machine instruction on the few\nremaining big endian platforms.\n\n struct Monster : private flatbuffers::Table {\n const Vec3 *pos() const { return GetStruct(4); }\n int16_t mana() const { return GetField(6, 150); }\n int16_t hp() const { return GetField(8, 100); }\n const flatbuffers::String *name() const { return GetPointer(10); }\n const flatbuffers::Vector *inventory() const { return GetPointer *>(14); }\n int8_t color() const { return GetField(16, 2); }\n };\n\nTables are a bit more complicated. A table accessor struct is used to point at\nthe serialized data for a table, which always starts with an offset to its\nvtable. It derives from `Table`, which contains the `GetField` helper functions.\nGetField takes a vtable offset, and a default value. It will look in the vtable\nat that offset. If the offset is out of bounds (data from an older version) or\nthe vtable entry is 0, the field is not present and the default is returned.\nOtherwise, it uses the entry as an offset into the table to locate the field.\n\n struct MonsterBuilder {\n flatbuffers::FlatBufferBuilder &fbb_;\n flatbuffers::uoffset_t start_;\n void add_pos(const Vec3 *pos) { fbb_.AddStruct(4, pos); }\n void add_mana(int16_t mana) { fbb_.AddElement(6, mana, 150); }\n void add_hp(int16_t hp) { fbb_.AddElement(8, hp, 100); }\n void add_name(flatbuffers::Offset name) { fbb_.AddOffset(10, name); }\n void add_inventory(flatbuffers::Offset> inventory) { fbb_.AddOffset(14, inventory); }\n void add_color(int8_t color) { fbb_.AddElement(16, color, 2); }\n MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }\n flatbuffers::Offset Finish() { return flatbuffers::Offset(fbb_.EndTable(start_, 7)); }\n };\n\n`MonsterBuilder` is the base helper struct to construct a table using a\n`FlatBufferBuilder`. You can add the fields in any order, and the `Finish`\ncall will ensure the correct vtable gets generated.\n\n inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb,\n const Vec3 *pos, int16_t mana,\n int16_t hp,\n flatbuffers::Offset name,\n flatbuffers::Offset> inventory,\n int8_t color) {\n MonsterBuilder builder_(_fbb);\n builder_.add_inventory(inventory);\n builder_.add_name(name);\n builder_.add_pos(pos);\n builder_.add_hp(hp);\n builder_.add_mana(mana);\n builder_.add_color(color);\n return builder_.Finish();\n }\n\n`CreateMonster` is a convenience function that calls all functions in\n`MonsterBuilder` above for you. Note that if you pass values which are\ndefaults as arguments, it will not actually construct that field, so\nyou can probably use this function instead of the builder class in\nalmost all cases.\n\n inline const Monster *GetMonster(const void *buf) { return flatbuffers::GetRoot(buf); }\n\nThis function is only generated for the root table type, to be able to\nstart traversing a FlatBuffer from a raw buffer pointer.\n\n }; // namespace MyGame\n }; // namespace Sample\n\n### Encoding example.\n\nBelow is a sample encoding for the following JSON corresponding to the above\nschema:\n\n { pos: { x: 1, y: 2, z: 3 }, name: \"fred\", hp: 50 }\n\nResulting in this binary buffer:\n\n // Start of the buffer:\n uint32_t 20 // Offset to the root table.\n\n // Start of the vtable. Not shared in this example, but could be:\n uint16_t 16 // Size of table, starting from here.\n uint16_t 22 // Size of object inline data.\n uint16_t 4, 0, 20, 16, 0, 0 // Offsets to fields from start of (root) table, 0 for not present.\n\n // Start of the root table:\n int32_t 16 // Offset to vtable used (default negative direction)\n float 1, 2, 3 // the Vec3 struct, inline.\n uint32_t 8 // Offset to the name string.\n int16_t 50 // hp field.\n int16_t 0 // Padding for alignment.\n\n // Start of name string:\n uint32_t 4 // Length of string.\n int8_t 'f', 'r', 'e', 'd', 0, 0, 0, 0 // Text + 0 termination + padding.\n\nNote that this not the only possible encoding, since the writer has some\nflexibility in which of the children of root object to write first (though in\nthis case there's only one string), and what order to write the fields in.\nDifferent orders may also cause different alignments to happen.\n\n### Additional reading.\n\nThe author of the C language implementation has made a similar\n[document](https://github.com/dvidelabs/flatcc/blob/master/doc/binary-format.md#flatbuffers-binary-format)\nthat may further help clarify the format.\n\n# FlexBuffers\n\nThe [schema-less](flexbuffers.md) version of FlatBuffers have their\nown encoding, detailed here.\n\nIt shares many properties mentioned above, in that all data is accessed\nover offsets, all scalars are aligned to their own size, and\nall data is always stored in little endian format.\n\nOne difference is that FlexBuffers are built front to back, so children are\nstored before parents, and the root of the data starts at the last byte.\n\nAnother difference is that scalar data is stored with a variable number of bits\n(8/16/32/64). The current width is always determined by the *parent*, i.e. if\nthe scalar sits in a vector, the vector determines the bit width for all\nelements at once. Selecting the minimum bit width for a particular vector is\nsomething the encoder does automatically and thus is typically of no concern\nto the user, though being aware of this feature (and not sticking a double in\nthe same vector as a bunch of byte sized elements) is helpful for efficiency.\n\nUnlike FlatBuffers there is only one kind of offset, and that is an unsigned\ninteger indicating the number of bytes in a negative direction from the address\nof itself (where the offset is stored).\n\n### Vectors\n\nThe representation of the vector is at the core of how FlexBuffers works (since\nmaps are really just a combination of 2 vectors), so it is worth starting there.\n\nAs mentioned, a vector is governed by a single bit width (supplied by its\nparent). This includes the size field. For example, a vector that stores the\ninteger values `1, 2, 3` is encoded as follows:\n\n uint8_t 3, 1, 2, 3, 4, 4, 4\n\nThe first `3` is the size field, and is placed before the vector (an offset\nfrom the parent to this vector points to the first element, not the size\nfield, so the size field is effectively at index -1).\nSince this is an untyped vector `SL_VECTOR`, it is followed by 3 type\nbytes (one per element of the vector), which are always following the vector,\nand are always a uint8_t even if the vector is made up of bigger scalars.\n\nA vector may include more than one offset pointing to the same value if the\nuser explicitly serializes the same offset twice.\n\n### Types\n\nA type byte is made up of 2 components (see flexbuffers.h for exact values):\n\n* 2 lower bits representing the bit-width of the child (8, 16, 32, 64).\n This is only used if the child is accessed over an offset, such as a child\n vector. It is ignored for inline types.\n* 6 bits representing the actual type (see flexbuffers.h).\n\nThus, in this example `4` means 8 bit child (value 0, unused, since the value is\nin-line), type `SL_INT` (value 1).\n\n### Typed Vectors\n\nThese are like the Vectors above, but omit the type bytes. The type is instead\ndetermined by the vector type supplied by the parent. Typed vectors are only\navailable for a subset of types for which these savings can be significant,\nnamely inline signed/unsigned integers (`TYPE_VECTOR_INT` / `TYPE_VECTOR_UINT`),\nfloats (`TYPE_VECTOR_FLOAT`), and keys (`TYPE_VECTOR_KEY`, see below).\n\nAdditionally, for scalars, there are fixed length vectors of sizes 2 / 3 / 4\nthat don't store the size (`TYPE_VECTOR_INT2` etc.), for an additional savings\nin space when storing common vector or color data.\n\n### Scalars\n\nFlexBuffers supports integers (`TYPE_INT` and `TYPE_UINT`) and floats\n(`TYPE_FLOAT`), available in the bit-widths mentioned above. They can be stored\nboth inline and over an offset (`TYPE_INDIRECT_*`).\n\nThe offset version is useful to encode costly 64bit (or even 32bit) quantities\ninto vectors / maps of smaller sizes, and to share / repeat a value multiple\ntimes.\n\n### Booleans and Nulls\n\nBooleans (`TYPE_BOOL`) and nulls (`TYPE_NULL`) are encoded as inlined unsigned integers.\n\n### Blobs, Strings and Keys.\n\nA blob (`TYPE_BLOB`) is encoded similar to a vector, with one difference: the\nelements are always `uint8_t`. The parent bit width only determines the width of\nthe size field, allowing blobs to be large without the elements being large.\n\nStrings (`TYPE_STRING`) are similar to blobs, except they have an additional 0\ntermination byte for convenience, and they MUST be UTF-8 encoded (since an\naccessor in a language that does not support pointers to UTF-8 data may have to\nconvert them to a native string type).\n\nA \"Key\" (`TYPE_KEY`) is similar to a string, but doesn't store the size\nfield. They're so named because they are used with maps, which don't care\nfor the size, and can thus be even more compact. Unlike strings, keys cannot\ncontain bytes of value 0 as part of their data (size can only be determined by\n`strlen`), so while you can use them outside the context of maps if you so\ndesire, you're usually better off with strings.\n\n### Maps\n\nA map (`TYPE_MAP`) is like an (untyped) vector, but with 2 prefixes before the\nsize field:\n\n| index | field |\n| ----: | :----------------------------------------------------------- |\n| -3 | An offset to the keys vector (may be shared between tables). |\n| -2 | Byte width of the keys vector. |\n| -1 | Size (from here on it is compatible with `TYPE_VECTOR`) |\n| 0 | Elements. |\n| Size | Types. |\n\nSince a map is otherwise the same as a vector, it can be iterated like\na vector (which is probably faster than lookup by key).\n\nThe keys vector is a typed vector of keys. Both the keys and corresponding\nvalues *have* to be stored in sorted order (as determined by `strcmp`), such\nthat lookups can be made using binary search.\n\nThe reason the key vector is a separate structure from the value vector is\nsuch that it can be shared between multiple value vectors, and also to\nallow it to be treated as its own individual vector in code.\n\nAn example map { foo: 13, bar: 14 } would be encoded as:\n\n 0 : uint8_t 'b', 'a', 'r', 0\n 4 : uint8_t 'f', 'o', 'o', 0\n 8 : uint8_t 2 // key vector of size 2\n // key vector offset points here\n 9 : uint8_t 9, 6 // offsets to bar_key and foo_key\n 11: uint8_t 2, 1 // offset to key vector, and its byte width\n 13: uint8_t 2 // value vector of size\n // value vector offset points here\n 14: uint8_t 14, 13 // values\n 16: uint8_t 4, 4 // types\n\n### The root\n\nAs mentioned, the root starts at the end of the buffer.\nThe last uint8_t is the width in bytes of the root (normally the parent\ndetermines the width, but the root has no parent). The uint8_t before this is\nthe type of the root, and the bytes before that are the root value (of the\nnumber of bytes specified by the last byte).\n\nSo for example, the integer value `13` as root would be:\n\n uint8_t 13, 4, 1 // Value, type, root byte width.\n\n" }, { "path": "docs/source/languages/c.md", "content": "Use in C {#flatbuffers_guide_use_c}\n==========\n\nThe C language binding exists in a separate project named [FlatCC](https://github.com/dvidelabs/flatcc).\n\nThe `flatcc` C schema compiler can generate code offline as well as\nonline via a C library. It can also generate buffer verifiers and fast\nJSON parsers, printers.\n\nGreat care has been taken to ensure compatibility with the main `flatc`\nproject.\n\n## General Documention\n\n- [Tutorial](../tutorial.md) - select C as language\n when scrolling down\n- [FlatCC Guide](https://github.com/dvidelabs/flatcc#flatcc-flatbuffers-in-c-for-c)\n- [The C Builder Interface](https://github.com/dvidelabs/flatcc/blob/master/doc/builder.md#the-builder-interface)\n- [The Monster Sample in C](https://github.com/dvidelabs/flatcc/blob/master/samples/monster/monster.c)\n- [GitHub](https://github.com/dvidelabs/flatcc)\n\n\n## Supported Platforms\n\n- Ubuntu (clang / gcc, ninja / gnu make)\n- OS-X (clang / gcc, ninja / gnu make)\n- Windows MSVC 2010, 2013, 2015\n\nCI builds recent versions of gcc, clang and MSVC on OS-X, Ubuntu, and\nWindows, and occasionally older compiler versions. See main project [Status](https://github.com/dvidelabs/flatcc#status).\n\nOther platforms may well work, including Centos, but are not tested\nregularly.\n\nThe monster sample project was specifically written for C99 in order to\nfollow the C++ version and for that reason it will not work with MSVC\n2010.\n\n## Modular Object Creation\n\nIn the tutorial we used the call `Monster_create_as_root` to create the\nroot buffer object since this is easier in simple use cases. Sometimes\nwe need more modularity so we can reuse a function to create nested\ntables and root tables the same way. For this we need the\n`flatcc_builder_buffer_create_call`. It is best to keep `flatcc_builder`\ncalls isolated at the top driver level, so we get:\n\n
\n~~~{.c}\n ns(Monster_ref_t) create_orc(flatcc_builder_t *B)\n {\n // ... same as in the tutorial.\n return s(Monster_create(B, ...));\n }\n\n void create_monster_buffer()\n {\n uint8_t *buf;\n size_t size;\n flatcc_builder_t builder, *B;\n\n // Initialize the builder object.\n B = &builder;\n flatcc_builder_init(B);\n // Only use `buffer_create` without `create/start/end_as_root`.\n flatcc_builder_buffer_create(create_orc(B));\n // Allocate and copy buffer to user memory.\n buf = flatcc_builder_finalize_buffer(B, &size);\n // ... write the buffer to disk or network, or something.\n\n free(buf);\n flatcc_builder_clear(B);\n }\n~~~\n
\n\nThe same principle applies with `start/end` vs `start/end_as_root` in\nthe top-down approach.\n\n\n## Top Down Example\n\nThe tutorial uses a bottom up approach. In C it is also possible to use\na top-down approach by starting and ending objects nested within each\nother. In the tutorial there is no deep nesting, so the difference is\nlimited, but it shows the idea:\n\n
\n
\n~~~{.c}\n uint8_t treasure[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};\n size_t treasure_count = c_vec_len(treasure);\n ns(Weapon_ref_t) axe;\n\n // NOTE: if we use end_as_root, we MUST also start as root.\n ns(Monster_start_as_root(B));\n ns(Monster_pos_create(B, 1.0f, 2.0f, 3.0f));\n ns(Monster_hp_add(B, 300));\n ns(Monster_mana_add(B, 150));\n // We use create_str instead of add because we have no existing string reference.\n ns(Monster_name_create_str(B, \"Orc\"));\n // Again we use create because we no existing vector object, only a C-array.\n ns(Monster_inventory_create(B, treasure, treasure_count));\n ns(Monster_color_add(B, ns(Color_Red)));\n if (1) {\n ns(Monster_weapons_start(B));\n ns(Monster_weapons_push_create(B, flatbuffers_string_create_str(B, \"Sword\"), 3));\n // We reuse the axe object later. Note that we dereference a pointer\n // because push always returns a short-term pointer to the stored element.\n // We could also have created the axe object first and simply pushed it.\n axe = *ns(Monster_weapons_push_create(B, flatbuffers_string_create_str(B, \"Axe\"), 5));\n ns(Monster_weapons_end(B));\n } else {\n // We can have more control with the table elements added to a vector:\n //\n ns(Monster_weapons_start(B));\n ns(Monster_weapons_push_start(B));\n ns(Weapon_name_create_str(B, \"Sword\"));\n ns(Weapon_damage_add(B, 3));\n ns(Monster_weapons_push_end(B));\n ns(Monster_weapons_push_start(B));\n ns(Monster_weapons_push_start(B));\n ns(Weapon_name_create_str(B, \"Axe\"));\n ns(Weapon_damage_add(B, 5));\n axe = *ns(Monster_weapons_push_end(B));\n ns(Monster_weapons_end(B));\n }\n // Unions can get their type by using a type-specific add/create/start method.\n ns(Monster_equipped_Weapon_add(B, axe));\n\n ns(Monster_end_as_root(B));\n~~~\n
\n\n\n## Basic Reflection\n\nThe C-API does support reading binary schema (.bfbs)\nfiles via code generated from the `reflection.fbs` schema, and an\n[example usage](https://github.com/dvidelabs/flatcc/tree/master/samples/reflection)\nshows how to use this. The reflection schema files are pre-generated\nin the [runtime distribution](https://github.com/dvidelabs/flatcc/tree/master/include/flatcc/reflection).\n\n\n## Mutations and Reflection\n\nThe C-API does not support mutating reflection like C++ does, nor does\nthe reader interface support mutating scalars (and it is generally\nunsafe to do so even after verification).\n\nThe generated reader interface supports sorting vectors in-place after\ncasting them to a mutating type because it is not practical to do so\nwhile building a buffer. This is covered in the builder documentation. \nThe reflection example makes use of this feature to look up objects by\nname.\n\nIt is possible to build new buffers using complex objects from existing\nbuffers as source. This can be very efficient due to direct copy\nsemantics without endian conversion or temporary stack allocation.\n\nScalars, structs and strings can be used as source, as well vectors of\nthese.\n\nIt is currently not possible to use an existing table or vector of table\nas source, but it would be possible to add support for this at some\npoint.\n\n\n## Namespaces\n\nThe `FLATBUFFERS_WRAP_NAMESPACE` approach used in the tutorial is convenient\nwhen each function has a very long namespace prefix. But it isn't always\nthe best approach. If the namespace is absent, or simple and\ninformative, we might as well use the prefix directly. The\n[reflection example](https://github.com/dvidelabs/flatcc/blob/master/samples/reflection/bfbs2json.c)\nmentioned above uses this approach.\n\n\n## Checking for Present Members\n\nNot all languages support testing if a field is present, but in C we can\nelaborate the reader section of the tutorial with tests for this. Recall\nthat `mana` was set to the default value `150` and therefore shouldn't\nbe present.\n\n
\n~~~{.c}\n int hp_present = ns(Monster_hp_is_present(monster)); // 1\n int mana_present = ns(Monster_mana_is_present(monster)); // 0\n~~~\n
\n\n## Alternative ways to add a Union\n\nIn the tutorial we used a single call to add a union. Here we show\ndifferent ways to accomplish the same thing. The last form is rarely\nused, but is the low-level way to do it. It can be used to group small\nvalues together in the table by adding type and data at different\npoints in time.\n\n
\n~~~{.c}\n ns(Equipment_union_ref_t) equipped = ns(Equipment_as_Weapon(axe));\n ns(Monster_equipped_add(B, equipped));\n // or alternatively\n ns(Monster_equipped_Weapon_add(B, axe);\n // or alternatively\n ns(Monster_equipped_add_type(B, ns(Equipment_Weapon));\n ns(Monster_equipped_add_member(B, axe));\n~~~\n
\n\n## Why not integrate with the `flatc` tool?\n\n[It was considered how the C code generator could be integrated into the\n`flatc` tool](https://github.com/dvidelabs/flatcc/issues/1), but it\nwould either require that the standalone C implementation of the schema\ncompiler was dropped, or it would lead to excessive code duplication, or\na complicated intermediate representation would have to be invented.\nNeither of these alternatives are very attractive, and it isn't a big\ndeal to use the `flatcc` tool instead of `flatc` given that the\nFlatBuffers C runtime library needs to be made available regardless.\n\n\n" }, { "path": "docs/source/languages/c_sharp.md", "content": "Use in C\\# {#flatbuffers_guide_use_c-sharp}\n==============\n\n## Before you get started\n\nBefore diving into the FlatBuffers usage in C#, it should be noted that\nthe [Tutorial](../tutorial.md) page has a complete guide to\ngeneral FlatBuffers usage in all of the supported languages (including C#).\nThis page is designed to cover the nuances of FlatBuffers usage,\nspecific to C#.\n\nYou should also have read the [Building](../building.md)\ndocumentation to build `flatc` and should be familiar with\n[Using the schema compiler](../flatc.md) and\n[Writing a schema](../schema.md).\n\n## FlatBuffers C# code location\n\nThe code for the FlatBuffers C# library can be found at\n`flatbuffers/net/FlatBuffers`. You can browse the library on the\n[FlatBuffers GitHub page](https://github.com/google/flatbuffers/tree/master/net/\nFlatBuffers).\n\n## Building the FlatBuffers C# library\n\nThe `FlatBuffers.csproj` project contains multitargeting for .NET Standard 2.0, 2.1,\n.NET 6 and .NET 8.\n\nYou can build for a specific framework target when using the cross-platform\n[.NET Core SDK](https://dotnet.microsoft.com/download) by adding the `-f`\ncommand line option:\n\n~~~{.sh}\n dotnet build -f netstandard2.1 \"FlatBuffers.csproj\"\n~~~\n\nThe `FlatBuffers.csproj` project also provides support for defining various\nconditional compilation symbols (see \"Conditional compilation symbols\" section\nbelow) using the `-p` command line option:\n\n~~~{.sh}\n dotnet build -f netstandard2.1 -p:ENABLE_SPAN_T=true -p:UNSAFE_BYTEBUFFER=true \"FlatBuffers.csproj\"\n~~~\n\n## Testing the FlatBuffers C# library\n\nThe code to test the libraries can be found at `flatbuffers/tests`.\n\nThe test code for C# is located in the [FlatBuffers.Test](https://github.com/\ngoogle/flatbuffers/tree/master/tests/FlatBuffers.Test) subfolder. To run the\ntests, open `FlatBuffers.Test.csproj` in [Visual Studio](\nhttps://www.visualstudio.com), and compile/run the project.\n\nOptionally, you can run this using [Mono](http://www.mono-project.com/) instead.\nOnce you have installed Mono, you can run the tests from the command line\nby running the following commands from inside the `FlatBuffers.Test` folder:\n\n~~~{.sh}\n mcs *.cs ../MyGame/Example/*.cs ../../net/FlatBuffers/*.cs\n mono Assert.exe\n~~~\n\n## Using the FlatBuffers C# library\n\n*Note: See [Tutorial](../tutorial.md) for a more in-depth\nexample of how to use FlatBuffers in C#.*\n\nFlatBuffers supports reading and writing binary FlatBuffers in C#.\n\nTo use FlatBuffers in your own code, first generate C# classes from your\nschema with the `--csharp` option to `flatc`.\nThen you can include both FlatBuffers and the generated code to read\nor write a FlatBuffer.\n\nFor example, here is how you would read a FlatBuffer binary file in C#:\nFirst, import the library and generated code. Then, you read a FlatBuffer binary\nfile into a `byte[]`. You then turn the `byte[]` into a `ByteBuffer`, which you\npass to the `GetRootAsMyRootType` function:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cs}\n using MyGame.Example;\n using Google.FlatBuffers;\n\n // This snippet ignores exceptions for brevity.\n byte[] data = File.ReadAllBytes(\"monsterdata_test.mon\");\n\n ByteBuffer bb = new ByteBuffer(data);\n Monster monster = Monster.GetRootAsMonster(bb);\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nNow you can access the data from the `Monster monster`:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cs}\n short hp = monster.Hp;\n Vec3 pos = monster.Pos;\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nC# code naming follows standard C# style with PascalCasing identifiers,\ne.g. `GetRootAsMyRootType`. Also, values (except vectors and unions) are\navailable as properties instead of parameterless accessor methods.\nThe performance-enhancing methods to which you can pass an already created\nobject are prefixed with `Get`, e.g.:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cs}\n // property\n var pos = monster.Pos;\n\n // method filling a preconstructed object\n var preconstructedPos = new Vec3();\n monster.GetPos(preconstructedPos);\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n## Storing dictionaries in a FlatBuffer\n\nFlatBuffers doesn't support dictionaries natively, but there is support to\nemulate their behavior with vectors and binary search, which means you\ncan have fast lookups directly from a FlatBuffer without having to unpack\nyour data into a `Dictionary` or similar.\n\nTo use it:\n- Designate one of the fields in a table as the \"key\" field. You do this\n by setting the `key` attribute on this field, e.g.\n `name:string (key)`.\n You may only have one key field, and it must be of string or scalar type.\n- Write out tables of this type as usual, collect their offsets in an\n array.\n- Instead of calling standard generated method,\n e.g.: `Monster.createTestarrayoftablesVector`,\n call `CreateSortedVectorOfMonster` in C#\n which will first sort all offsets such that the tables they refer to\n are sorted by the key field, then serialize it.\n- Now when you're accessing the FlatBuffer, you can use\n the `ByKey` accessor to access elements of the vector, e.g.:\n `monster.TestarrayoftablesByKey(\"Frodo\")` in C#,\n which returns an object of the corresponding table type,\n or `null` if not found.\n `ByKey` performs a binary search, so should have a similar\n speed to `Dictionary`, though may be faster because of better caching.\n `ByKey` only works if the vector has been sorted, it will\n likely not find elements if it hasn't been sorted.\n\n## Buffer verification\n\nAs mentioned in [C++ Usage](cpp.md) buffer\naccessor functions do not verify buffer offsets at run-time.\nIf it is necessary, you can optionally use a buffer verifier before you\naccess the data. This verifier will check all offsets, all sizes of\nfields, and null termination of strings to ensure that when a buffer\nis accessed, all reads will end up inside the buffer.\n\nEach root type will have a verification function generated for it,\ne.g. `Monster.VerifyMonster`. This can be called as shown:\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cs}\n var ok = Monster.VerifyMonster(buf);\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\nif `ok` is true, the buffer is safe to read.\n\nFor a more detailed control of verification `MonsterVerify.Verify`\nfor `Monster` type can be used:\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cs}\n # Sequence of calls\n FlatBuffers.Verifier verifier = new FlatBuffers.Verifier(buf);\n var ok = verifier.VerifyBuffer(\"MONS\", false, MonsterVerify.Verify);\n\n # Or single line call\n var ok = new FlatBuffers.Verifier(bb).setStringCheck(true).\\\n VerifyBuffer(\"MONS\", false, MonsterVerify.Verify);\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\nif `ok` is true, the buffer is safe to read.\n\nA second parameter of `verifyBuffer` specifies whether buffer content is\nsize prefixed or not. In the example above, the buffer is assumed to not include\nsize prefix (`false`).\n\nVerifier supports options that can be set using appropriate fluent methods:\n* SetMaxDepth - limit the nesting depth. Default: 1000000\n* SetMaxTables - total amount of tables the verifier may encounter. Default: 64\n* SetAlignmentCheck - check content alignment. Default: True\n* SetStringCheck - check if strings contain termination '0' character. Default: true\n\n\n## Text parsing\n\nThere currently is no support for parsing text (Schema's and JSON) directly\nfrom C#, though you could use the C++ parser through native call\ninterfaces available to each language. Please see the\nC++ documentation for more on text parsing.\n\n## Object based API\n\nFlatBuffers is all about memory efficiency, which is why its base API is written\naround using as little as possible of it. This does make the API clumsier\n(requiring pre-order construction of all data, and making mutation harder).\n\nFor times when efficiency is less important a more convenient object based API\ncan be used (through `--gen-object-api`) that is able to unpack & pack a\nFlatBuffer into objects and standard `System.Collections.Generic` containers,\nallowing for convenient construction, access and mutation.\n\nTo use:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cs}\n // Deserialize from buffer into object.\n MonsterT monsterobj = GetMonster(flatbuffer).UnPack();\n\n // Update object directly like a C# class instance.\n Console.WriteLine(monsterobj.Name);\n monsterobj.Name = \"Bob\"; // Change the name.\n\n // Serialize into new flatbuffer.\n FlatBufferBuilder fbb = new FlatBufferBuilder(1);\n fbb.Finish(Monster.Pack(fbb, monsterobj).Value);\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n### Json Serialization\n\nAn additional feature of the object API is the ability to allow you to\nserialize & deserialize a JSON text.\nTo use Json Serialization, add `--cs-gen-json-serializer` option to `flatc` and\nadd `Newtonsoft.Json` nuget package to csproj. This requires explicitly setting\nthe `--gen-object-api` option as well.\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cs}\n // Deserialize MonsterT from json\n string jsonText = File.ReadAllText(@\"Resources/monsterdata_test.json\");\n MonsterT mon = MonsterT.DeserializeFromJson(jsonText);\n\n // Serialize MonsterT to json\n string jsonText2 = mon.SerializeToJson();\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n* Limitation\n * `hash` attribute currently not supported.\n* NuGet package Dependency\n * [Newtonsoft.Json](https://github.com/JamesNK/Newtonsoft.Json)\n\n## Conditional compilation symbols\n\nThere are three conditional compilation symbols that have an impact on\nperformance/features of the C# `ByteBuffer` implementation.\n\n* `UNSAFE_BYTEBUFFER`\n\n This will use unsafe code to manipulate the underlying byte array. This can\n yield a reasonable performance increase.\n\n* `BYTEBUFFER_NO_BOUNDS_CHECK`\n\n This will disable the bounds check asserts to the byte array. This can yield a\n small performance gain in normal code.\n\n* `ENABLE_SPAN_T`\n\n This will enable reading and writing blocks of memory with a `Span` instead\n of just `T[]`. You can also enable writing directly to shared memory or other\n types of memory by providing a custom implementation of `ByteBufferAllocator`.\n `ENABLE_SPAN_T` also requires `UNSAFE_BYTEBUFFER` to be defined, or .NET\n Standard 2.1.\n\nUsing `UNSAFE_BYTEBUFFER` and `BYTEBUFFER_NO_BOUNDS_CHECK` together can yield a\nperformance gain of ~15% for some operations, however doing so is potentially\ndangerous. Do so at your own risk!\n\n
\n" }, { "path": "docs/source/languages/cpp.md", "content": "# Language Guide: C++\n\n## Before you get started\n\nBefore diving into the FlatBuffers usage in C++, it should be noted that\nthe [Tutorial](../tutorial.md) page has a complete guide\nto general FlatBuffers usage in all of the supported languages (including C++).\nThis page is designed to cover the nuances of FlatBuffers usage, specific to\nC++.\n\n#### Prerequisites\n\nThis page assumes you have written a FlatBuffers schema and compiled it\nwith the Schema Compiler. If you have not, please see\n[Using the schema compiler](../flatc.md)\nand [Writing a schema](../schema.md).\n\nAssuming you wrote a schema, say `mygame.fbs` (though the extension doesn't\nmatter), you've generated a C++ header called `mygame_generated.h` using the\ncompiler (e.g. `flatc -c mygame.fbs`), you can now start using this in\nyour program by including the header. As noted, this header relies on\n`flatbuffers/flatbuffers.h`, which should be in your include path.\n\n## FlatBuffers C++ library code location\n\nThe code for the FlatBuffers C++ library can be found at\n`flatbuffers/include/flatbuffers`. You can browse the library code on the\n[FlatBuffers GitHub page](https://github.com/google/flatbuffers/tree/master/include/flatbuffers).\n\n## Testing the FlatBuffers C++ library\n\nThe code to test the C++ library can be found at `flatbuffers/tests`.\nThe test code itself is located in\n[test.cpp](https://github.com/google/flatbuffers/blob/master/tests/test.cpp).\n\nThis test file is built alongside `flatc`. To review how to build the project,\nplease read the [Building](../building.md) documentation.\n\nTo run the tests, execute `flattests` from the root `flatbuffers/` directory.\nFor example, on [Linux](https://en.wikipedia.org/wiki/Linux), you would simply\nrun: `./flattests`.\n\n## Using the FlatBuffers C++ library\n\n*Note: See [Tutorial](../tutorial.md) for a more in-depth\nexample of how to use FlatBuffers in C++.*\n\nFlatBuffers supports both reading and writing FlatBuffers in C++.\n\nTo use FlatBuffers in your code, first generate the C++ classes from your\nschema with the `--cpp` option to `flatc`. Then you can include both FlatBuffers\nand the generated code to read or write FlatBuffers.\n\nFor example, here is how you would read a FlatBuffer binary file in C++:\nFirst, include the library and generated code. Then read the file into\na `char *` array, which you pass to `GetMonster()`.\n\n```cpp\n #include \"flatbuffers/flatbuffers.h\"\n #include \"monster_test_generate.h\"\n #include // C++ header file for printing\n #include // C++ header file for file access\n\n\n std::ifstream infile;\n infile.open(\"monsterdata_test.mon\", std::ios::binary | std::ios::in);\n infile.seekg(0,std::ios::end);\n int length = infile.tellg();\n infile.seekg(0,std::ios::beg);\n char *data = new char[length];\n infile.read(data, length);\n infile.close();\n\n auto monster = GetMonster(data);\n```\n\n`monster` is of type `Monster *`, and points to somewhere *inside* your\nbuffer (root object pointers are not the same as `buffer_pointer` \\!).\nIf you look in your generated header, you'll see it has\nconvenient accessors for all fields, e.g. `hp()`, `mana()`, etc:\n\n```cpp\n std::cout << \"hp : \" << monster->hp() << std::endl; // '80'\n std::cout << \"mana : \" << monster->mana() << std::endl; // default value of '150'\n std::cout << \"name : \" << monster->name()->c_str() << std::endl; // \"MyMonster\"\n```\n\n*Note: That we never stored a `mana` value, so it will return the default.*\n\nThe following attributes are supported:\n\n- `shared` (on a field): For string fields, this enables the usage of string\n pooling (i.e. `CreateSharedString`) as default serialization behavior.\n\n Specifically, `CreateXxxDirect` functions and `Pack` functions for object\n based API (see below) will use `CreateSharedString` to create strings.\n\n## Object based API\n\nFlatBuffers is all about memory efficiency, which is why its base API is written\naround using as little as possible of it. This does make the API clumsier\n(requiring pre-order construction of all data, and making mutation harder).\n\nFor times when efficiency is less important a more convenient object based API\ncan be used (through `--gen-object-api`) that is able to unpack & pack a\nFlatBuffer into objects and standard STL containers, allowing for convenient\nconstruction, access and mutation.\n\nTo use:\n\n```cpp\n // Autogenerated class from table Monster.\n MonsterT monsterobj;\n\n // Deserialize from buffer into object.\n GetMonster(flatbuffer)->UnPackTo(&monsterobj);\n\n // Update object directly like a C++ class instance.\n cout << monsterobj.name; // This is now a std::string!\n monsterobj.name = \"Bob\"; // Change the name.\n\n // Serialize into new flatbuffer.\n FlatBufferBuilder fbb;\n fbb.Finish(Monster::Pack(fbb, &monsterobj));\n```\n\nThe following attributes are specific to the object-based API code generation:\n\n- `native_inline` (on a field): Because FlatBuffer tables and structs are\n optionally present in a given buffer, they are best represented as pointers\n (specifically std::unique_ptrs) in the native class since they can be null.\n This attribute changes the member declaration to use the type directly\n rather than wrapped in a unique_ptr.\n\n- `native_default(\"value\")` (on a field): For members that are declared\n \"native_inline\", the value specified with this attribute will be included\n verbatim in the class constructor initializer list for this member.\n\n- `native_custom_alloc(\"custom_allocator\")` (on a table or struct): When using the\n object-based API all generated NativeTables that are allocated when unpacking\n your flatbuffer will use \"custom allocator\". The allocator is also used by\n any std::vector that appears in a table defined with `native_custom_alloc`.\n This can be used to provide allocation from a pool for example, for faster\n unpacking when using the object-based API.\n\nMinimal Example:\n\nschema:\n\n```cpp\n table mytable(native_custom_alloc:\"custom_allocator\") {\n ...\n }\n```\n\nwith `custom_allocator` defined before `flatbuffers.h` is included, as:\n\n```cpp\n template struct custom_allocator : public std::allocator {\n\n typedef T *pointer;\n\n template \n struct rebind {\n typedef custom_allocator other;\n };\n\n pointer allocate(const std::size_t n) {\n return std::allocator::allocate(n);\n }\n\n void deallocate(T* ptr, std::size_t n) {\n return std::allocator::deallocate(ptr,n);\n }\n\n custom_allocator() throw() {}\n\n template \n custom_allocator(const custom_allocator&) throw() {}\n };\n```\n\n- `native_type(\"type\")` (on a struct): In some cases, a more optimal C++ data\ntype exists for a given struct. For example, the following schema:\n\n```cpp\n struct Vec2 {\n x: float;\n y: float;\n }\n```\n\ngenerates the following Object-Based API class:\n\n```cpp\n struct Vec2T : flatbuffers::NativeTable {\n float x;\n float y;\n };\n```\n\nHowever, it can be useful to instead use a user-defined C++ type since it\ncan provide more functionality, eg.\n\n```cpp\n struct vector2 {\n float x = 0, y = 0;\n vector2 operator+(vector2 rhs) const { ... }\n vector2 operator-(vector2 rhs) const { ... }\n float length() const { ... }\n // etc.\n };\n```\n\nThe `native_type` attribute will replace the usage of the generated class\nwith the given type. So, continuing with the example, the generated\ncode would use `vector2` in place of `Vec2T` for all generated code of\nthe Object-Based API.\n\nHowever, because the `native_type` is unknown to flatbuffers, the user must\nprovide the following functions to aide in the serialization process:\n\n```cpp\n namespace flatbuffers {\n Vec2 Pack(const vector2& obj);\n vector2 UnPack(const Vec2& obj);\n }\n```\n\n- `native_type_pack_name(\"name\")` (on a struct when `native_type` is\n specified, too): when you want to use the same `native_type` multiple times\n (e. g. with different precision) you must make the names of the Pack/UnPack\n functions unique, otherwise you will run into compile errors. This attribute\n appends a name to the expected Pack/UnPack functions. So when you\n specify `native_type_pack_name(\"Vec2\")` in the above example you now need to\n implement these serialization functions instead:\n\n```cpp\n namespace flatbuffers {\n Vec2 PackVec2(const vector2& obj);\n vector2 UnPackVec2(const Vec2& obj);\n }\n```\n\n- `native_type(\"type\")` (on a table): Tables can also be represented with\nnative types. For example, the following schema:\n\n```cpp\n table Matrix (native_type: \"NativeMatrix\") {\n rows: int32;\n columns: int32;\n values: [float];\n }\n```\n\nWould be represented by a user-defined C++ class:\n\n```cpp\n class NativeMatrix { ... }\n```\n\nIn this case, the following function declarations are generated by the compiler.\nThe user must provide and link the matching function definitions:\n\n```cpp\n struct Matrix FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {\n // ...\n\n static ::flatbuffers::Offset Pack(\n ::flatbuffers::FlatBufferBuilder& _fbb,\n const NativeMatrix* _o,\n const ::flatbuffers::rehasher_function_t* _rehasher = nullptr);\n\n void UnPackTo(\n NativeMatrix* _o,\n const ::flatbuffers::resolver_function_t* _resolver = nullptr) const;\n }\n```\n\nFinally, the following top-level attributes:\n\n- `native_include(\"path\")` (at file level): Because the `native_type` attribute\n can be used to introduce types that are unknown to flatbuffers, it may be\n necessary to include \"external\" header files in the generated code. This\n attribute can be used to directly add an #include directive to the top of\n the generated code that includes the specified path directly.\n\n- `force_align`: this attribute may not be respected in the object API,\n depending on the aligned of the allocator used with `new`.\n\n## External references\n\nAn additional feature of the object API is the ability to allow you to load\nmultiple independent FlatBuffers, and have them refer to eachothers objects\nusing hashes which are then represented as typed pointers in the object API.\n\nTo make this work have a field in the objects you want to referred to which is\nusing the string hashing feature (see `hash` attribute in the\n[schema](../schema.md) documentation). Then you have\na similar hash in the field referring to it, along with a `cpp_type`\nattribute specifying the C++ type this will refer to (this can be any C++\ntype, and will get a `*` added).\n\nThen, in JSON or however you create these buffers, make sure they use the\nsame string (or hash).\n\nWhen you call `UnPack` (or `Create`), you'll need a function that maps from\nhash to the object (see `resolver_function_t` for details).\n\n## Using different pointer types\n\nBy default the object tree is built out of `std::unique_ptr`, but you can\ninfluence this either globally (using the `--cpp-ptr-type` argument to\n`flatc`) or per field (using the `cpp_ptr_type` attribute) to by any smart\npointer type (`my_ptr`), or by specifying `naked` as the type to get `T *`\npointers. Unlike the smart pointers, naked pointers do not manage memory for\nyou, so you'll have to manage their lifecycles manually. To reference the\npointer type specified by the `--cpp-ptr-type` argument to `flatc` from a\nflatbuffer field set the `cpp_ptr_type` attribute to `default_ptr_type`.\n\n## Using different string type\n\nBy default the object tree is built out of `std::string`, but you can\ninfluence this either globally (using the `--cpp-str-type` argument to\n`flatc`) or per field using the `cpp_str_type` attribute.\n\nThe type must support `T::c_str()`, `T::length()` and `T::empty()` as member functions.\n\nFurther, the type must be constructible from std::string, as by default a\nstd::string instance is constructed and then used to initialize the custom\nstring type. This behavior impedes efficient and zero-copy construction of\ncustom string types; the `--cpp-str-flex-ctor` argument to `flatc` or the\nper field attribute `cpp_str_flex_ctor` can be used to change this behavior,\nso that the custom string type is constructed by passing the pointer and\nlength of the FlatBuffers String. The custom string class will require a\nconstructor in the following format: `custom_str_class(const char *, size_t)`.\nPlease note that the character array is not guaranteed to be NULL terminated,\nyou should always use the provided size to determine end of string.\n\n## Reflection (& Resizing)\n\nThere is experimental support for reflection in FlatBuffers, allowing you to\nread and write data even if you don't know the exact format of a buffer, and\neven allows you to change sizes of strings and vectors in-place.\n\nThe way this works is very elegant; there is actually a FlatBuffer schema that\ndescribes schemas (\\!) which you can find in `reflection/reflection.fbs`.\nThe compiler, `flatc`, can write out any schemas it has just parsed as a binary\nFlatBuffer, corresponding to this meta-schema.\n\nLoading in one of these binary schemas at runtime allows you traverse any\nFlatBuffer data that corresponds to it without knowing the exact format. You\ncan query what fields are present, and then read/write them after.\n\nFor convenient field manipulation, you can include the header\n`flatbuffers/reflection.h` which includes both the generated code from the meta\nschema, as well as a lot of helper functions.\n\nAnd example of usage, for the time being, can be found in\n`test.cpp/ReflectionTest()`.\n\n## Mini Reflection\n\nA more limited form of reflection is available for direct inclusion in\ngenerated code, which doesn't do any (binary) schema access at all. It was designed\nto keep the overhead of reflection as low as possible (on the order of 2-6\nbytes per field added to your executable), but doesn't contain all the\ninformation the (binary) schema contains.\n\nYou add this information to your generated code by specifying `--reflect-types`\n(or instead `--reflect-names` if you also want field / enum names).\n\nYou can now use this information, for example to print a FlatBuffer to text:\n\n auto s = flatbuffers::FlatBufferToString(flatbuf, MonsterTypeTable());\n\n`MonsterTypeTable()` is declared in the generated code for each type. The\nstring produced is very similar to the JSON produced by the `Parser` based\ntext generator.\n\nYou'll need `flatbuffers/minireflect.h` for this functionality. In there is also\na convenient visitor/iterator so you can write your own output / functionality\nbased on the mini reflection tables without having to know the FlatBuffers or\nreflection encoding.\n\n## Storing maps / dictionaries in a FlatBuffer\n\nFlatBuffers doesn't support maps natively, but there is support to\nemulate their behavior with vectors and binary search, which means you\ncan have fast lookups directly from a FlatBuffer without having to unpack\nyour data into a `std::map` or similar.\n\nTo use it:\n- Designate one of the fields in a table as they \"key\" field. You do this\n by setting the `key` attribute on this field, e.g.\n `name:string (key)`.\n You may only have one key field, and it must be of string or scalar type.\n- Write out tables of this type as usual, collect their offsets in an\n array or vector.\n- Instead of `CreateVector`, call `CreateVectorOfSortedTables`,\n which will first sort all offsets such that the tables they refer to\n are sorted by the key field, then serialize it.\n- Now when you're accessing the FlatBuffer, you can use `Vector::LookupByKey`\n instead of just `Vector::Get` to access elements of the vector, e.g.:\n `myvector->LookupByKey(\"Fred\")`, which returns a pointer to the\n corresponding table type, or `nullptr` if not found.\n `LookupByKey` performs a binary search, so should have a similar speed to\n `std::map`, though may be faster because of better caching. `LookupByKey`\n only works if the vector has been sorted, it will likely not find elements\n if it hasn't been sorted.\n\n## Direct memory access\n\nAs you can see from the above examples, all elements in a buffer are\naccessed through generated accessors. This is because everything is\nstored in little endian format on all platforms (the accessor\nperforms a swap operation on big endian machines), and also because\nthe layout of things is generally not known to the user.\n\nFor structs, layout is deterministic and guaranteed to be the same\nacross platforms (scalars are aligned to their\nown size, and structs themselves to their largest member), and you\nare allowed to access this memory directly by using `sizeof()` and\n`memcpy` on the pointer to a struct, or even an array of structs.\n\nTo compute offsets to sub-elements of a struct, make sure they\nare a structs themselves, as then you can use the pointers to\nfigure out the offset without having to hardcode it. This is\nhandy for use of arrays of structs with calls like `glVertexAttribPointer`\nin OpenGL or similar APIs.\n\nIt is important to note is that structs are still little endian on all\nmachines, so only use tricks like this if you can guarantee you're not\nshipping on a big endian machine (an `assert(FLATBUFFERS_LITTLEENDIAN)`\nwould be wise).\n\n## Access of untrusted buffers\n\nThe generated accessor functions access fields over offsets, which is\nvery quick. These offsets are not verified at run-time, so a malformed\nbuffer could cause a program to crash by accessing random memory.\n\nWhen you're processing large amounts of data from a source you know (e.g.\nyour own generated data on disk), this is acceptable, but when reading\ndata from the network that can potentially have been modified by an\nattacker, this is undesirable.\n\nFor this reason, you can optionally use a buffer verifier before you\naccess the data. This verifier will check all offsets, all sizes of\nfields, and null termination of strings to ensure that when a buffer\nis accessed, all reads will end up inside the buffer.\n\nEach root type will have a verification function generated for it,\ne.g. for `Monster`, you can call:\n\n```cpp\n\tVerifier verifier(buf, len);\n\tbool ok = VerifyMonsterBuffer(verifier);\n```\n\nif `ok` is true, the buffer is safe to read.\n\nBesides untrusted data, this function may be useful to call in debug\nmode, as extra insurance against data being corrupted somewhere along\nthe way.\n\nWhile verifying a buffer isn't \"free\", it is typically faster than\na full traversal (since any scalar data is not actually touched),\nand since it may cause the buffer to be brought into cache before\nreading, the actual overhead may be even lower than expected.\n\nIn specialized cases where a denial of service attack is possible,\nthe verifier has two additional constructor arguments that allow\nyou to limit the nesting depth and total amount of tables the\nverifier may encounter before declaring the buffer malformed. The default is\n`Verifier(buf, len, 64 /* max depth */, 1000000, /* max tables */)` which\nshould be sufficient for most uses.\n\n## Text & schema parsing\n\nUsing binary buffers with the generated header provides a super low\noverhead use of FlatBuffer data. There are, however, times when you want\nto use text formats, for example because it interacts better with source\ncontrol, or you want to give your users easy access to data.\n\nAnother reason might be that you already have a lot of data in JSON\nformat, or a tool that generates JSON, and if you can write a schema for\nit, this will provide you an easy way to use that data directly.\n\n(see the schema documentation for some specifics on the JSON format\naccepted).\n\nSchema evolution compatibility for the JSON format follows the same rules as the binary format (JSON formatted data will be forwards/backwards compatible with schemas that evolve in a compatible way).\n\nThere are two ways to use text formats:\n\n#### Using the compiler as a conversion tool\n\nThis is the preferred path, as it doesn't require you to add any new\ncode to your program, and is maximally efficient since you can ship with\nbinary data. The disadvantage is that it is an extra step for your\nusers/developers to perform, though you might be able to automate it.\n\n flatc -b myschema.fbs mydata.json\n\nThis will generate the binary file `mydata_wire.bin` which can be loaded\nas before.\n\n#### Making your program capable of loading text directly\n\nThis gives you maximum flexibility. You could even opt to support both,\ni.e. check for both files, and regenerate the binary from text when\nrequired, otherwise just load the binary.\n\nThis option is currently only available for C++, or Java through JNI.\n\nAs mentioned in the section \"Building\" above, this technique requires\nyou to link a few more files into your program, and you'll want to include\n`flatbuffers/idl.h`.\n\nLoad text (either a schema or json) into an in-memory buffer (there is a\nconvenient `LoadFile()` utility function in `flatbuffers/util.h` if you\nwish). Construct a parser:\n\n```cpp\n flatbuffers::Parser parser;\n```\n\nNow you can parse any number of text files in sequence:\n\n```cpp\n parser.Parse(text_file.c_str());\n```\n\nThis works similarly to how the command-line compiler works: a sequence\nof files parsed by the same `Parser` object allow later files to\nreference definitions in earlier files. Typically this means you first\nload a schema file (which populates `Parser` with definitions), followed\nby one or more JSON files.\n\nAs optional argument to `Parse`, you may specify a null-terminated list of\ninclude paths. If not specified, any include statements try to resolve from\nthe current directory.\n\nIf there were any parsing errors, `Parse` will return `false`, and\n`Parser::error_` contains a human readable error string with a line number\netc, which you should present to the creator of that file.\n\nAfter each JSON file, the `Parser::fbb` member variable is the\n`FlatBufferBuilder` that contains the binary buffer version of that\nfile, that you can access as described above.\n\n`samples/sample_text.cpp` is a code sample showing the above operations.\n\n## Threading\n\nReading a FlatBuffer does not touch any memory outside the original buffer,\nand is entirely read-only (all const), so is safe to access from multiple\nthreads even without synchronisation primitives.\n\nCreating a FlatBuffer is not thread safe. All state related to building\na FlatBuffer is contained in a FlatBufferBuilder instance, and no memory\noutside of it is touched. To make this thread safe, either do not\nshare instances of FlatBufferBuilder between threads (recommended), or\nmanually wrap it in synchronisation primitives. There's no automatic way to\naccomplish this, by design, as we feel multithreaded construction\nof a single buffer will be rare, and synchronisation overhead would be costly.\n\n## Advanced union features\n\nThe C++ implementation currently supports vectors of unions (i.e. you can\ndeclare a field as `[T]` where `T` is a union type instead of a table type). It\nalso supports structs and strings in unions, besides tables.\n\nFor an example of these features, see `tests/union_vector`, and\n`UnionVectorTest` in `test.cpp`.\n\nSince these features haven't been ported to other languages yet, if you\nchoose to use them, you won't be able to use these buffers in other languages\n(`flatc` will refuse to compile a schema that uses these features).\n\nThese features reduce the amount of \"table wrapping\" that was previously\nneeded to use unions.\n\nTo use scalars, simply wrap them in a struct.\n\n## Depth limit of nested objects and stack-overflow control\nThe parser of Flatbuffers schema or json-files is kind of recursive parser.\nTo avoid stack-overflow problem the parser has a built-in limiter of\nrecursion depth. Number of nested declarations in a schema or number of\nnested json-objects is limited. By default, this depth limit set to `64`.\nIt is possible to override this limit with `FLATBUFFERS_MAX_PARSING_DEPTH`\ndefinition. This definition can be helpful for testing purposes or embedded\napplications. For details see [build](../building.md) of\nCMake-based projects.\n\n## Dependence from C-locale {#flatbuffers_locale_cpp}\nThe Flatbuffers [grammar](../grammar.md) uses ASCII\ncharacter set for identifiers, alphanumeric literals, reserved words.\n\nInternal implementation of the Flatbuffers depends from functions which\ndepend from C-locale: `strtod()` or `strtof()`, for example.\nThe library expects the dot `.` symbol as the separator of an integer\npart from the fractional part of a float number.\nAnother separator symbols (`,` for example) will break the compatibility\nand may lead to an error while parsing a Flatbuffers schema or a json file.\n\nThe Standard C locale is a global resource, there is only one locale for\nthe entire application. Some modern compilers and platforms have\nlocale-independent or locale-narrow functions `strtof_l`, `strtod_l`,\n`strtoll_l`, `strtoull_l` to resolve this dependency.\nThese functions use specified locale rather than the global or per-thread\nlocale instead. They are part of POSIX-2008 but not part of the C/C++\nstandard library, therefore, may be missing on some platforms.\nThe Flatbuffers library try to detect these functions at configuration and\ncompile time:\n- CMake `\"CMakeLists.txt\"`:\n - Check existence of `strtol_l` and `strtod_l` in the ``.\n- Compile-time `\"/include/base.h\"`:\n - `_MSC_VER >= 1900`: MSVC2012 or higher if build with MSVC.\n - `_XOPEN_SOURCE>=700`: POSIX-2008 if build with GCC/Clang.\n\nAfter detection, the definition `FLATBUFFERS_LOCALE_INDEPENDENT` will be\nset to `0` or `1`.\nTo override or stop this detection use CMake `-DFLATBUFFERS_LOCALE_INDEPENDENT={0|1}`\nor predefine `FLATBUFFERS_LOCALE_INDEPENDENT` symbol.\n\nTo test the compatibility of the Flatbuffers library with\na specific locale use the environment variable `FLATBUFFERS_TEST_LOCALE`:\n```sh\n>FLATBUFFERS_TEST_LOCALE=\"\" ./flattests\n>FLATBUFFERS_TEST_LOCALE=\"ru_RU.CP1251\" ./flattests\n```\n\n## Support of floating-point numbers\nThe Flatbuffers library assumes that a C++ compiler and a CPU are\ncompatible with the `IEEE-754` floating-point standard.\nThe schema and json parser may fail if `fast-math` or `/fp:fast` mode is active.\n\n### Support of hexadecimal and special floating-point numbers\nAccording to the [grammar](../grammar.md) `fbs` and `json` files\nmay use hexadecimal and special (`NaN`, `Inf`) floating-point literals.\nThe Flatbuffers uses `strtof` and `strtod` functions to parse floating-point\nliterals. The Flatbuffers library has a code to detect a compiler compatibility\nwith the literals. If necessary conditions are met the preprocessor constant\n`FLATBUFFERS_HAS_NEW_STRTOD` will be set to `1`.\nThe support of floating-point literals will be limited at compile time\nif `FLATBUFFERS_HAS_NEW_STRTOD` constant is less than `1`.\nIn this case, schemas with hexadecimal or special literals cannot be used.\n\n### Comparison of floating-point NaN values\nThe floating-point `NaN` (`not a number`) is special value which\nrepresenting an undefined or unrepresentable value.\n`NaN` may be explicitly assigned to variables, typically as a representation\nfor missing values or may be a result of a mathematical operation.\nThe `IEEE-754` defines two kind of `NaNs`:\n- Quiet NaNs, or `qNaNs`.\n- Signaling NaNs, or `sNaNs`.\n\nAccording to the `IEEE-754`, a comparison with `NaN` always returns\nan unordered result even when compared with itself. As a result, a whole\nFlatbuffers object will be not equal to itself if has one or more `NaN`.\nFlatbuffers scalar fields that have the default value are not actually stored\nin the serialized data but are generated in code (see [Writing a schema](../schema.md)).\nScalar fields with `NaN` defaults break this behavior.\nIf a schema has a lot of `NaN` defaults the Flatbuffers can override\nthe unordered comparison by the ordered: `(NaN==NaN)->true`.\nThis ordered comparison is enabled when compiling a program with the symbol\n`FLATBUFFERS_NAN_DEFAULTS` defined.\nAdditional computations added by `FLATBUFFERS_NAN_DEFAULTS` are very cheap\nif GCC or Clang used. These compilers have a compile-time implementation\nof `isnan` checking which MSVC does not.\n\n## gRPC\n\n### Before you get started\n\nBefore diving into the FlatBuffers gRPC usage in C++, you should already be\nfamiliar with the following:\n\n- FlatBuffers as a serialization format\n- [gRPC](http://www.grpc.io/docs/) usage\n\n### Using the FlatBuffers gRPC C++ library\n\nNOTE: The examples below are also in the `grpc/samples/greeter` directory.\n\nWe will illustrate usage with the following schema:\n\n```c++ title=\"grpc/samples/greeter/greeter.fbs\"\n--8<-- \"https://raw.githubusercontent.com/google/flatbuffers/refs/heads/master/grpc/samples/greeter/greeter.fbs\"\n```\n\nWhen we run `flatc`, we pass in the `--grpc` option and generage an additional\n`greeter.grpc.fb.h` and `greeter.grpc.fb.cc`.\n\nExample server code looks like this:\n\n```c++ title=\"grpc/samples/greeter/server.cpp\"\n--8<-- \"https://raw.githubusercontent.com/google/flatbuffers/refs/heads/master/grpc/samples/greeter/server.cpp\"\n```\n\nExample client code looks like this:\n\n```c++ title=\"grpc/samples/greeter/client.cpp\"\n--8<-- \"https://raw.githubusercontent.com/google/flatbuffers/refs/heads/master/grpc/samples/greeter/client.cpp\"\n```\n\n" }, { "path": "docs/source/languages/dart.md", "content": "Use in Dart {#flatbuffers_guide_use_dart}\n===========\n\n## Before you get started\n\nBefore diving into the FlatBuffers usage in Dart, it should be noted that\nthe [Tutorial](../tutorial.md) page has a complete guide\nto general FlatBuffers usage in all of the supported languages (including Dart).\nThis page is designed to cover the nuances of FlatBuffers usage, specific to\nDart.\n\nYou should also have read the [Building](../building.md)\ndocumentation to build `flatc` and should be familiar with\n[Using the schema compiler](../flatc.md) and\n[Writing a schema](../schema.md).\n\n## FlatBuffers Dart library code location\n\nThe code for the FlatBuffers Dart library can be found at\n`flatbuffers/dart`. You can browse the library code on the [FlatBuffers\nGitHub page](https://github.com/google/flatbuffers/tree/master/dart).\n\n## Testing the FlatBuffers Dart library\n\nThe code to test the Dart library can be found at `flatbuffers/tests`.\nThe test code itself is located in [dart_test.dart](https://github.com/google/\nflatbuffers/blob/master/tests/dart_test.dart).\n\nTo run the tests, use the [DartTest.sh](https://github.com/google/flatbuffers/\nblob/master/tests/DartTest.sh) shell script.\n\n*Note: The shell script requires the [Dart SDK](https://www.dartlang.org/tools/sdk)\nto be installed.*\n\n## Using the FlatBuffers Dart library\n\n*Note: See [Tutorial](../tutorial.md) for a more in-depth\nexample of how to use FlatBuffers in Dart.*\n\nFlatBuffers supports reading and writing binary FlatBuffers in Dart.\n\nTo use FlatBuffers in your own code, first generate Dart classes from your\nschema with the `--dart` option to `flatc`. Then you can include both FlatBuffers\nand the generated code to read or write a FlatBuffer.\n\nFor example, here is how you would read a FlatBuffer binary file in Dart: First,\ninclude the library and generated code. Then read a FlatBuffer binary file into\na `List`, which you pass to the factory constructor for `Monster`:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.dart}\nimport 'dart:io' as io;\n\nimport 'package:flat_buffers/flat_buffers.dart' as fb;\nimport './monster_my_game.sample_generated.dart' as myGame;\n\nList data = await new io.File('monster.dat').readAsBytes();\nvar monster = new myGame.Monster(data);\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nNow you can access values like this:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.dart}\nvar hp = monster.hp;\nvar pos = monster.pos;\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n## Differences from the Dart SDK Front End flat_buffers\n\nThe work in this repository is signfiicantly based on the implementation used\ninternally by the Dart SDK in the front end/analyzer package. Several\nsignificant changes have been made.\n\n1. Support for packed boolean lists has been removed. This is not standard\n in other implementations and is not compatible with them. Do note that,\n like in the JavaScript implementation, __null values in boolean lists\n will be treated as false__. It is also still entirely possible to pack data\n in a single scalar field, but that would have to be done on the application\n side.\n2. The SDK implementation supports enums with regular Dart enums, which\n works if enums are always indexed at 1; however, FlatBuffers does not\n require that. This implementation uses specialized enum-like classes to\n ensure proper mapping from FlatBuffers to Dart and other platforms.\n3. The SDK implementation does not appear to support FlatBuffer structs or\n vectors of structs - it treated everything as a built-in scalar or a table.\n This implementation treats structs in a way that is compatible with other\n non-Dart implementations, and properly handles vectors of structs. Many of\n the methods prefixed with 'low' have been prepurposed to support this.\n4. The SDK implementation treats int64 and uint64 as float64s. This\n implementation does not. This may cause problems with JavaScript\n compatibility - however, it should be possible to use the JavaScript\n implementation, or to do a customized implementation that treats all 64 bit\n numbers as floats. Supporting the Dart VM and Flutter was a more important\n goal of this implementation. Support for 16 bit integers was also added.\n5. The code generation in this offers an \"ObjectBuilder\", which generates code\n very similar to the SDK classes that consume FlatBuffers, as well as Builder\n classes, which produces code which more closely resembles the builders in\n other languages. The ObjectBuilder classes are easier to use, at the cost of\n additional references allocated.\n\n## Text Parsing\n\nThere currently is no support for parsing text (Schema's and JSON) directly\nfrom Dart, though you could use the C++ parser through Dart Native Extensions.\nPlease see the C++ documentation for more on text parsing (note that this is\nnot currently an option in Flutter - follow [this issue](https://github.com/flutter/flutter/issues/7053)\nfor the latest).\n\n## Object based API\n\nFlatBuffers is all about memory efficiency, which is why its base API is written\naround using as little as possible of it. This does make the API clumsier\n(requiring pre-order construction of all data, and making mutation harder).\n\nFor times when efficiency is less important a more convenient object based API\ncan be used (through `--gen-object-api`) that is able to unpack & pack a FlatBuffer\ninto objects and lists, allowing for convenient construction, access and mutation.\n\nTo use:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.dart}\n // Deserialize from buffer into object.\n MonsterT monster = Monster(flatbuffer).unpack();\n\n // Update object directly like a Dart class instance.\n print(monster.Name);\n monster.Name = \"Bob\"; // Change the name.\n\n // Serialize into new flatbuffer.\n final fbb = Builder();\n fbb.Finish(monster.pack(fbb));\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" }, { "path": "docs/source/languages/go.md", "content": "Use in Go {#flatbuffers_guide_use_go}\n=========\n\n## Before you get started\n\nBefore diving into the FlatBuffers usage in Go, it should be noted that\nthe [Tutorial](../tutorial.md) page has a complete guide\nto general FlatBuffers usage in all of the supported languages (including Go).\nThis page is designed to cover the nuances of FlatBuffers usage, specific to\nGo.\n\nYou should also have read the [Building](../building.md)\ndocumentation to build `flatc` and should be familiar with\n[Using the schema compiler](../flatc.md) and\n[Writing a schema](../schema.md).\n\n## FlatBuffers Go library code location\n\nThe code for the FlatBuffers Go library can be found at\n`flatbuffers/go`. You can browse the library code on the [FlatBuffers\nGitHub page](https://github.com/google/flatbuffers/tree/master/go).\n\n## Testing the FlatBuffers Go library\n\nThe code to test the Go library can be found at `flatbuffers/tests`.\nThe test code itself is located in [go_test.go](https://github.com/google/\nflatbuffers/blob/master/tests/go_test.go).\n\nTo run the tests, use the [GoTest.sh](https://github.com/google/flatbuffers/\nblob/master/tests/GoTest.sh) shell script.\n\n*Note: The shell script requires [Go](https://golang.org/doc/install) to\nbe installed.*\n\n## Using the FlatBuffers Go library\n\n*Note: See [Tutorial](../tutorial.md) for a more in-depth\nexample of how to use FlatBuffers in Go.*\n\nFlatBuffers supports reading and writing binary FlatBuffers in Go.\n\nTo use FlatBuffers in your own code, first generate Go classes from your\nschema with the `--go` option to `flatc`. Then you can include both FlatBuffers\nand the generated code to read or write a FlatBuffer.\n\nFor example, here is how you would read a FlatBuffer binary file in Go: First,\ninclude the library and generated code. Then read a FlatBuffer binary file into\na `[]byte`, which you pass to the `GetRootAsMonster` function:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.go}\n import (\n example \"MyGame/Example\"\n flatbuffers \"github.com/google/flatbuffers/go\"\n\n \"os\"\n )\n\n buf, err := os.ReadFile(\"monster.dat\")\n // handle err\n monster := example.GetRootAsMonster(buf, 0)\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nNow you can access values like this:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.go}\n hp := monster.Hp()\n pos := monster.Pos(nil)\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n\nIn some cases it's necessary to modify values in an existing FlatBuffer in place (without creating a copy). For this reason, scalar fields of a Flatbuffer table or struct can be mutated.\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.go}\n monster := example.GetRootAsMonster(buf, 0)\n\n // Set table field.\n if ok := monster.MutateHp(10); !ok {\n panic(\"failed to mutate Hp\")\n }\n\n // Set struct field.\n monster.Pos().MutateZ(4)\n\n // This mutation will fail because the mana field is not available in\n // the buffer. It should be set when creating the buffer.\n if ok := monster.MutateMana(20); !ok {\n panic(\"failed to mutate Hp\")\n }\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe term `mutate` is used instead of `set` to indicate that this is a special use case. All mutate functions return a boolean value which is false if the field we're trying to mutate is not available in the buffer.\n\n## Text Parsing\n\nThere currently is no support for parsing text (Schema's and JSON) directly\nfrom Go, though you could use the C++ parser through cgo. Please see the\nC++ documentation for more on text parsing.\n\n
\n" }, { "path": "docs/source/languages/java.md", "content": "Use in Java {#flatbuffers_guide_use_java}\n==============\n\n## Before you get started\n\nBefore diving into the FlatBuffers usage in Java, it should be noted that\nthe [Tutorial](../tutorial.md) page has a complete guide to\ngeneral FlatBuffers usage in all of the supported languages (including Java).\nThis page is designed to cover the nuances of FlatBuffers usage,\nspecific to Java.\n\nYou should also have read the [Building](../building.md)\ndocumentation to build `flatc` and should be familiar with\n[Using the schema compiler](../flatc.md) and\n[Writing a schema](../schema.md).\n\n## FlatBuffers Java code location\n\nThe code for the FlatBuffers Java library can be found at\n`flatbuffers/java/com/google/flatbuffers`. You can browse the library on the\n[FlatBuffers GitHub page](https://github.com/google/flatbuffers/tree/master/\njava/com/google/flatbuffers).\n\n## Testing the FlatBuffers Java libraries\n\nThe code to test the libraries can be found at `flatbuffers/tests`.\n\nThe test code for Java is located in [JavaTest.java](https://github.com/google\n/flatbuffers/blob/master/tests/JavaTest.java).\n\nTo run the tests, use either [JavaTest.sh](https://github.com/google/\nflatbuffers/blob/master/tests/JavaTest.sh) or [JavaTest.bat](https://github.com/\ngoogle/flatbuffers/blob/master/tests/JavaTest.bat), depending on your operating\nsystem.\n\n*Note: These scripts require that [Java](https://www.oracle.com/java/index.html)\nis installed.*\n\n## Using the FlatBuffers Java library\n\n*Note: See [Tutorial](../tutorial.md) for a more in-depth\nexample of how to use FlatBuffers in Java.*\n\nFlatBuffers supports reading and writing binary FlatBuffers in Java.\n\nTo use FlatBuffers in your own code, first generate Java classes from your\nschema with the `--java` option to `flatc`.\nThen you can include both FlatBuffers and the generated code to read\nor write a FlatBuffer.\n\nFor example, here is how you would read a FlatBuffer binary file in Java:\nFirst, import the library and generated code. Then, you read a FlatBuffer binary\nfile into a `byte[]`. You then turn the `byte[]` into a `ByteBuffer`, which you\npass to the `getRootAsMyRootType` function:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.java}\n import MyGame.Example.*;\n import com.google.flatbuffers.FlatBufferBuilder;\n\n // This snippet ignores exceptions for brevity.\n File file = new File(\"monsterdata_test.mon\");\n RandomAccessFile f = new RandomAccessFile(file, \"r\");\n byte[] data = new byte[(int)f.length()];\n f.readFully(data);\n f.close();\n\n ByteBuffer bb = ByteBuffer.wrap(data);\n Monster monster = Monster.getRootAsMonster(bb);\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nNow you can access the data from the `Monster monster`:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.java}\n short hp = monster.hp();\n Vec3 pos = monster.pos();\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n## Storing dictionaries in a FlatBuffer\n\nFlatBuffers doesn't support dictionaries natively, but there is support to\nemulate their behavior with vectors and binary search, which means you\ncan have fast lookups directly from a FlatBuffer without having to unpack\nyour data into a `Dictionary` or similar.\n\nTo use it:\n- Designate one of the fields in a table as the \"key\" field. You do this\n by setting the `key` attribute on this field, e.g.\n `name:string (key)`.\n You may only have one key field, and it must be of string or scalar type.\n- Write out tables of this type as usual, collect their offsets in an\n array.\n- Instead of calling standard generated method,\n e.g.: `Monster.createTestarrayoftablesVector`,\n call `createSortedVectorOfTables` (from the `FlatBufferBuilder` object).\n which will first sort all offsets such that the tables they refer to\n are sorted by the key field, then serialize it.\n- Now when you're accessing the FlatBuffer, you can use\n the `ByKey` accessor to access elements of the vector, e.g.:\n `monster.testarrayoftablesByKey(\"Frodo\")`.\n which returns an object of the corresponding table type,\n or `null` if not found.\n `ByKey` performs a binary search, so should have a similar\n speed to `Dictionary`, though may be faster because of better caching.\n `ByKey` only works if the vector has been sorted, it will\n likely not find elements if it hasn't been sorted.\n\n## Text parsing\n\nThere currently is no support for parsing text (Schema's and JSON) directly\nfrom Java, though you could use the C++ parser through native call\ninterfaces available to each language. Please see the\nC++ documentation for more on text parsing.\n\n
\n" }, { "path": "docs/source/languages/javascript.md", "content": "Use in JavaScript {#flatbuffers_guide_use_javascript}\n=================\n\n## Before you get started\n\nBefore diving into the FlatBuffers usage in JavaScript, it should be noted that\nthe [Tutorial](../tutorial.md) page has a complete guide to\ngeneral FlatBuffers usage in all of the supported languages\n(including JavaScript). This page is specifically designed to cover the nuances\nof FlatBuffers usage in JavaScript.\n\nYou should also have read the [Building](../building.md)\ndocumentation to build `flatc` and should be familiar with\n[Using the schema compiler](../flatc.md) and\n[Writing a schema](../schema.md).\n\n## FlatBuffers JavaScript library code location\n\nThe generated code for the FlatBuffers JavaScript library can be found at\nhttps://www.npmjs.com/package/flatbuffers. To use it from sources:\n\n1. Run `npm run compile` from the main folder to generate JS files from TS.\n1. In your project, install it as a normal dependency, using the flatbuffers\nfolder as the source.\n\n## Using the FlatBuffers JavaScript library\n\n*Note: See [Tutorial](../tutorial.md) for a more in-depth\nexample of how to use FlatBuffers.*\n\nDue to the complexity related with large amounts of JS flavors and module types,\nnative JS support has been replaced in 2.0 by transpilation from TypeScript.\n\nPlease look at [TypeScript usage](typescript.md) and\ntranspile your sources to desired JS flavor. The minimal steps to get up and\nrunning with JS are:\n\n1. Generate TS files from `*.fbs` by using the `--ts` option.\n1. Transpile resulting TS files to desired JS flavor using `tsc` (see\n https://www.typescriptlang.org/download for installation instructions).\n\n~~~{.js}\n // Note: These require functions are an example - use your desired module flavor.\n var fs = require('fs');\n\n var flatbuffers = require('../flatbuffers').flatbuffers;\n var MyGame = require('./monster_generated').MyGame;\n\n var data = new Uint8Array(fs.readFileSync('monster.dat'));\n var buf = new flatbuffers.ByteBuffer(data);\n\n var monster = MyGame.Example.Monster.getRootAsMonster(buf);\n\n //--------------------------------------------------------------------------//\n\n // Note: This code is an example of browser-based HTML/JavaScript. See above\n // for the code using JavaScript module loaders (e.g. Node.js).\n \n \n \n\n // Open the HTML file in a browser and select \"monster.dat\" from with the\n // field.\n \n~~~\n\nNow you can access values like this:\n\n~~~{.js}\n var hp = monster.hp();\n var pos = monster.pos();\n~~~\n\n## Text parsing FlatBuffers in JavaScript\n\nThere currently is no support for parsing text (Schema's and JSON) directly\nfrom JavaScript.\n" }, { "path": "docs/source/languages/kotlin.md", "content": "Use in Kotlin {#flatbuffers_guide_use_kotlin}\n==============\n\n## Before you get started\n\nBefore diving into the FlatBuffers usage in Kotlin, it should be noted that\nthe [Tutorial](../tutorial.md) page has a complete guide to\ngeneral FlatBuffers usage in all of the supported languages (including K).\n\nThis page is designed to cover the nuances of FlatBuffers usage, specific to Kotlin.\n\nYou should also have read the [Building](../building.md)\ndocumentation to build `flatc` and should be familiar with\n[Using the schema compiler](../flatc.md) and\n[Writing a schema](../schema.md).\n\n## Kotlin and FlatBuffers Java code location\n\nCode generated for Kotlin currently uses the flatbuffers java runtime library. That means that Kotlin generated code can only have Java virtual machine as target architecture (which includes Android). Kotlin Native and Kotlin.js are currently not supported.\n\nThe code for the FlatBuffers Java library can be found at\n`flatbuffers/java/com/google/flatbuffers`. You can browse the library on the\n[FlatBuffers GitHub page](https://github.com/google/flatbuffers/tree/master/\njava/com/google/flatbuffers).\n\n## Testing FlatBuffers Kotlin\n\nThe test code for Java is located in [KotlinTest.java](https://github.com/google\n/flatbuffers/blob/master/tests/KotlinTest.kt).\n\nTo run the tests, use [KotlinTest.sh](https://github.com/google/\nflatbuffers/blob/master/tests/KotlinTest.sh) shell script.\n\n*Note: These scripts require that [Kotlin](https://kotlinlang.org/) is installed.*\n\n## Using the FlatBuffers Kotlin library\n\n*Note: See [Tutorial](../tutorial.md) for a more in-depth\nexample of how to use FlatBuffers in Kotlin.*\n\nFlatBuffers supports reading and writing binary FlatBuffers in Kotlin.\n\nTo use FlatBuffers in your own code, first generate Java classes from your\nschema with the `--kotlin` option to `flatc`.\nThen you can include both FlatBuffers and the generated code to read\nor write a FlatBuffer.\n\nFor example, here is how you would read a FlatBuffer binary file in Kotlin:\nFirst, import the library and generated code. Then, you read a FlatBuffer binary\nfile into a `ByteArray`. You then turn the `ByteArray` into a `ByteBuffer`, which you\npass to the `getRootAsMyRootType` function:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.kt}\n import MyGame.Example.*\n import com.google.flatbuffers.FlatBufferBuilder\n\n // This snippet ignores exceptions for brevity.\n val data = RandomAccessFile(File(\"monsterdata_test.mon\"), \"r\").use {\n val temp = ByteArray(it.length().toInt())\n it.readFully(temp)\n temp\n }\n\n val bb = ByteBuffer.wrap(data)\n val monster = Monster.getRootAsMonster(bb)\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nNow you can access the data from the `Monster monster`:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.kt}\n val hp = monster.hp\n val pos = monster.pos!!;\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n\n\n## Differences between Kotlin and Java code\n\nKotlin generated code was designed to be as close as possible to the java counterpart, as for now, we only support kotlin on java virtual machine. So the differences in implementation and usage are basically the ones introduced by the Kotlin language itself. You can find more in-depth information [here](https://kotlinlang.org/docs/reference/comparison-to-java.html).\n\nThe most obvious ones are:\n\n* Fields as accessed as Kotlin [properties](https://kotlinlang.org/docs/reference/properties.html)\n* Static methods are accessed in [companion object](https://kotlinlang.org/docs/reference/classes.html#companion-objects)\n" }, { "path": "docs/source/languages/lobster.md", "content": "Use in Lobster {#flatbuffers_guide_use_lobster}\n==============\n\n## Before you get started\n\nBefore diving into the FlatBuffers usage in Lobster, it should be noted that the\n[Tutorial](../tutorial.md) page has a complete guide to general\nFlatBuffers usage in all of the supported languages (including Lobster). This\npage is designed to cover the nuances of FlatBuffers usage, specific to\nLobster.\n\nYou should also have read the [Building](../building.md)\ndocumentation to build `flatc` and should be familiar with\n[Using the schema compiler](../flatc.md) and\n[Writing a schema](../schema.md).\n\n## FlatBuffers Lobster library code location\n\nThe code for the FlatBuffers Lobster library can be found at\n`flatbuffers/lobster`. You can browse the library code on the\n[FlatBuffers GitHub page](https://github.com/google/flatbuffers/tree/master/\nlobster).\n\n## Testing the FlatBuffers Lobster library\n\nThe code to test the Lobster library can be found at `flatbuffers/tests`.\nThe test code itself is located in [lobstertest.lobster](https://github.com/google/\nflatbuffers/blob/master/tests/lobstertest.lobster).\n\nTo run the tests, run `lobster lobstertest.lobster`. To obtain Lobster itself,\ngo to the [Lobster homepage](http://strlen.com/lobster) or\n[github](https://github.com/aardappel/lobster) to learn how to build it for your\nplatform.\n\n## Using the FlatBuffers Lobster library\n\n*Note: See [Tutorial](../tutorial.md) for a more in-depth\nexample of how to use FlatBuffers in Lobster.*\n\nThere is support for both reading and writing FlatBuffers in Lobster.\n\nTo use FlatBuffers in your own code, first generate Lobster classes from your\nschema with the `--lobster` option to `flatc`. Then you can include both\nFlatBuffers and the generated code to read or write a FlatBuffer.\n\nFor example, here is how you would read a FlatBuffer binary file in Lobster:\nFirst, import the library and the generated code. Then read a FlatBuffer binary\nfile into a string, which you pass to the `GetRootAsMonster` function:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.lobster}\n include \"monster_generated.lobster\"\n\n let fb = read_file(\"monsterdata_test.mon\")\n assert fb\n let monster = MyGame_Example_GetRootAsMonster(fb)\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nNow you can access values like this:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.lobster}\n let hp = monster.hp\n let pos = monster.pos\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nAs you can see, even though `hp` and `pos` are functions that access FlatBuffer\ndata in-place in the string buffer, they appear as field accesses.\n\n## Speed\n\nUsing FlatBuffers in Lobster should be relatively fast, as the implementation\nmakes use of native support for writing binary values, and access of vtables.\nBoth generated code and the runtime library are therefore small and fast.\n\nActual speed will depend on whether you use Lobster as bytecode VM or compiled to\nC++.\n\n## Text Parsing\n\nLobster has full support for parsing JSON into FlatBuffers, or generating\nJSON from FlatBuffers. See `samples/sample_test.lobster` for an example.\n\nThis uses the C++ parser and generator underneath, so should be both fast and\nconformant.\n\n
\n" }, { "path": "docs/source/languages/lua.md", "content": "Use in Lua {#flatbuffers_guide_use_lua}\n=============\n\n## Before you get started\n\nBefore diving into the FlatBuffers usage in Lua, it should be noted that the\n[Tutorial](../tutorial.md) page has a complete guide to general\nFlatBuffers usage in all of the supported languages (including Lua). This\npage is designed to cover the nuances of FlatBuffers usage, specific to\nLua.\n\nYou should also have read the [Building](../building.md)\ndocumentation to build `flatc` and should be familiar with\n[Using the schema compiler](../flatc.md) and\n[Writing a schema](../schema.md).\n\n## FlatBuffers Lua library code location\n\nThe code for the FlatBuffers Lua library can be found at\n`flatbuffers/lua`. You can browse the library code on the\n[FlatBuffers GitHub page](https://github.com/google/flatbuffers/tree/master/lua).\n\n## Testing the FlatBuffers Lua library\n\nThe code to test the Lua library can be found at `flatbuffers/tests`.\nThe test code itself is located in [luatest.lua](https://github.com/google/\nflatbuffers/blob/master/tests/luatest.lua).\n\nTo run the tests, use the [LuaTest.sh](https://github.com/google/flatbuffers/\nblob/master/tests/LuaTest.sh) shell script.\n\n*Note: This script requires [Lua 5.3](https://www.lua.org/) and\n[LuaJIT](http://luajit.org/) to be installed.*\n\n## Using the FlatBuffers Lua library\n\n*Note: See [Tutorial](../tutorial.md) for a more in-depth\nexample of how to use FlatBuffers in Lua.*\n\nThere is support for both reading and writing FlatBuffers in Lua.\n\nTo use FlatBuffers in your own code, first generate Lua classes from your\nschema with the `--lua` option to `flatc`. Then you can include both\nFlatBuffers and the generated code to read or write a FlatBuffer.\n\nFor example, here is how you would read a FlatBuffer binary file in Lua:\nFirst, require the module and the generated code. Then read a FlatBuffer binary\nfile into a `string`, which you pass to the `GetRootAsMonster` function:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.lua}\n -- require the library\n local flatbuffers = require(\"flatbuffers\")\n\n -- require the generated code\n local monster = require(\"MyGame.Sample.Monster\")\n\n -- read the flatbuffer from a file into a string\n local f = io.open('monster.dat', 'rb')\n local buf = f:read('*a')\n f:close()\n\n -- parse the flatbuffer to get an instance to the root monster\n local monster1 = monster.GetRootAsMonster(buf, 0)\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nNow you can access values like this:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.lua}\n -- use the : notation to access member data\n local hp = monster1:Hp()\n local pos = monster1:Pos()\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n\n## Text Parsing\n\nThere currently is no support for parsing text (Schema's and JSON) directly\nfrom Lua, though you could use the C++ parser through SWIG or ctypes. Please\nsee the C++ documentation for more on text parsing.\n\n
\n" }, { "path": "docs/source/languages/php.md", "content": "Use in PHP {#flatbuffers_guide_use_php}\n==========\n\n## Before you get started\n\nBefore diving into the FlatBuffers usage in PHP, it should be noted that\nthe [Tutorial](../tutorial.md) page has a complete guide to\ngeneral FlatBuffers usage in all of the supported languages\n(including PHP). This page is specifically designed to cover the nuances of\nFlatBuffers usage in PHP.\n\nYou should also have read the [Building](../building.md)\ndocumentation to build `flatc` and should be familiar with\n[Using the schema compiler](../flatc.md) and\n[Writing a schema](../schema.md).\n\n## FlatBuffers PHP library code location\n\nThe code for FlatBuffers PHP library can be found at `flatbuffers/php`. You\ncan browse the library code on the [FlatBuffers\nGitHub page](https://github.com/google/flatbuffers/tree/master/php).\n\n## Testing the FlatBuffers JavaScript library\n\nThe code to test the PHP library can be found at `flatbuffers/tests`.\nThe test code itself is located in [phpTest.php](https://github.com/google/\nflatbuffers/blob/master/tests/phpTest.php).\n\nYou can run the test with `php phpTest.php` from the command line.\n\n*Note: The PHP test file requires\n[PHP](http://php.net/manual/en/install.php) to be installed.*\n\n## Using theFlatBuffers PHP library\n\n*Note: See [Tutorial](../tutorial.md) for a more in-depth\nexample of how to use FlatBuffers in PHP.*\n\nFlatBuffers supports both reading and writing FlatBuffers in PHP.\n\nTo use FlatBuffers in your own code, first generate PHP classes from your schema\nwith the `--php` option to `flatc`. Then you can include both FlatBuffers and\nthe generated code to read or write a FlatBuffer.\n\nFor example, here is how you would read a FlatBuffer binary file in PHP:\nFirst, include the library and generated code (using the PSR `autoload`\nfunction). Then you can read a FlatBuffer binary file, which you\npass the contents of to the `GetRootAsMonster` function:\n\n~~~{.php}\n // It is recommended that you use PSR autoload when using FlatBuffers in PHP.\n // Here is an example:\n function __autoload($class_name) {\n // The last segment of the class name matches the file name.\n $class = substr($class_name, strrpos($class_name, \"\\\\\") + 1);\n $root_dir = join(DIRECTORY_SEPARATOR, array(dirname(dirname(__FILE__)))); // `flatbuffers` root.\n\n // Contains the `*.php` files for the FlatBuffers library and the `flatc` generated files.\n $paths = array(join(DIRECTORY_SEPARATOR, array($root_dir, \"php\")),\n join(DIRECTORY_SEPARATOR, array($root_dir, \"tests\", \"MyGame\", \"Example\")));\n foreach ($paths as $path) {\n $file = join(DIRECTORY_SEPARATOR, array($path, $class . \".php\"));\n if (file_exists($file)) {\n require($file);\n break;\n }\n }\n\n // Read the contents of the FlatBuffer binary file.\n $filename = \"monster.dat\";\n $handle = fopen($filename, \"rb\");\n $contents = fread($handle, filesize($filename));\n fclose($handle);\n\n // Pass the contents to `GetRootAsMonster`.\n $monster = \\MyGame\\Example\\Monster::GetRootAsMonster($contents);\n~~~\n\nNow you can access values like this:\n\n~~~{.php}\n $hp = $monster->GetHp();\n $pos = $monster->GetPos();\n~~~\n\n## Text Parsing\n\nThere currently is no support for parsing text (Schema's and JSON) directly\nfrom PHP.\n" }, { "path": "docs/source/languages/python.md", "content": "Use in Python {#flatbuffers_guide_use_python}\n=============\n\n## Before you get started\n\nBefore diving into the FlatBuffers usage in Python, it should be noted that the\n[Tutorial](../tutorial.md) page has a complete guide to general\nFlatBuffers usage in all of the supported languages (including Python). This\npage is designed to cover the nuances of FlatBuffers usage, specific to\nPython.\n\nYou should also have read the [Building](../building.md)\ndocumentation to build `flatc` and should be familiar with\n[Using the schema compiler](../flatc.md) and\n[Writing a schema](../schema.md).\n\n## FlatBuffers Python library code location\n\nThe code for the FlatBuffers Python library can be found at\n`flatbuffers/python/flatbuffers`. You can browse the library code on the\n[FlatBuffers GitHub page](https://github.com/google/flatbuffers/tree/master/\npython).\n\n## Testing the FlatBuffers Python library\n\nThe code to test the Python library can be found at `flatbuffers/tests`.\nThe test code itself is located in [py_test.py](https://github.com/google/\nflatbuffers/blob/master/tests/py_test.py).\n\nTo run the tests, use the [PythonTest.sh](https://github.com/google/flatbuffers/\nblob/master/tests/PythonTest.sh) shell script.\n\n*Note: This script requires [python](https://www.python.org/) to be\ninstalled.*\n\n## Using the FlatBuffers Python library\n\n*Note: See [Tutorial](../tutorial.md) for a more in-depth\nexample of how to use FlatBuffers in Python.*\n\nThere is support for both reading and writing FlatBuffers in Python.\n\nTo use FlatBuffers in your own code, first generate Python classes from your\nschema with the `--python` option to `flatc`. Then you can include both\nFlatBuffers and the generated code to read or write a FlatBuffer.\n\nFor example, here is how you would read a FlatBuffer binary file in Python:\nFirst, import the library and the generated code. Then read a FlatBuffer binary\nfile into a `bytearray`, which you pass to the `GetRootAsMonster` function:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.py}\n import MyGame.Example as example\n import flatbuffers\n\n buf = open('monster.dat', 'rb').read()\n buf = bytearray(buf)\n monster = example.GetRootAsMonster(buf, 0)\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nNow you can access values like this:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.py}\n hp = monster.Hp()\n pos = monster.Pos()\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n## Support for Numpy arrays\n\nThe Flatbuffers python library also has support for accessing scalar\nvectors as numpy arrays. This can be orders of magnitude faster than\niterating over the vector one element at a time, and is particularly\nuseful when unpacking large nested flatbuffers. The generated code for\na scalar vector will have a method `AsNumpy()`. In the\ncase of the Monster example, you could access the inventory vector\nlike this:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.py}\n inventory = monster.InventoryAsNumpy()\n # inventory is a numpy array of type np.dtype('uint8')\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\ninstead of\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.py}\n inventory = []\n for i in range(monster.InventoryLength()):\n inventory.append(int(monster.Inventory(i)))\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nNumpy is not a requirement. If numpy is not installed on your system,\nthen attempting to access one of the `*asNumpy()` methods will result\nin a `NumpyRequiredForThisFeature` exception.\n\n## Text Parsing\n\nThere currently is no support for parsing text (Schema's and JSON) directly\nfrom Python, though you could use the C++ parser through SWIG or ctypes. Please\nsee the C++ documentation for more on text parsing.\n\n
\n" }, { "path": "docs/source/languages/rust.md", "content": "Use in Rust {#flatbuffers_guide_use_rust}\n==========\n\n## Before you get started\n\nBefore diving into the FlatBuffers usage in Rust, it should be noted that\nthe [Tutorial](../tutorial.md) page has a complete guide\nto general FlatBuffers usage in all of the supported languages (including Rust).\nThis page is designed to cover the nuances of FlatBuffers usage, specific to\nRust.\n\n#### Prerequisites\n\nThis page assumes you have written a FlatBuffers schema and compiled it\nwith the Schema Compiler. If you have not, please see\n[Using the schema compiler](../flatc.md)\nand [Writing a schema](../schema.md).\n\nAssuming you wrote a schema, say `mygame.fbs` (though the extension doesn't\nmatter), you've generated a Rust file called `mygame_generated.rs` using the\ncompiler (e.g. `flatc --rust mygame.fbs` or via helpers listed in \"Useful\ntools created by others\" section bellow), you can now start using this in\nyour program by including the file. As noted, this header relies on the crate\n`flatbuffers`, which should be in your include `Cargo.toml`.\n\n## FlatBuffers Rust library code location\n\nThe code for the FlatBuffers Rust library can be found at\n`flatbuffers/rust`. You can browse the library code on the\n[FlatBuffers GitHub page](https://github.com/google/flatbuffers/tree/master/rust).\n\n## Testing the FlatBuffers Rust library\n\nThe code to test the Rust library can be found at `flatbuffers/tests/rust_usage_test`.\nThe test code itself is located in\n[integration_test.rs](https://github.com/google/flatbuffers/blob/master/tests/rust_usage_test/tests/integration_test.rs)\n\nThis test file requires `flatc` to be present. To review how to build the project,\nplease read the [Building](../building.md) documentation.\n\nTo run the tests, execute `RustTest.sh` from the `flatbuffers/tests` directory.\nFor example, on [Linux](https://en.wikipedia.org/wiki/Linux), you would simply\nrun: `cd tests && ./RustTest.sh`.\n\n*Note: The shell script requires [Rust](https://www.rust-lang.org) to\nbe installed.*\n\n## Using the FlatBuffers Rust library\n\n*Note: See [Tutorial](../tutorial.md) for a more in-depth\nexample of how to use FlatBuffers in Rust.*\n\nFlatBuffers supports both reading and writing FlatBuffers in Rust.\n\nTo use FlatBuffers in your code, first generate the Rust modules from your\nschema with the `--rust` option to `flatc`. Then you can import both FlatBuffers\nand the generated code to read or write FlatBuffers.\n\nFor example, here is how you would read a FlatBuffer binary file in Rust:\nFirst, include the library and generated code. Then read the file into\na `u8` vector, which you pass, as a byte slice, to `root_as_monster()`.\n\nThis full example program is available in the Rust test suite:\n[monster_example.rs](https://github.com/google/flatbuffers/blob/master/tests/rust_usage_test/bin/monster_example.rs)\n\nIt can be run by `cd`ing to the `rust_usage_test` directory and executing: `cargo run monster_example`.\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.rs}\n extern crate flatbuffers;\n\n #[allow(dead_code, unused_imports)]\n #[path = \"../../monster_test_generated.rs\"]\n mod monster_test_generated;\n pub use monster_test_generated::my_game;\n\n use std::io::Read;\n\n fn main() {\n let mut f = std::fs::File::open(\"../monsterdata_test.mon\").unwrap();\n let mut buf = Vec::new();\n f.read_to_end(&mut buf).expect(\"file reading failed\");\n\n let monster = my_game::example::root_as_monster(&buf[..]);\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n`monster` is of type `Monster`, and points to somewhere *inside* your\nbuffer (root object pointers are not the same as `buffer_pointer` !).\nIf you look in your generated header, you'll see it has\nconvenient accessors for all fields, e.g. `hp()`, `mana()`, etc:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.rs}\n println!(\"{}\", monster.hp()); // `80`\n println!(\"{}\", monster.mana()); // default value of `150`\n println!(\"{:?}\", monster.name()); // Some(\"MyMonster\")\n }\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n*Note: That we never stored a `mana` value, so it will return the default.*\n\n## Direct memory access\n\nAs you can see from the above examples, all elements in a buffer are\naccessed through generated accessors. This is because everything is\nstored in little endian format on all platforms (the accessor\nperforms a swap operation on big endian machines), and also because\nthe layout of things is generally not known to the user.\n\nFor structs, layout is deterministic and guaranteed to be the same\nacross platforms (scalars are aligned to their\nown size, and structs themselves to their largest member), and you\nare allowed to access this memory directly by using `safe_slice`\non the reference to a struct, or even an array of structs.\n\nTo compute offsets to sub-elements of a struct, make sure they\nare structs themselves, as then you can use the pointers to\nfigure out the offset without having to hardcode it. This is\nhandy for use of arrays of structs with calls like `glVertexAttribPointer`\nin OpenGL or similar APIs.\n\nIt is important to note is that structs are still little endian on all\nmachines, so the functions to enable tricks like this are only exposed on little\nendian machines. If you also ship on big endian machines, using an\n`#[cfg(target_endian = \"little\")]` attribute would be wise or your code will not\ncompile.\n\nThe special function `safe_slice` is implemented on Vector objects that are\nrepresented in memory the same way as they are represented on the wire. This\nfunction is always available on vectors of struct, bool, u8, and i8. It is\nconditionally-compiled on little-endian systems for all the remaining scalar\ntypes.\n\nThe FlatBufferBuilder function `create_vector_direct` is implemented for all\ntypes that are endian-safe to write with a `memcpy`. It is the write-equivalent\nof `safe_slice`.\n\n## Access of untrusted buffers\n\nThe safe Rust functions to interpret a slice as a table (`root`,\n`size_prefixed_root`, `root_with_opts`, and `size_prefixed_root_with_opts`)\nverify the data first. This has some performance cost, but is intended to be\nsafe for use on flatbuffers from untrusted sources. There are corresponding\n`unsafe` versions with names ending in `_unchecked` which skip this\nverification, and may access arbitrary memory.\n\nThe generated accessor functions access fields over offsets, which is\nvery quick. The current implementation uses these to access memory without any\nfurther bounds checking. All of the safe Rust APIs ensure the verifier is run\nover these flatbuffers before accessing them.\n\nWhen you're processing large amounts of data from a source you know (e.g.\nyour own generated data on disk), the `_unchecked` versions are acceptable, but\nwhen reading data from the network that can potentially have been modified by an\nattacker, it is desirable to use the safe versions which use the verifier.\n\n## Threading\n\nReading a FlatBuffer does not touch any memory outside the original buffer,\nand is entirely read-only (all immutable), so is safe to access from multiple\nthreads even without synchronisation primitives.\n\nCreating a FlatBuffer is not thread safe. All state related to building\na FlatBuffer is contained in a FlatBufferBuilder instance, and no memory\noutside of it is touched. To make this thread safe, either do not\nshare instances of FlatBufferBuilder between threads (recommended), or\nmanually wrap it in synchronisation primitives. There's no automatic way to\naccomplish this, by design, as we feel multithreaded construction\nof a single buffer will be rare, and synchronisation overhead would be costly.\n\nUnlike most other languages, in Rust these properties are exposed to and\nenforced by the type system. `flatbuffers::Table` and the generated table types\nare `Send + Sync`, indicating they may be freely shared across threads and data\nmay be accessed from any thread which receives a const (aka shared) reference.\nThere are no functions which require a mutable (aka exclusive) reference, which\nmeans all the available functions may be called like this.\n`flatbuffers::FlatBufferBuilder` is also `Send + Sync`, but all of the mutating\nfunctions require a mutable (aka exclusive) reference which can only be created\nwhen no other references to the `FlatBufferBuilder` exist, and may not be copied\nwithin the same thread, let alone to a second thread.\n\n## Reflection (& Resizing)\n\nThere is experimental support for reflection in FlatBuffers, allowing you to\nread and write data even if you don't know the exact format of a buffer, and\neven allows you to change sizes of strings in-place.\n\nThe way this works is very elegant; there is actually a FlatBuffer schema that\ndescribes schemas (\\!) which you can find in `reflection/reflection.fbs`.\nThe compiler, `flatc`, can write out any schemas it has just parsed as a binary\nFlatBuffer, corresponding to this meta-schema.\n\nLoading in one of these binary schemas at runtime allows you to traverse any\nFlatBuffer data that corresponds to it without knowing the exact format. You\ncan query what fields are present, and then read/write them after.\n\nFor convenient field manipulation, you can use the crate\n`flatbuffers-reflection` which includes both the generated code from the meta\nschema, as well as a lot of helper functions.\n\nAnd example of usage, for the time being, can be found in\n`tests/rust_reflection_test/src/lib.rs`. Two sets of APIs are provided:\n\n- [Unsafe getters/setters](https://docs.rs/flatbuffers-reflection/latest/flatbuffers_reflection/#functions),\n which you can use when you are processing trusted data (either from a source you know, or has been verified)\n\n- Safe getters in [SafeBuffer](https://docs.rs/flatbuffers-reflection/latest/flatbuffers_reflection/struct.SafeBuffer.html),\n which does verification when constructed so you can use it for any data source\n\n## Buffer pre allocation in a latency-sensitive context\n\nIn latency-sensitive applications, dynamic memory allocations can introduce unpredictable latency spikes. The `FlatBufferBuilder` internally uses several `Vec`s that may reallocate during serialization:\n\n- The backing buffer for the FlatBuffer data\n- `field_locs` for tracking field locations within tables\n- `written_vtable_revpos` for deduplicating vtables\n- `strings_pool` for shared string interning\n\nTo avoid allocations during serialization, you can preallocate all internal vectors upfront using the `with_internal_capacity` constructor:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.rs}\n // Preallocate: 1KB buffer, 8 field locations, 16 vtables, 32 shared strings\n let mut builder = FlatBufferBuilder::with_internal_capacity(1024, 8, 16, 32);\n\n // All subsequent operations will not allocate (if capacities are sufficient)\n let name = builder.create_shared_string(\"MyMonster\");\n // ... build your FlatBuffer ...\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThere are three variants available:\n\n- `with_internal_capacity(size, field_locs, vtables, strings)` - Creates a new builder with all capacities preallocated\n- `from_vec_with_internal_capacity(buffer, field_locs, vtables, strings)` - Reuses an existing `Vec` as the backing buffer\n- `new_in_with_internal_capacity(allocator, field_locs, vtables, strings)` - Uses a custom `Allocator` with preallocated internal vecs\n\nWhen combined with `reset()`, you can reuse the same builder across multiple serializations without any allocations after the initial setup:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.rs}\n let mut builder = FlatBufferBuilder::with_internal_capacity(1024, 8, 16, 32);\n\n loop {\n // Build a FlatBuffer (allocation-free if capacities are sufficient)\n let data = build_message(&mut builder);\n send(data);\n\n // Reset for reuse - clears state but retains allocated capacity\n builder.reset();\n }\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n## Useful tools created by others\n\n* [flatc-rust](https://github.com/frol/flatc-rust) - FlatBuffers compiler\n(flatc) as API for transparent `.fbs` to `.rs` code-generation via Cargo\nbuild scripts integration.\n\n
\n" }, { "path": "docs/source/languages/swift.md", "content": "Use in Swift {#flatbuffers_guide_use_swift}\n=========\n\n## Before you get started\n\nBefore diving into the FlatBuffers usage in Swift, it should be noted that\nthe [Tutorial](../tutorial.md) page has a complete guide\nto general FlatBuffers usage in all of the supported languages (including Swift).\nThis page is designed to cover the nuances of FlatBuffers usage, specific to\nSwift.\n\nYou should also have read the [Building](../building.md)\ndocumentation to build `flatc` and should be familiar with\n[Using the schema compiler](../flatc.md) and\n[Writing a schema](../schema.md).\n\n## FlatBuffers Swift library code location\n\nThe code for the FlatBuffers Swift library can be found at\n`flatbuffers/swift`. You can browse the library code on the [FlatBuffers\nGitHub page](https://github.com/google/flatbuffers/tree/master/swift).\n\n## Testing the FlatBuffers Swift library\n\nThe code to test the Swift library can be found at `flatbuffers/tests/swift/tests`.\nThe test code itself is located in [flatbuffers/tests/swift/tests](https://github.com/google/flatbuffers/blob/master/tests/swift/tests).\n\nTo run the tests, use the [SwiftTest.sh](https://github.com/google/flatbuffers/blob/master/tests/swift/tests/SwiftTest.sh) shell script.\n\n*Note: The shell script requires [Swift](https://swift.org) to\nbe installed.*\n\n## Using the FlatBuffers Swift library\n\n*Note: See [Tutorial](../tutorial.md) for a more in-depth\nexample of how to use FlatBuffers in Swift.*\n\nFlatBuffers supports reading and writing binary FlatBuffers in Swift.\n\nTo use FlatBuffers in your own code, first generate Swift structs from your\nschema with the `--swift` option to `flatc`. Then include FlatBuffers using `SPM` in\nby adding the path to `FlatBuffers/swift` into it. The generated code should also be\nadded to xcode or the path of the package you will be using. Note: sometimes xcode cant\nand wont see the generated files, so it's better that you copy them to xcode.\n\nFor example, here is how you would read a FlatBuffer binary file in Swift: First,\ninclude the library and copy thegenerated code. Then read a FlatBuffer binary file or\na data object from the server, which you can pass into the `GetRootAsMonster` function.\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.swift}\n import FlatBuffers\n\n typealias Monster1 = MyGame.Sample.Monster\n typealias Vec3 = MyGame.Sample.Vec3\n\n let path = FileManager.default.currentDirectoryPath\n let url = URL(fileURLWithPath: path, isDirectory: true).appendingPathComponent(\"monsterdata_test\").appendingPathExtension(\"mon\")\n guard let data = try? Data(contentsOf: url) else { return }\n\n let monster: Monster = try! getCheckedRoot(byteBuffer: &byteBuffer)\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nNow you can access values like this:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.swift}\n let hp = monster.hp\n let pos = monster.pos // uses native swift structs\n let pos = monster.mutablePos // uses flatbuffers structs\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n\nIn some cases it's necessary to modify values in an existing FlatBuffer in place (without creating a copy). For this reason, scalar fields of a Flatbuffer table or struct can be mutated.\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.swift}\n var byteBuffer = ByteBuffer(bytes: data)\n // Get an accessor to the root object inside the buffer.\n let monster: Monster = try! getCheckedRoot(byteBuffer: &byteBuffer)\n // let monster: Monster = getRoot(byteBuffer: &byteBuffer)\n\n if !monster.mutate(hp: 10) {\n fatalError(\"couldn't mutate\")\n }\n // mutate a struct field using flatbuffers struct\n // DONT use monster.pos to mutate since swift copy on write\n // will not mutate the value in the buffer\n let vec = monster.mutablePos.mutate(z: 4)\n\n // This mutation will fail because the mana field is not available in\n // the buffer. It should be set when creating the buffer.\n if !monster.mutate(mana: 20) {\n fatalError(\"couldn't mutate\")\n }\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe term `mutate` is used instead of `set` to indicate that this is a special use case. All mutate functions return a boolean value which is false if the field we're trying to mutate is not available in the buffer.\n\n
\n" }, { "path": "docs/source/languages/typescript.md", "content": "Use in TypeScript {#flatbuffers_guide_use_typescript}\n=================\n\n## Before you get started\n\nBefore diving into the FlatBuffers usage in TypeScript, it should be noted that\nthe [Tutorial](../tutorial.md) page has a complete guide to\ngeneral FlatBuffers usage in all of the supported languages\n(including TypeScript). This page is specifically designed to cover the nuances\nof FlatBuffers usage in TypeScript.\n\nYou should also have read the [Building](../building.md)\ndocumentation to build `flatc` and should be familiar with\n[Using the schema compiler](../flatc.md) and\n[Writing a schema](../schema.md).\n\n## FlatBuffers TypeScript library code location\n\nThe code for the FlatBuffers TypeScript library can be found at\nhttps://www.npmjs.com/package/flatbuffers.\n\n## Testing the FlatBuffers TypeScript library\n\nTo run the tests, use the [TypeScriptTest.py](https://github.com/google/\nflatbuffers/blob/master/tests/TypeScriptTest.py) Python3 script.\n\n*Note: The TypeScript test file requires [Node.js](https://nodejs.org/en/).*\n\n## Using the FlatBuffers TypeScript library\n\n*Note: See [Tutorial](../tutorial.md) for a more in-depth\nexample of how to use FlatBuffers in TypeScript.*\n\nFlatBuffers supports both reading and writing FlatBuffers in TypeScript.\n\nTo use FlatBuffers in your own code, first generate TypeScript classes from your\nschema with the `--ts` option to `flatc`. Then you can include both FlatBuffers\nand the generated code to read or write a FlatBuffer.\n\nFor example, here is how you would read a FlatBuffer binary file in TypeScript:\nFirst, include the library and generated code. Then read the file into an\n`Uint8Array`. Make a `flatbuffers.ByteBuffer` out of the `Uint8Array`, and pass\nthe ByteBuffer to the `getRootAsMonster` function.\n\n~~~{.ts}\n import * as flatbuffers from 'flatbuffers';\n\n import { MyGame } from './monster_generated';\n\n let data = new Uint8Array(fs.readFileSync('monster.dat'));\n let buf = new flatbuffers.ByteBuffer(data);\n\n let monster = MyGame.Example.Monster.getRootAsMonster(buf);\n~~~\n\nNow you can access values like this:\n\n~~~{.ts}\n let hp = monster.hp();\n let pos = monster.pos();\n~~~\n\n## Object based API\n\nFlatBuffers is all about memory efficiency, which is why its base API is written\naround using as little as possible of it. This does make the API clumsier\n(requiring pre-order construction of all data, and making mutation harder).\n\nFor times when efficiency is less important a more convenient object based API\ncan be used (through `--gen-object-api`) that is able to unpack & pack a\nFlatBuffer into objects and standard TS types.\n\nTo use:\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.ts}\n // Autogenerated class from table Monster.\n let monsterobj = new MonsterT();\n\n // Deserialize from buffer into object.\n Monster.getRootAsMonster(flatbuffer).unpackTo(monsterobj);\n // or\n let monsterobj = Monster.getRootAsMonster(flatbuffer).unpack();\n\n // Update object directly like a regular TS class instance.\n console.log(monsterobj.name);\n monsterobj.name = \"Bob\";\n\n // Serialize into new flatbuffer.\n let fbb = new flatbuffers.Builder(1);\n Monster.finishMonsterBuffer(fbb, monsterobj.pack(fbb));\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n## Text parsing FlatBuffers in TypeScript\n\nThere currently is no support for parsing text (Schema's and JSON) directly\nfrom TypeScript.\n" }, { "path": "docs/source/quick_start.md", "content": "# Quick Start\n\nThis will quickly go over the parts of using FlatBuffers to serialize some data.\nSee the [Tutorial](tutorial.md) for a more in depth guide.\n\n1. **Build the compiler for FlatBuffers ([`flatc`](flatc.md))**\n\n ```sh\n cmake -G \"Unix Makefiles\"\n make -j\n ```\n\n2. **Define your FlatBuffer [schema](schema.md) (`.fbs`)**\n\n ```c title=\"monster.fbs\" linenums=\"1\"\n table Monster {\n name:string;\n health:int;\n }\n\n root_type Monster;\n ```\n\n See [monster.fbs](https://github.com/google/flatbuffers/blob/master/samples/monster.fbs)\n for an complete example.\n\n3. **Generate code for your language(s)**\n\n Use the `flatc` compiler to take your schema and generate language-specific\n code:\n\n ```sh\n ./flatc --cpp --rust monster.fbs\n ```\n\n Which generates `monster_generated.h` and `monster_generated.rs` files.\n\n4. **Serialize data**\n\n Use the generated code files, as well as the `FlatBufferBuilder` to construct\n your serialized buffer.\n\n ```c++ title=\"my_monster_factory.cc\" linenums=\"1\"\n #include \"flatbuffers.h\"\n #include \"monster_generated.h\"\n\n int main() {\n // Used to build the flatbuffer\n FlatBufferBuilder builder;\n\n // Auto-generated function emitted from `flatc` and the input\n // `monster.fbs` schema.\n auto monster = CreateMonsterDirect(builder, \"Abominable Snowman\", 100);\n\n // Finalize the buffer.\n builder.Finish(monster);\n }\n ```\n\n See complete [C++ Example](https://github.com/google/flatbuffers/blob/master/samples/sample_binary.cpp#L24-L56).\n\n5. **Transmit/Store the serialized FlatBuffer**\n\n Use your serialized buffer however you want. Send it to someone, save it for\n later, etc...\n\n ```c++ title=\"my_monster_factory.cc\" linenums=\"13\"\n // Get a pointer to the flatbuffer.\n const uint8_t* flatbuffer = builder.GetBufferPointer();\n ```\n\n6. **Read the data**\n\n Use the generated accessors to read the data from the serialized buffer.\n\n It doesn't need to be the same language, or even schema version (see\n [Evolving](evolution.md)), FlatBuffers ensures the data is readable across\n languages and schema versions.\n\n ```c++ title=\"my_monster_factory.cc\" linenums=\"15\"\n // Get a view of the root monster from the flatbuffer.\n const Monster snowman = GetMonster(flatbuffer);\n\n // Access the monster's fields directly.\n ASSERT_EQ(snowman->name(), \"Abominable Snowman\");\n ASSERT_EQ(snowman->health(), 100);\n ```\n\n See [`Rust` examples](https://github.com/google/flatbuffers/blob/master/samples/sample_binary.rs#L92-L106)\n for reading the data written by `C++`.\n" }, { "path": "docs/source/schema.md", "content": "# Schema\n\nThe syntax of the schema language (aka IDL,\n[Interface Definition Language](https://en.wikipedia.org/wiki/Interface_description_language))\nshould look quite familiar to users of any of the C family of languages, and\nalso to users of other IDLs. Let's look at an example first:\n\n```c title=\"monster.fbs\" linenums=\"1\"\n// example IDL file\n\nnamespace MyGame;\n\nattribute \"priority\";\n\nenum Color : byte { Red = 1, Green, Blue }\n\nunion Any { Monster, Weapon, Pickup }\n\nstruct Vec3 {\n x:float;\n y:float;\n z:float;\n}\n\ntable Monster {\n pos:Vec3;\n mana:short = 150;\n hp:short = 100;\n name:string;\n friendly:bool = false (deprecated, priority: 1);\n inventory:[ubyte];\n color:Color = Blue;\n test:Any;\n}\n\ntable Weapon {}\ntable Pickup {}\n\nroot_type Monster;\n```\n\n## Tables\n\nTables are the main way of defining objects in FlatBuffers.\n\n```c title=\"monster.fbs - Example Table\" linenums=\"17\"\ntable Monster {\n pos:Vec3;\n mana:short = 150;\n hp:short = 100;\n name:string;\n friendly:bool = false (deprecated, priority: 1);\n inventory:[ubyte];\n color:Color = Blue;\n test:Any;\n}\n```\n\nThey consist of a name (here `Monster`) and a list of [fields](#fields). This\nfield list can be appended to (and deprecated from) while still maintaining\ncompatibility.\n\n### Fields\n\nTable fields have a name identifier, a [type](#types), optional default value,\noptional [attributes](#attributes) and ends with a `;`. See the\n[grammar](grammar.md) for full details.\n\n```ebnf\nfield_decl = ident `:` type [ `=` scalar ] metadata `;`\n```\n\nFields do not have to appear in the wire representation, and you can choose to\nomit fields when constructing an object. You have the flexibility to add fields\nwithout fear of bloating your data. This design is also FlatBuffer's mechanism\nfor forward and backwards compatibility.\n\nThere are three, mutually exclusive, reactions to the non-presence of a table's\nfield in the binary data.\n\n#### 1. Default\n\nDefault value fields with return the default value as defined in the schema. If\nthe default value is not specified in the schema, it will be `0` for scalar\ntypes, or `null` for other types.\n\n```c++\nmana:short = 150;\nhp:short;\ninventory:[ubyte];\n```\n\nHere `mana` would default to the value `150`, `hp` to value `0`, and `inventory`\nto `null`, if those fields are not set.\n\nOnly scalar values can have explicit defaults, non-scalar fields (strings,\nvectors, tables) are `null` when not present.\n\nThis is the normal mode that fields will take.\n\n??? danger \"Don't change Default values\"\n\n You generally do not want to change default values after they're initially\n defined. Fields that have the default value are not actually stored in the\n serialized data (see also Gotchas below). Values explicitly written by code\n generated by the old schema old version, if they happen to be the default, will\n be read as a different value by code generated with the new schema. This is\n slightly less bad when converting an optional scalar into a default valued\n scalar since non-presence would not be overloaded with a previous default value.\n There are situations, however, where this may be desirable, especially if you\n can ensure a simultaneous rebuild of all code.\n\n#### 2. Optional\n\nOptional value fields will return some form of `null` in the language generated.\n\n=== \"C++\"\n\n ```c++\n std::optional field;\n ```\n\nFor optional scalars, just set the field default value to `null`. If the\nproducer of the buffer does not explicitly set that field, it will be marked\n`null`.\n\n```c++\n hp:short = null;\n```\n\n!!! note\n\n Not every languages support scalar defaults yet\n\n#### 3. Required\n\nRequired valued fields will cause an error if they are not set. The FlatBuffers\nverifier would consider the whole buffer invalid.\n\nThis is enabled by the [`required` attribute](#required) on the field.\n\n```\n hp:short (required)\n```\n\nYou cannot have `required` set with an explicit default value, it will result in\na compiler error.\n\n## Structs\n\nSimilar to a table, `structs` consist of fields are required (so no defaults\neither), and fields may not be added or be deprecated.\n\n```c title=\"monster.fbs - Example Struct\" linenums=\"11\"\nstruct Vec3 {\n x:float;\n y:float;\n z:float;\n}\n```\n\nStructs may only contain scalars or other structs. Use this for simple objects\nwhere you are very sure no changes will ever be made (as quite clear in the\nexample `Vec3`). Structs use less memory than tables and are even faster to\naccess (they are always stored in-line in their parent object, and use no\nvirtual table).\n\n### Arrays\n\nArrays are a convenience short-hand for a fixed-length collection of elements.\nArrays allow the following syntax, while maintaining binary equivalency.\n\n
\n\n- **Normal Syntax**\n\n ===\n\n ```c++\n struct Vec3 {\n x:float;\n y:float;\n z:float;\n }\n ```\n\n- **Array Syntax**\n\n ===\n\n ```c++\n struct Vec3 {\n v:[float:3];\n }\n ```\n\n
\n\nArrays are currently only supported in a `struct`.\n\n## Types\n\nThe following are the built-in types that can be used in FlatBuffers.\n\n### Scalars\n\nThe standard assortment of fixed sized scalars are available. There are no\nvariable sized integers (e.g., `varints`).\n\n| Size | Signed | Unsigned | Floating Point |\n| ------ | ----------------- | ------------------- | -------------------- |\n| 8-bit | `byte`, `bool` | `ubyte` (`uint8`) | |\n| 16-bit | `short` (`int16`) | `ushort` (`uint16`) |\n| 32-bit | `int` (`int32`) | `uint` (`uint32`) | `float` (`float32`) |\n| 64-bit | `long` (`int64`) | `ulong` (`uint64`) | `double` (`float64`) |\n\nThe type names in parentheses are alias names such that for example `uint8` can\nbe used in place of `ubyte`, and `int32` can be used in place of `int` without\naffecting code generation.\n\n### Non-scalars\n\n#### Vectors\n\nVector of any other type (denoted with `[type]`).\n\n```c++\ninventory:[ubyte];\n```\n\n!!! note \"Nesting vectors\"\n\n Nesting vectors is not supported, instead you can wrap the inner vector with\n a table.\n\n ```\n table nest{\n a:[ubyte]\n }\n\n table monster {\n a:[nest]\n }\n ```\n\n#### Strings\n\nStrings (indicated by `string`) are zero-terminated strings, prefixed by their\nlength. Strings may only hold UTF-8 or 7-bit ASCII. For other text encodings or\ngeneral binary data use vectors (`[byte]` or `[ubyte]`) instead.\n\n```c++\nname:string;\n```\n\n## Enums\n\nDefine a sequence of named constants, each with a given value, or increasing by\none from the previous one. The default first value is `0`. As you can see in the\nenum declaration, you specify the underlying integral type of the enum with `:`\n(in this case `byte`), which then determines the type of any fields declared\nwith this enum type.\n\nOnly integer types are allowed, i.e. `byte`, `ubyte`, `short` `ushort`, `int`,\n`uint`, `long` and `ulong`.\n\nTypically, enum values should only ever be added, never removed (there is no\ndeprecation for enums). This requires code to handle forwards compatibility\nitself, by handling unknown enum values.\n\n## Unions\n\nUnions share a lot of properties with enums, but instead of new names for\nconstants, you use names of tables. You can then declare a union field, which\ncan hold a reference to any of those types, and additionally a field with the\nsuffix `_type` is generated that holds the corresponding enum value, allowing\nyou to know which type to cast to at runtime.\n\nIt's possible to give an alias name to a type union. This way a type can even be\nused to mean different things depending on the name used:\n\n```txt\ntable PointPosition { x:uint; y:uint; }\ntable MarkerPosition {}\nunion Position {\n Start:MarkerPosition,\n Point:PointPosition,\n Finish:MarkerPosition\n}\n```\n\nUnions contain a special `NONE` marker to denote that no value is stored so that\nname cannot be used as an alias.\n\nUnions are a good way to be able to send multiple message types as a FlatBuffer.\nNote that because a union field is really two fields, it must always be part of\na table, it cannot be the root of a FlatBuffer by itself.\n\nIf you have a need to distinguish between different FlatBuffers in a more\nopen-ended way, for example for use as files, see the file identification\nfeature below.\n\nThere is an experimental support only in C++ for a vector of unions (and types).\nIn the example IDL file above, use [Any] to add a vector of Any to Monster\ntable. There is also experimental support for other types besides tables in\nunions, in particular structs and strings. There's no direct support for scalars\nin unions, but they can be wrapped in a struct at no space cost.\n\n## Namespaces\n\nThese will generate the corresponding namespace in C++ for all helper code, and\npackages in Java. You can use `.` to specify nested namespaces / packages.\n\n## Includes\n\nYou can include other schemas files in your current one, e.g.:\n\n```txt\ninclude \"mydefinitions.fbs\";\n```\n\nThis makes it easier to refer to types defined elsewhere. `include`\nautomatically ensures each file is parsed just once, even when referred to more\nthan once.\n\nWhen using the `flatc` compiler to generate code for schema definitions, only\ndefinitions in the current file will be generated, not those from the included\nfiles (those you still generate separately).\n\n## Root type\n\nThis declares what you consider to be the root table of the serialized data.\nThis is particularly important for parsing JSON data, which doesn't include\nobject type information.\n\n## File identification and extension\n\nTypically, a FlatBuffer binary buffer is not self-describing, i.e. it needs you\nto know its schema to parse it correctly. But if you want to use a FlatBuffer as\na file format, it would be convenient to be able to have a \"magic number\" in\nthere, like most file formats have, to be able to do a sanity check to see if\nyou're reading the kind of file you're expecting.\n\nNow, you can always prefix a FlatBuffer with your own file header, but\nFlatBuffers has a built-in way to add an identifier to a FlatBuffer that takes\nup minimal space, and keeps the buffer compatible with buffers that don't have\nsuch an identifier.\n\nYou can specify in a schema, similar to `root_type`, that you intend for this\ntype of FlatBuffer to be used as a file format:\n\n```txt\nfile_identifier \"MYFI\";\n```\n\nIdentifiers must always be exactly 4 characters long. These 4 characters will\nend up as bytes at offsets 4-7 (inclusive) in the buffer.\n\nFor any schema that has such an identifier, `flatc` will automatically add the\nidentifier to any binaries it generates (with `-b`), and generated calls like\n`FinishMonsterBuffer` also add the identifier. If you have specified an\nidentifier and wish to generate a buffer without one, you can always still do so\nby calling `FlatBufferBuilder::Finish` explicitly.\n\nAfter loading a buffer, you can use a call like `MonsterBufferHasIdentifier` to\ncheck if the identifier is present.\n\nNote that this is best for open-ended uses such as files. If you simply wanted\nto send one of a set of possible messages over a network for example, you'd be\nbetter off with a union.\n\nAdditionally, by default `flatc` will output binary files as `.bin`. This\ndeclaration in the schema will change that to whatever you want:\n\n```txt\nfile_extension \"ext\";\n```\n\n## RPC interface declarations\n\nYou can declare RPC calls in a schema, that define a set of functions that take\na FlatBuffer as an argument (the request) and return a FlatBuffer as the\nresponse (both of which must be table types):\n\n```txt\nrpc_service MonsterStorage {\n Store(Monster):StoreResponse;\n Retrieve(MonsterId):Monster;\n}\n```\n\nWhat code this produces and how it is used depends on language and RPC system\nused, there is preliminary support for GRPC through the `--grpc` code generator,\nsee `grpc/tests` for an example.\n\n## Comments & documentation\n\nMay be written as in most C-based languages. Additionally, a triple comment\n(`///`) on a line by itself signals that a comment is documentation for whatever\nis declared on the line after it (table/struct/field/enum/union/element), and\nthe comment is output in the corresponding C++ code. Multiple such lines per\nitem are allowed.\n\n## Attributes\n\nAttributes may be attached to a declaration, behind a field/enum value, or after\nthe name of a table/struct/enum/union. These may either have a value or not.\nSome attributes like `deprecated` are understood by the compiler; user defined\nones need to be declared with the attribute declaration (like `priority` in the\nexample above), and are available to query if you parse the schema at runtime.\nThis is useful if you write your own code generators/editors etc., and you wish\nto add additional information specific to your tool (such as a help text).\n\nCurrent understood attributes:\n\n- `id: n` (on a table field): manually set the field identifier to `n`. If you\n use this attribute, you must use it on ALL fields of this table, and the\n numbers must be a contiguous range from 0 onwards. Additionally, since a union\n type effectively adds two fields, its id must be that of the second field (the\n first field is the type field and not explicitly declared in the schema). For\n example, if the last field before the union field had id 6, the union field\n should have id 8, and the unions type field will implicitly be 7. IDs allow\n the fields to be placed in any order in the schema. When a new field is added\n to the schema it must use the next available ID.\n- `deprecated` (on a field): do not generate accessors for this field anymore,\n code should stop using this data. Old data may still contain this field, but\n it won't be accessible anymore by newer code. Note that if you deprecate a\n field that was previous required, old code may fail to validate new data (when\n using the optional verifier).\n- `required` (on a non-scalar table field): this field must always be set. By\n default, fields do not need to be present in the binary. This is desirable, as\n it helps with forwards/backwards compatibility, and flexibility of data\n structures. By specifying this attribute, you make non- presence in an error\n for both reader and writer. The reading code may access the field directly,\n without checking for null. If the constructing code does not initialize this\n field, they will get an assert, and also the verifier will fail on buffers\n that have missing required fields. Both adding and removing this attribute may\n be forwards/backwards incompatible as readers will be unable read old or new\n data, respectively, unless the data happens to always have the field set.\n- `force_align: size` (on a struct): force the alignment of this struct to be\n something higher than what it is naturally aligned to. Causes these structs to\n be aligned to that amount inside a buffer, IF that buffer is allocated with\n that alignment (which is not necessarily the case for buffers accessed\n directly inside a `FlatBufferBuilder`). Note: currently not guaranteed to have\n an effect when used with `--object-api`, since that may allocate objects at\n alignments less than what you specify with `force_align`.\n- `force_align: size` (on a vector): force the alignment of this vector to be\n something different than what the element size would normally dictate. Note:\n Now only work for generated C++ code.\n- `bit_flags` (on an unsigned enum): the values of this field indicate bits,\n meaning that any unsigned value N specified in the schema will end up\n representing 1<\n" }, { "path": "docs/source/tutorial.md", "content": "# Tutorial\n\nThis tutorial provides an example of how to work with FlatBuffers in a variety\nof languages. The following topics will cover all the steps of using FlatBuffers\nin your application.\n\n1. Writing a FlatBuffers schema file (`.fbs`).\n2. Using the `flatc` compiler to transform the schema into language-specific\n code.\n3. Importing the generated code and libraries into your application.\n4. Serializing data into a flatbuffer.\n5. Deserializing a flatbuffer.\n\nThe tutorial is structured to be language agnostic, with language specifics in\ncode blocks providing more context. Additionally, this tries to cover the major\nparts and type system of flatbuffers to give a general overview. It's not\nexpected to be an exhaustive list of all features, or provide the best way to do\nthings.\n\n## FlatBuffers Schema (`.fbs`)\n\nTo start working with FlatBuffers, you first need to create a\n[schema](schema.md) file which defines the format of the data structures you\nwish to serialize. The schema is processed by the `flatc` compiler to generate\nlanguage-specific code that you use in your projects.\n\nThe following\n[`monster.fbs`](https://github.com/google/flatbuffers/blob/master/samples/monster.fbs)\nschema will be used for this tutorial. This is part of the FlatBuffers\n[sample code](https://github.com/google/flatbuffers/tree/master/samples) to give\ncomplete sample binaries demonstrations.\n\nFlatBuffers schema is a Interface Definition Language (IDL) that has a couple\ndata structures, see the [schema](schema.md) documentation for a detail\ndescription. Use the inline code annotations to get a brief synopsis of each\npart of the schema.\n\n```proto title=\"monster.fbs\" linenums=\"1\"\n// Example IDL file for our monster's schema.\n\nnamespace MyGame.Sample; //(1)!\n\nenum Color:byte { Red = 0, Green, Blue = 2 } //(2)!\n\n// Optionally add more tables.\nunion Equipment { Weapon } //(3)!\n\nstruct Vec3 { //(4)!\n x:float; //(5)!\n y:float;\n z:float;\n}\n\ntable Monster { //(6)!\n pos:Vec3; //(7)!\n mana:short = 150; //(8)!\n hp:short = 100;\n name:string; //(9)!\n friendly:bool = false (deprecated); //(10)!\n inventory:[ubyte]; //(11)!\n color:Color = Blue;\n weapons:[Weapon]; //(12)!\n equipped:Equipment; //(13)!\n path:[Vec3];\n}\n\ntable Weapon {\n name:string;\n damage:short;\n}\n\nroot_type Monster; //(14)!\n```\n\n1. FlatBuffers has support for namespaces to place the generated code into.\n There is mixed level of support for namespaces (some languages don't have\n namespaces), but for the C family of languages, it is fully supported.\n\n2. Enums definitions can be defined with the backing numerical type. Implicit\n numbering is supported, so that `Green` would have a value of 1.\n\n3. A union represents a single value from a set of possible values. Its\n effectively an enum (to represent the type actually store) and a value,\n combined into one. In this example, the union is not very useful, since it\n only has a single type.\n\n4. A struct is a collection of scalar fields with names. It is itself a scalar\n type, which uses less memory and has faster lookup. However, once a struct is\n defined, it cannot be changed. Use tables for data structures that can evolve\n over time.\n\n5. FlatBuffers has the standard set of scalar numerical types (`int8`, `int16`,\n `int32`, `int64`, `uint8`, `uint16`, `uint32`, `uint64`, `float`, `double`),\n as well as `bool`. Note, scalars are fixed width, `varints` are not\n supported.\n\n6. Tables are the main data structure for grouping data together. It can evolve\n by adding and deprecating fields over time, while preserving forward and\n backwards compatibility.\n\n7. A field that happens to be a `struct`. This means the data of the `Vec3`\n struct will be serialized inline in the table without any need for offset.\n\n8. Fields can be provided a default value. Default values can be configured to\n not be serialized at all while still providing the default value while\n deserializing. However, once set, a default value cannot be changed.\n\n9. A `string` field which points to a serialized string external to the table.\n\n10. A deprecated field that is no longer being used. This is used instead of\n removing the field outright.\n\n11. A `vector` field that points to a vector of bytes. Like `strings`, the\n vector data is serialized elsewhere and this field just stores an offset to\n the vector.\n\n12. Vector of `tables` and `structs` are also possible.\n\n13. A field to a `union` type.\n\n14. The root of the flatbuffer is always a `table`. This indicates the type of\n `table` the \"entry\" point of the flatbuffer will point to.\n\n## Compiling Schema to Code (`flatc`)\n\nAfter a schema file is written, you compile it to code in the languages you wish\nto work with. This compilation is done by the [FlatBuffers Compiler](flatc.md)\n(`flatc`) which is one of the binaries built in the repo.\n\n### Building `flatc`\n\nFlatBuffers uses [`cmake`](https://cmake.org/) to build projects files for your\nenvironment.\n\n=== \"Unix\"\n\n ```sh\n cmake -G \"Unix Makefiles\"\n make flatc\n ```\n\n=== \"Windows\"\n\n ```sh\n cmake -G \"Visual Studio 17 2022\"\n msbuild.exe FlatBuffers.sln\n ```\n\nSee the documentation on [building](building.md) for more details and other\nenvironments. Some languages also include a prebuilt `flatc` via their package\nmanager.\n\n### Compiling Schema\n\nTo compile the schema, invoke `flatc` with the schema file and the language\nflags you wish to generate code for. This compilation will generate files that\nyou include in your application code. These files provide convenient APIs for\nserializing and deserializing the flatbuffer binary data.\n\n=== \"C++\"\n\n ```sh\n flatc --cpp monster.fbs\n ```\n\n=== \"C\"\n\n !!! Note\n\n If you're working in C, you need to use the separate project\n [FlatCC](https://github.com/dvidelabs/flatcc) which contains a schema\n compiler and runtime library in C for C. See\n [flatcc build instructions](https://github.com/dvidelabs/flatcc#building).\n\n Please be aware of the difference between `flatc` and `flatcc` tools.\n\n ```sh\n cd flatcc\n mkdir -p build/tmp/samples/monster\n bin/flatcc -a -o build/tmp/samples/monster samples/monster/monster.fbs\n # or just\n flatcc/samples/monster/build.sh\n ```\n\n=== \"C#\"\n\n ```sh\n flatc --csharp monster.fbs\n ```\n\n=== \"Dart\"\n\n ```sh\n flatc --dart monster.fbs\n ```\n\n=== \"Go\"\n\n ```sh\n flatc --go monster.fbs\n ```\n\n=== \"Java\"\n\n ```sh\n flatc --java monster.fbs\n ```\n\n=== \"JavaScript\"\n\n ```sh\n flatc --js monster.fbs\n ```\n\n=== \"Kotlin\"\n\n ```sh\n flatc --kotlin monster.fbs\n ```\n\n=== \"Lobster\"\n\n ```sh\n flatc --lobster monster.fbs\n ```\n\n=== \"Lua\"\n\n ```sh\n flatc --lua monster.fbs\n ```\n\n=== \"PHP\"\n\n ```sh\n flatc --php monster.fbs\n ```\n\n=== \"Python\"\n\n ```sh\n flatc --python monster.fbs\n ```\n\n=== \"Rust\"\n\n ```sh\n flatc --rust monster.fbs\n ```\n\n=== \"Swift\"\n\n ```sh\n flatc --swift monster.fbs\n ```\n\n=== \"TypeScript\"\n\n ```sh\n flatc --ts monster.fbs\n ```\n\nYou can deserialize flatbuffers in languages that differ from the language that\nserialized it. For purpose of this tutorial, we assume one language is used for\nboth serializing and deserializing.\n\n## Application Integration\n\nThe generated files are then included in your project to be built into your\napplication. This is heavily dependent on your build system and language, but\ngenerally involves two things:\n\n1. Importing the generated code.\n2. Importing the \"runtime\" libraries.\n\n=== \"C++\"\n\n ```c++\n #include \"monster_generated.h\" // This was generated by `flatc`\n #include \"flatbuffers.h\" // The runtime library for C++\n\n // Simplifies naming in the following examples.\n using namespace MyGame::Sample; // Specified in the schema.\n ```\n\n=== \"C\"\n\n ```c\n #include \"monster_builder.h\" // Generated by `flatcc`.\n\n // Convenient namespace macro to manage long namespace prefix.\n #undef ns\n // Specified in the schema.\n #define ns(x) FLATBUFFERS_WRAP_NAMESPACE(MyGame_Sample, x)\n\n // A helper to simplify creating vectors from C-arrays.\n #define c_vec_len(V) (sizeof(V)/sizeof((V)[0]))\n ```\n\n=== \"C#\"\n\n ```c#\n using Google.FlatBuffers; // The runtime library for C#\n using MyGame.Sample; // The generated files from `flatc`\n ```\n\n=== \"Dart\"\n\n ```dart\n import 'package:flat_buffers/flat_buffers.dart' as fb;\n\n // Generated by `flatc`.\n import 'monster_my_game.sample_generated.dart' as myGame;\n ```\n\n=== \"Go\"\n\n ```go\n import (\n flatbuffers \"github.com/google/flatbuffers/go\"\n sample \"MyGame/Sample\"\n )\n ```\n\n=== \"Java\"\n\n ```java\n import MyGame.Sample.*; //The `flatc` generated files. (Monster, Vec3, etc.)\n\n import com.google.flatbuffers.FlatBufferBuilder;\n ```\n\n=== \"JavaScript\"\n\n ```javascript\n // The following code is an example - use your desired module flavor by\n // transpiling from TS.\n var flatbuffers = require('/js/flatbuffers').flatbuffers;\n var MyGame = require('./monster_generated').MyGame; // Generated by `flatc`.\n\n //------------------------------------------------------------------------//\n\n // The following code is for browser-based HTML/JavaScript. Use the above\n // code for JavaScript module loaders (e.g. Node.js).\n \n // Generated by `flatc`.\n ```\n\n=== \"Kotlin\"\n\n ```kotlin\n import MyGame.Sample.* //The `flatc` generated files. (Monster, Vec3, etc.)\n\n import com.google.flatbuffers.FlatBufferBuilder\n ```\n\n=== \"Lobster\"\n\n ```lobster\n import from \"../lobster/\" // Where to find flatbuffers.lobster\n import monster_generated\n ```\n\n=== \"Lua\"\n\n ```lua\n -- require the flatbuffers module\n local flatbuffers = require(\"flatbuffers\")\n\n -- require the generated files from `flatc`.\n local color = require(\"MyGame.Sample.Color\")\n local equipment = require(\"MyGame.Sample.Equipment\")\n local monster = require(\"MyGame.Sample.Monster\")\n local vec3 = require(\"MyGame.Sample.Vec3\")\n local weapon = require(\"MyGame.Sample.Weapon\")\n ```\n\n=== \"PHP\"\n\n ```php\n // It is recommended that your use PSR autoload when using FlatBuffers in\n // PHP. Here is an example from `SampleBinary.php`:\n function __autoload($class_name) {\n // The last segment of the class name matches the file name.\n $class = substr($class_name, strrpos($class_name, \"\\\\\") + 1);\n // `flatbuffers` root.\n $root_dir = join(DIRECTORY_SEPARATOR, array(dirname(dirname(__FILE__))));\n\n // Contains the `*.php` files for the FlatBuffers library and the `flatc`\n // generated files.\n $paths = array(join(DIRECTORY_SEPARATOR, array($root_dir, \"php\")),\n join(DIRECTORY_SEPARATOR,\n array($root_dir, \"samples\", \"MyGame\", \"Sample\")));\n foreach ($paths as $path) {\n $file = join(DIRECTORY_SEPARATOR, array($path, $class . \".php\"));\n if (file_exists($file)) {\n require($file);\n break;\n }\n }\n }\n ```\n\n=== \"Python\"\n\n ```py\n import flatbuffers\n\n # Generated by `flatc`.\n import MyGame.Sample.Color\n import MyGame.Sample.Equipment\n import MyGame.Sample.Monster\n import MyGame.Sample.Vec3\n import MyGame.Sample.Weapon\n ```\n\n=== \"Rust\"\n\n ```rust\n // import the flatbuffers runtime library\n extern crate flatbuffers;\n\n // import the generated code\n #[allow(dead_code, unused_imports)]\n #[path = \"./monster_generated.rs\"]\n mod monster_generated;\n pub use monster_generated::my_game::sample::{root_as_monster,\n Color, Equipment,\n Monster, MonsterArgs,\n Vec3,\n Weapon, WeaponArgs};\n ```\n\n=== \"Swift\"\n\n ```swift\n /**\n // make sure that monster_generated.swift is included in your project\n */\n import Flatbuffers\n\n // typealiases for convenience\n typealias Monster = MyGame1_Sample_Monster\n typealias Weapon = MyGame1_Sample_Weapon\n typealias Color = MyGame1_Sample_Color\n typealias Vec3 = MyGame1_Sample_Vec3\n ```\n\n=== \"TypeScript\"\n\n ```ts\n // note: import flatbuffers with your desired import method\n\n import { MyGame } from './monster_generated';\n ```\n\nFor some languages the runtime libraries are just code files you compile into\nyour application. While other languages provide packaged libraries via their\npackage managers.\n\nThe generated files include APIs for both serializing and deserializing\nFlatBuffers. So these steps are identical for both the consumer and producer.\n\n## Serialization\n\nOnce all the files are included into your application, it's time to start\nserializing some data!\n\nWith FlatBuffers, serialization can be a bit verbose, since each piece of data\nmust be serialized separately and in a particular order (depth-first, pre-order\ntraversal). The verbosity allows efficient serialization without heap\nallocations, at the cost of more complex serialization APIs.\n\nFor example, any reference type (e.g. `table`, `vector`, `string`) must be\nserialized before it can be referred to by other structures. So its typical to\nserialize the data from leaf to root node, as will be shown below.\n\n### FlatBufferBuilder\n\nMost languages use a Builder object for managing the binary array that the data\nis serialized into. It provides an API for serializing data, as well as keeps\ntrack of some internal state. The generated code wraps methods on the Builder\nobject to provide an API tailored to the schema.\n\nFirst instantiate a Builder (or reuse an existing one) and specify some memory\nfor it. The builder will automatically resize the backing buffer when necessary.\n\n=== \"C++\"\n\n ```c++\n // Construct a Builder with 1024 byte backing array.\n flatbuffers::FlatBufferBuilder builder(1024);\n ```\n\n=== \"C\"\n\n ```c\n flatcc_builder_t builder, *B;\n B = &builder;\n // Initialize the builder object.\n flatcc_builder_init(B);\n ```\n\n=== \"C#\"\n\n ```c#\n // Construct a Builder with 1024 byte backing array.\n FlatBufferBuilder builder = new FlatBufferBuilder(1024);\n ```\n\n=== \"Dart\"\n\n ```dart\n // Construct a Builder with 1024 byte backing array.\n var builder = new fb.Builder(initialSize: 1024);\n ```\n\n=== \"Go\"\n\n ```go\n // Construct a Builder with 1024 byte backing array.\n builder := flatbuffers.NewBuilder(1024)\n ```\n\n=== \"Java\"\n\n ```java\n // Construct a Builder with 1024 byte backing array.\n FlatBufferBuilder builder = new FlatBufferBuilder(1024);\n ```\n\n=== \"JavaScript\"\n\n ```javascript\n // Construct a Builder with 1024 byte backing array.\n var builder = new flatbuffers.Builder(1024);\n ```\n\n=== \"Kotlin\"\n\n ```kotlin\n // Construct a Builder with 1024 byte backing array.\n val builder = FlatBufferBuilder(1024)\n ```\n\n=== \"Lobster\"\n\n ```lobster\n // Construct a Builder with 1024 byte backing array.\n let builder = flatbuffers_builder {}\n ```\n\n=== \"Lua\"\n\n ```lua\n -- Construct a Builder with 1024 byte backing array.\n local builder = flatbuffers.Builder(1024)\n ```\n\n=== \"PHP\"\n\n ```php\n // Construct a Builder with 1024 byte backing array.\n $builder = new Google\\FlatBuffers\\FlatbufferBuilder(1024);\n ```\n\n=== \"Python\"\n\n ```py\n # Construct a Builder with 1024 byte backing array.\n builder = flatbuffers.Builder(1024)\n ```\n\n=== \"Rust\"\n\n ```rust\n // Construct a Builder with 1024 byte backing array.\n let mut builder = flatbuffers::FlatBufferBuilder::with_capacity(1024);\n ```\n\n=== \"Swift\"\n\n ```swift\n // Construct a Builder with 1024 byte backing array.\n let builder = FlatBufferBuilder(initialSize: 1024)\n ```\n\n=== \"TypeScript\"\n\n ```ts\n // Construct a Builder with 1024 byte backing array.\n let builder = new flatbuffers.Builder(1024);\n ```\n\nOnce a Builder is available, data can be serialized to it via the Builder APIs\nand the generated code.\n\n### Serializing Data\n\nIn this tutorial, we are building `Monsters` and `Weapons` for a computer game.\nA `Weapon` is represented by a flatbuffer `table` with some fields. One field is\nthe `name` field, which is type `string` and the other `damage` field is a\nnumerical scalar.\n\n```c title=\"monster.fbs\" linenums=\"28\"\ntable Weapon {\n name:string;\n damage:short;\n}\n```\n\n#### Strings\n\nSince `string` is a reference type, we first need to serialize it before\nassigning it to the `name` field of the `Weapon` table. This is done through the\nBuilder `CreateString` method.\n\nLet's serialize two weapon strings.\n\n=== \"C++\"\n\n ```c++\n flatbuffers::Offset weapon_one_name = builder.CreateString(\"Sword\");\n flatbuffers::Offset weapon_two_name = builder.CreateString(\"Axe\");\n ```\n\n `flatbuffers::Offset<>` is a just a \"typed\" integer tied to a particular\n type. It helps make the numerical offset more strongly typed.\n\n=== \"C\"\n\n ```c\n flatbuffers_string_ref_t weapon_one_name\n = flatbuffers_string_create_str(B, \"Sword\");\n flatbuffers_string_ref_t weapon_two_name\n = flatbuffers_string_create_str(B, \"Axe\");\n ```\n\n=== \"C#\"\n\n ```c#\n Offset weaponOneName = builder.CreateString(\"Sword\");\n Offset weaponTwoName = builder.CreateString(\"Axe\");\n ```\n\n=== \"Dart\"\n\n ```dart\n final int weaponOneName = builder.writeString(\"Sword\");\n final int weaponTwoName = builder.writeString(\"Axe\");\n ```\n\n=== \"Go\"\n\n ```go\n weaponOne := builder.CreateString(\"Sword\")\n weaponTwo := builder.CreateString(\"Axe\")\n ```\n\n=== \"Java\"\n\n ```java\n int weaponOneName = builder.createString(\"Sword\")\n int weaponTwoName = builder.createString(\"Axe\");\n ```\n\n=== \"JavaScript\"\n\n ```javascript\n var weaponOne = builder.createString('Sword');\n var weaponTwo = builder.createString('Axe');\n ```\n\n=== \"Kotlin\"\n\n ```kotlin\n val weaponOneName = builder.createString(\"Sword\")\n val weaponTwoName = builder.createString(\"Axe\")\n ```\n\n=== \"Lobster\"\n\n ```lobster\n let weapon_one = builder.CreateString(\"Sword\")\n let weapon_two = builder.CreateString(\"Axe\")\n ```\n\n=== \"Lua\"\n\n ```lua\n local weaponOne = builder:CreateString(\"Sword\")\n local weaponTwo = builder:CreateString(\"Axe\")\n ```\n\n=== \"PHP\"\n\n ```php\n $weapon_one_name = $builder->createString(\"Sword\")\n $weapon_two_name = $builder->createString(\"Axe\");\n ```\n\n=== \"Python\"\n\n ```py\n weapon_one = builder.CreateString('Sword')\n weapon_two = builder.CreateString('Axe')\n ```\n\n=== \"Rust\"\n\n ```rust\n let weapon_one_name = builder.create_string(\"Sword\");\n let weapon_two_name = builder.create_string(\"Axe\");\n ```\n\n=== \"Swift\"\n\n ```swift\n let weapon1Name = builder.create(string: \"Sword\")\n let weapon2Name = builder.create(string: \"Axe\")\n ```\n\n=== \"TypeScript\"\n\n ```ts\n let weaponOne = builder.createString('Sword');\n let weaponTwo = builder.createString('Axe');\n ```\n\n\nThis performs the actual serialization (the string data is copied into the\nbacking array) and returns an offset. Think of the offset as a handle to that\nreference. It's just a \"typed\" numerical offset to where that data resides in\nthe buffer.\n\n#### Tables\n\nNow that we have some names serialized, we can serialize the `Weapon` tables.\nHere we will use one of the generated helper functions that was emitted by\n`flatc`. The `CreateWeapon` function takes in the Builder object, as well as the\noffset to the weapon's name and a numerical value for the damage field.\n\n=== \"C++\"\n\n ```c++\n short weapon_one_damage = 3;\n short weapon_two_damage = 5;\n\n // Use the `CreateWeapon()` shortcut to create Weapons with all the fields\n // set.\n flatbuffers::Offset sword =\n CreateWeapon(builder, weapon_one_name, weapon_one_damage);\n flatbuffers::Offset axe =\n CreateWeapon(builder, weapon_two_name, weapon_two_damage);\n ```\n\n=== \"C\"\n\n ```c\n uint16_t weapon_one_damage = 3;\n uint16_t weapon_two_damage = 5;\n\n ns(Weapon_ref_t) sword\n = ns(Weapon_create(B, weapon_one_name, weapon_one_damage));\n ns(Weapon_ref_t) axe\n = ns(Weapon_create(B, weapon_two_name, weapon_two_damage));\n ```\n\n=== \"C#\"\n\n ```c#\n short weaponOneDamage = 3;\n short weaponTwoDamage = 5;\n\n // Use the `CreateWeapon()` helper function to create the weapons, since we\n // set every field.\n Offset sword =\n Weapon.CreateWeapon(builder, weaponOneName, weaponOneDamage);\n Offset axe =\n Weapon.CreateWeapon(builder, weaponTwoName, weaponTwoDamage);\n ```\n\n=== \"Dart\"\n\n ```dart\n final int weaponOneDamage = 3;\n final int weaponTwoDamage = 5;\n\n final swordBuilder = new myGame.WeaponBuilder(builder)\n ..begin()\n ..addNameOffset(weaponOneName)\n ..addDamage(weaponOneDamage);\n final int sword = swordBuilder.finish();\n\n final axeBuilder = new myGame.WeaponBuilder(builder)\n ..begin()\n ..addNameOffset(weaponTwoName)\n ..addDamage(weaponTwoDamage);\n final int axe = axeBuilder.finish();\n ```\n\n Note, as an alternative, the previous steps can be combined using the\n generative Builder classes.\n\n ```dart\n final myGame.WeaponBuilder sword = new myGame.WeaponObjectBuilder(\n name: \"Sword\",\n damage: 3,\n );\n\n final myGame.WeaponBuilder axe = new myGame.WeaponObjectBuilder(\n name: \"Axe\",\n damage: 5,\n );\n ```\n\n=== \"Go\"\n\n ```go\n // Create the first `Weapon` (\"Sword\").\n sample.WeaponStart(builder)\n sample.WeaponAddName(builder, weaponOne)\n sample.WeaponAddDamage(builder, 3)\n sword := sample.WeaponEnd(builder)\n\n // Create the second `Weapon` (\"Axe\").\n sample.WeaponStart(builder)\n sample.WeaponAddName(builder, weaponTwo)\n sample.WeaponAddDamage(builder, 5)\n axe := sample.WeaponEnd(builder)\n ```\n\n=== \"Java\"\n\n ```java\n short weaponOneDamage = 3;\n short weaponTwoDamage = 5;\n\n // Use the `createWeapon()` helper function to create the weapons, since we\n // set every field.\n int sword = Weapon.createWeapon(builder, weaponOneName, weaponOneDamage);\n int axe = Weapon.createWeapon(builder, weaponTwoName, weaponTwoDamage);\n ```\n\n=== \"JavaScript\"\n\n ```javascript\n // Create the first `Weapon` ('Sword').\n MyGame.Sample.Weapon.startWeapon(builder);\n MyGame.Sample.Weapon.addName(builder, weaponOne);\n MyGame.Sample.Weapon.addDamage(builder, 3);\n var sword = MyGame.Sample.Weapon.endWeapon(builder);\n\n // Create the second `Weapon` ('Axe').\n MyGame.Sample.Weapon.startWeapon(builder);\n MyGame.Sample.Weapon.addName(builder, weaponTwo);\n MyGame.Sample.Weapon.addDamage(builder, 5);\n var axe = MyGame.Sample.Weapon.endWeapon(builder);\n ```\n\n=== \"Kotlin\"\n\n ```kotlin\n val weaponOneDamage: Short = 3;\n val weaponTwoDamage: Short = 5;\n\n // Use the `createWeapon()` helper function to create the weapons, since we\n // set every field.\n val sword = Weapon.createWeapon(builder, weaponOneName, weaponOneDamage)\n val axe = Weapon.createWeapon(builder, weaponTwoName, weaponTwoDamage)\n ```\n\n=== \"Lobster\"\n\n ```lobster\n let sword = MyGame_Sample_WeaponBuilder { b }\n .start()\n .add_name(weapon_one)\n .add_damage(3)\n .end()\n\n let axe = MyGame_Sample_WeaponBuilder { b }\n .start()\n .add_name(weapon_two)\n .add_damage(5)\n .end()\n ```\n\n=== \"Lua\"\n\n ```lua\n -- Create the first 'Weapon'\n weapon.Start(builder)\n weapon.AddName(builder, weaponOne)\n weapon.AddDamage(builder, 3)\n local sword = weapon.End(builder)\n\n -- Create the second 'Weapon'\n weapon.Start(builder)\n weapon.AddName(builder, weaponTwo)\n weapon.AddDamage(builder, 5)\n local axe = weapon.End(builder)\n ```\n\n=== \"PHP\"\n\n ```php\n $sword = \\MyGame\\Sample\\Weapon::CreateWeapon($builder, $weapon_one_name, 3);\n $axe = \\MyGame\\Sample\\Weapon::CreateWeapon($builder, $weapon_two_name, 5);\n ```\n\n=== \"Python\"\n\n ```py\n # Create the first `Weapon` ('Sword').\n MyGame.Sample.Weapon.Start(builder)\n MyGame.Sample.Weapon.AddName(builder, weapon_one)\n MyGame.Sample.Weapon.AddDamage(builder, 3)\n sword = MyGame.Sample.Weapon.End(builder)\n\n # Create the second `Weapon` ('Axe').\n MyGame.Sample.Weapon.Start(builder)\n MyGame.Sample.Weapon.AddName(builder, weapon_two)\n MyGame.Sample.Weapon.AddDamage(builder, 5)\n axe = MyGame.Sample.Weapon.End(builder)\n ```\n\n=== \"Rust\"\n\n ```rust\n // Use the `Weapon::create` shortcut to create Weapons with named field\n // arguments.\n let sword = Weapon::create(&mut builder, &WeaponArgs{\n name: Some(weapon_one_name),\n damage: 3,\n });\n let axe = Weapon::create(&mut builder, &WeaponArgs{\n name: Some(weapon_two_name),\n damage: 5,\n });\n ```\n\n=== \"Swift\"\n\n ```swift\n // start creating the weapon by calling startWeapon\n let weapon1Start = Weapon.startWeapon(&builder)\n Weapon.add(name: weapon1Name, &builder)\n Weapon.add(damage: 3, &builder)\n // end the object by passing the start point for the weapon 1\n let sword = Weapon.endWeapon(&builder, start: weapon1Start)\n\n let weapon2Start = Weapon.startWeapon(&builder)\n Weapon.add(name: weapon2Name, &builder)\n Weapon.add(damage: 5, &builder)\n let axe = Weapon.endWeapon(&builder, start: weapon2Start)\n ```\n\n=== \"TypeScript\"\n\n ```ts\n // Create the first `Weapon` ('Sword').\n MyGame.Sample.Weapon.startWeapon(builder);\n MyGame.Sample.Weapon.addName(builder, weaponOne);\n MyGame.Sample.Weapon.addDamage(builder, 3);\n let sword = MyGame.Sample.Weapon.endWeapon(builder);\n\n // Create the second `Weapon` ('Axe').\n MyGame.Sample.Weapon.startWeapon(builder);\n MyGame.Sample.Weapon.addName(builder, weaponTwo);\n MyGame.Sample.Weapon.addDamage(builder, 5);\n let axe = MyGame.Sample.Weapon.endWeapon(builder);\n ```\n\n\nThe generated functions from `flatc`, like `CreateWeapon`, are just composed of\nvarious Builder API methods. So its not required to use the generated code, but\nit does make things much simpler and compact.\n\nJust like the `CreateString` methods, the table serialization functions return\nan offset to the location of the serialized `Weapon` table.\n\nNow that we have some `Weapons` serialized, we can serialize a `Monster`.\nLooking at the schema again, this table has a lot more fields of various types.\nSome of these need to be serialized beforehand, for the same reason we\nserialized the name string before the weapon table.\n\n!!! note inline end\n\n There is no prescribed ordering of which table fields must be serialized\n first, you could serialize in any order you want. You can also not serialize\n a field to provide a `null` value, this is done by using an 0 offset value.\n\n```c title=\"monster.fbs\" linenums=\"15\"\ntable Monster {\n pos:Vec3;\n mana:short = 150;\n hp:short = 100;\n name:string;\n friendly:bool = false (deprecated);\n inventory:[ubyte];\n color:Color = Blue;\n weapons:[Weapon];\n equipped:Equipment;\n path:[Vec3];\n}\n```\n\n#### Vectors\n\nThe `weapons` field is a `vector` of `Weapon` tables. We already have two\n`Weapons` serialized, so we just need to serialize a `vector` of those offsets.\nThe Builder provides multiple ways to create `vectors`.\n\n=== \"C++\"\n\n ```c++\n // Create a std::vector of the offsets we had previous made.\n std::vector> weapons_vector;\n weapons_vector.push_back(sword);\n weapons_vector.push_back(axe);\n\n // Then serialize that std::vector into the buffer and again get an Offset\n // to that vector. Use `auto` here since the full type is long, and it just\n // a \"typed\" number.\n auto weapons = builder.CreateVector(weapons_vector);\n ```\n\n=== \"C\"\n\n ```c\n // We use the internal builder stack to implement a dynamic vector.\n ns(Weapon_vec_start(B));\n ns(Weapon_vec_push(B, sword));\n ns(Weapon_vec_push(B, axe));\n ns(Weapon_vec_ref_t) weapons = ns(Weapon_vec_end(B));\n ```\n\n=== \"C#\"\n\n ```c#\n // Create an array of the two weapon offsets.\n var weaps = new Offset[2];\n weaps[0] = sword;\n weaps[1] = axe;\n\n // Pass the `weaps` array into the `CreateWeaponsVector()` method to create\n // a FlatBuffer vector.\n var weapons = Monster.CreateWeaponsVector(builder, weaps);\n ```\n\n=== \"Dart\"\n\n ```dart\n // If using the Builder classes, serialize the `[sword,axe]`\n final weapons = builder.writeList([sword, axe]);\n\n // If using the ObjectBuilders, just create an array from the two `Weapon`s\n final List weaps = [sword, axe];\n ```\n\n=== \"Go\"\n\n ```go\n // Create a FlatBuffer vector and prepend the weapons.\n // Note: Since we prepend the data, prepend them in reverse order.\n sample.MonsterStartWeaponsVector(builder, 2)\n builder.PrependUOffsetT(axe)\n builder.PrependUOffsetT(sword)\n weapons := builder.EndVector(2)\n ```\n\n=== \"Java\"\n\n ```java\n // Place the two weapons into an array, and pass it to the\n // `createWeaponsVector()` method to create a FlatBuffer vector.\n int[] weaps = new int[2];\n weaps[0] = sword;\n weaps[1] = axe;\n\n // Pass the `weaps` array into the `createWeaponsVector()` method to create\n // a FlatBuffer vector.\n int weapons = Monster.createWeaponsVector(builder, weaps);\n ```\n\n=== \"JavaScript\"\n\n ```javascript\n // Create an array from the two `Weapon`s and pass it to the\n // `createWeaponsVector()` method to create a FlatBuffer vector.\n var weaps = [sword, axe];\n var weapons = MyGame.Sample.Monster.createWeaponsVector(builder, weaps);\n ```\n\n=== \"Kotlin\"\n\n ```kotlin\n // Place the two weapons into an array, and pass it to the\n // `createWeaponsVector()` method to create a FlatBuffer vector.\n val weaps = intArrayOf(sword, axe)\n\n // Pass the `weaps` array into the `createWeaponsVector()` method to create\n // a FlatBuffer vector.\n val weapons = Monster.createWeaponsVector(builder, weaps)\n ```\n\n=== \"Lobster\"\n\n ```lobster\n let weapons = builder.MyGame_Sample_MonsterCreateWeaponsVector([sword, axe])\n ```\n\n=== \"Lua\"\n\n ```lua\n -- Create a FlatBuffer vector and prepend the weapons.\n -- Note: Since we prepend the data, prepend them in reverse order.\n monster.StartWeaponsVector(builder, 2)\n builder:PrependUOffsetTRelative(axe)\n builder:PrependUOffsetTRelative(sword)\n local weapons = builder:EndVector(2)\n ```\n\n=== \"PHP\"\n\n ```php\n // Create an array from the two `Weapon`s and pass it to the\n // `CreateWeaponsVector()` method to create a FlatBuffer vector.\n $weaps = array($sword, $axe);\n $weapons = \\MyGame\\Sample\\Monster::CreateWeaponsVector($builder, $weaps);\n ```\n\n=== \"Python\"\n\n ```py\n # Use the generated helper to create the weapons vector from offsets.\n weapons = MyGame.Sample.Monster.CreateWeaponsVector(builder, [sword, axe])\n ```\n\n=== \"Rust\"\n\n ```rust\n // Create a FlatBuffer `vector` that contains offsets to the sword and axe\n // we created above.\n let weapons = builder.create_vector(&[sword, axe]);\n ```\n\n=== \"Swift\"\n\n ```swift\n // Create a FlatBuffer `vector` that contains offsets to the sword and axe\n // we created above.\n let weaponsOffset = builder.createVector(ofOffsets: [sword, axe])\n ```\n\n=== \"TypeScript\"\n\n ```ts\n // Create an array from the two `Weapon`s and pass it to the\n // `createWeaponsVector()` method to create a FlatBuffer vector.\n let weaps = [sword, axe];\n let weapons = MyGame.Sample.Monster.createWeaponsVector(builder, weaps);\n ```\n\n\nWhile we are at it, let us serialize the other two vector fields: the\n`inventory` field is just a vector of scalars, and the `path` field is a vector\nof structs (which are scalar data as well). So these vectors can be serialized a\nbit more directly.\n\n=== \"C++\"\n\n ```c++\n // Create a `vector` representing the inventory of the Orc. Each number\n // could correspond to an item that can be claimed after he is slain.\n unsigned char treasure[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};\n flatbuffers::Offset> inventory =\n builder.CreateVector(treasure, 10);\n\n // Construct an array of two `Vec3` structs.\n Vec3 points[] = { Vec3(1.0f, 2.0f, 3.0f), Vec3(4.0f, 5.0f, 6.0f) };\n\n // Serialize it as a vector of structs.\n flatbuffers::Offset> path =\n builder.CreateVectorOfStructs(points, 2);\n ```\n\n=== \"C\"\n\n ```c\n // Create a `vector` representing the inventory of the Orc. Each number\n // could correspond to an item that can be claimed after he is slain.\n uint8_t treasure[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};\n flatbuffers_uint8_vec_ref_t inventory;\n // `c_vec_len` is the convenience macro we defined earlier.\n inventory = flatbuffers_uint8_vec_create(B, treasure, c_vec_len(treasure));\n ```\n\n=== \"C#\"\n\n ```c#\n // Create a `vector` representing the inventory of the Orc. Each number\n // could correspond to an item that can be claimed after he is slain.\n // Note: Since we prepend the bytes, this loop iterates in reverse order.\n Monster.StartInventoryVector(builder, 10);\n for (int i = 9; i >= 0; i--)\n {\n builder.AddByte((byte)i);\n }\n Offset> inventory = builder.EndVector();\n\n // Start building a path vector of length 2.\n Monster.StartPathVector(fbb, 2);\n\n // Serialize the individual Vec3 structs\n Vec3.CreateVec3(builder, 1.0f, 2.0f, 3.0f);\n Vec3.CreateVec3(builder, 4.0f, 5.0f, 6.0f);\n\n // End the vector to get the offset\n Offset> path = fbb.EndVector();\n ```\n\n=== \"Dart\"\n\n ```dart\n // Create a list representing the inventory of the Orc. Each number\n // could correspond to an item that can be claimed after he is slain.\n final List treasure = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n final inventory = builder.writeListUint8(treasure);\n\n // Using the Builder classes, you can write a list of structs like so:\n // Note that the intended order should be reversed if order is important.\n final vec3Builder = new myGame.Vec3Builder(builder);\n vec3Builder.finish(4.0, 5.0, 6.0);\n vec3Builder.finish(1.0, 2.0, 3.0);\n final int path = builder.endStructVector(2); // the length of the vector\n ```\n\n=== \"Go\"\n\n ```go\n // Create a `vector` representing the inventory of the Orc. Each number\n // could correspond to an item that can be claimed after he is slain.\n // Note: Since we prepend the bytes, this loop iterates in reverse.\n sample.MonsterStartInventoryVector(builder, 10)\n for i := 9; i >= 0; i-- {\n builder.PrependByte(byte(i))\n }\n inv := builder.EndVector(10)\n\n sample.MonsterStartPathVector(builder, 2)\n sample.CreateVec3(builder, 1.0, 2.0, 3.0)\n sample.CreateVec3(builder, 4.0, 5.0, 6.0)\n path := builder.EndVector(2)\n ```\n\n=== \"Java\"\n\n ```java\n // Create a `vector` representing the inventory of the Orc. Each number\n // could correspond to an item that can be claimed after he is slain.\n byte[] treasure = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};\n int inv = Monster.createInventoryVector(builder, treasure);\n\n Monster.startPathVector(fbb, 2);\n Vec3.createVec3(builder, 1.0f, 2.0f, 3.0f);\n Vec3.createVec3(builder, 4.0f, 5.0f, 6.0f);\n int path = fbb.endVector();\n ```\n\n=== \"JavaScript\"\n\n ```javascript\n // Create a `vector` representing the inventory of the Orc. Each number\n // could correspond to an item that can be claimed after he is slain.\n var treasure = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n var inv = MyGame.Sample.Monster.createInventoryVector(builder, treasure);\n\n MyGame.Sample.Monster.startPathVector(builder, 2);\n MyGame.Sample.Vec3.createVec3(builder, 1.0, 2.0, 3.0);\n MyGame.Sample.Vec3.createVec3(builder, 4.0, 5.0, 6.0);\n var path = builder.endVector();\n ```\n\n=== \"Kotlin\"\n\n ```kotlin\n // Create a `vector` representing the inventory of the Orc. Each number\n // could correspond to an item that can be claimed after he is slain.\n val treasure = byteArrayOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)\n val inv = Monster.createInventoryVector(builder, treasure)\n\n Monster.startPathVector(fbb, 2)\n Vec3.createVec3(builder, 1.0f, 2.0f, 3.0f)\n Vec3.createVec3(builder, 4.0f, 5.0f, 6.0f)\n val path = fbb.endVector()\n ```\n\n=== \"Lobster\"\n\n ```lobster\n // Inventory.\n let inv = builder.MyGame_Sample_MonsterCreateInventoryVector(map(10): _)\n\n builder.MyGame_Sample_MonsterStartPathVector(2)\n builder.MyGame_Sample_CreateVec3(1.0, 2.0, 3.0)\n builder.MyGame_Sample_CreateVec3(4.0, 5.0, 6.0)\n let path = builder.EndVector(2)\n ```\n\n=== \"Lua\"\n\n ```lua\n -- Create a `vector` representing the inventory of the Orc. Each number\n -- could correspond to an item that can be claimed after he is slain.\n -- Note: Since we prepend the bytes, this loop iterates in reverse.\n monster.StartInventoryVector(builder, 10)\n for i=10,1,-1 do\n builder:PrependByte(i)\n end\n local inv = builder:EndVector(10)\n\n -- Create a FlatBuffer vector and prepend the path locations.\n -- Note: Since we prepend the data, prepend them in reverse order.\n monster.StartPathVector(builder, 2)\n vec3.CreateVec3(builder, 1.0, 2.0, 3.0)\n vec3.CreateVec3(builder, 4.0, 5.0, 6.0)\n local path = builder:EndVector(2)\n ```\n\n=== \"PHP\"\n\n ```php\n // Create a `vector` representing the inventory of the Orc. Each number\n // could correspond to an item that can be claimed after he is slain.\n $treasure = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);\n $inv = \\MyGame\\Sample\\Monster::CreateInventoryVector($builder, $treasure);\n\n \\MyGame\\Example\\Monster::StartPathVector($builder, 2);\n \\MyGame\\Sample\\Vec3::CreateVec3($builder, 1.0, 2.0, 3.0);\n \\MyGame\\Sample\\Vec3::CreateVec3($builder, 1.0, 2.0, 3.0);\n $path = $builder->endVector();\n ```\n\n=== \"Python\"\n\n ```py\n # Create a `vector` representing the inventory of the Orc. Each number\n # could correspond to an item that can be claimed after he is slain.\n inv = MyGame.Sample.Monster.CreateInventoryVector(builder, range(0, 10))\n\n path_points = [\n MyGame.Sample.Vec3T(x=1.0, y=2.0, z=3.0),\n MyGame.Sample.Vec3T(x=4.0, y=5.0, z=6.0),\n ]\n path = MyGame.Sample.Monster.CreatePathVector(builder, path_points)\n ```\n\n=== \"Rust\"\n\n ```rust\n // Inventory.\n let inventory = builder.create_vector(&[0u8, 1, 2, 3, 4, 5, 6, 7, 8, 9]);\n\n // Create the path vector of Vec3 objects.\n let x = Vec3::new(1.0, 2.0, 3.0);\n let y = Vec3::new(4.0, 5.0, 6.0);\n let path = builder.create_vector(&[x, y]);\n ```\n\n=== \"Swift\"\n\n ```swift\n // create inventory\n let inventory: [Byte] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n let inventoryOffset = builder.createVector(inventory)\n\n let path = fbb.createVector(ofStructs: [\n Vec3(x: 1, y: 2, z: 3),\n Vec3(x: 4, y: 5, z: 6)\n ])\n ```\n\n=== \"TypeScript\"\n\n ```ts\n // Create a `vector` representing the inventory of the Orc. Each number\n // could correspond to an item that can be claimed after he is slain.\n let treasure = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n let inv = MyGame.Sample.Monster.createInventoryVector(builder, treasure);\n\n MyGame.Sample.Monster.startPathVector(builder, 2);\n MyGame.Sample.Vec3.createVec3(builder, 1.0, 2.0, 3.0);\n MyGame.Sample.Vec3.createVec3(builder, 4.0, 5.0, 6.0);\n let path = builder.endVector();\n ```\n\n\n#### Unions\n\nThe last non-scalar data field for the `Monster` table is the `equipped` `union`\nfield. For this case, we will reuse an already serialized `Weapon` (the only\ntype in the union), without needing to reserialize it. Union fields implicitly\nadd a hidden `_type` field that stores the type of value stored in the union.\nWhen serializing a union, you must explicitly set this type field, along with\nproviding the union value.\n\nWe will also serialize the other scalar data at the same time, since we have all\nthe necessary values and Offsets to make a `Monster`.\n\n=== \"C++\"\n\n ```c++\n // Create the remaining data needed for the Monster.\n auto name = builder.CreateString(\"Orc\");\n\n // Create the position struct\n auto position = Vec3(1.0f, 2.0f, 3.0f);\n\n // Set his hit points to 300 and his mana to 150.\n int hp = 300;\n int mana = 150;\n\n // Finally, create the monster using the `CreateMonster` helper function\n // to set all fields.\n //\n // Here we set the union field by using the `.Union()` method of the\n // `Offset` axe we already serialized above. We just have to specify\n // which type of object we put in the union, and do that with the\n // auto-generated `Equipment_Weapon` enum.\n flatbuffers::Offset orc =\n CreateMonster(builder, &position, mana, hp, name, inventory,\n Color_Red, weapons, Equipment_Weapon, axe.Union(),\n path);\n\n ```\n\n=== \"C\"\n\n ```c\n // Serialize a name for our monster, called \"Orc\".\n // The _str suffix indicates the source is an ascii-z string.\n flatbuffers_string_ref_t name = flatbuffers_string_create_str(B, \"Orc\");\n\n // Set his hit points to 300 and his mana to 150.\n uint16_t hp = 300;\n uint16_t mana = 150;\n\n // Define an equipment union. `create` calls in C has a single\n // argument for unions where C++ has both a type and a data argument.\n ns(Equipment_union_ref_t) equipped = ns(Equipment_as_Weapon(axe));\n ns(Vec3_t) pos = { 1.0f, 2.0f, 3.0f };\n ns(Monster_create_as_root(B, &pos, mana, hp, name, inventory, ns(Color_Red),\n weapons, equipped, path));\n ```\n\n=== \"C#\"\n\n ```c#\n // Create the remaining data needed for the Monster.\n var name = builder.CreateString(\"Orc\");\n\n // Create our monster using `StartMonster()` and `EndMonster()`.\n Monster.StartMonster(builder);\n Monster.AddPos(builder, Vec3.CreateVec3(builder, 1.0f, 2.0f, 3.0f));\n Monster.AddHp(builder, (short)300);\n Monster.AddName(builder, name);\n Monster.AddInventory(builder, inv);\n Monster.AddColor(builder, Color.Red);\n Monster.AddWeapons(builder, weapons);\n // For union fields, we explicitly add the auto-generated enum for the type\n // of value stored in the union.\n Monster.AddEquippedType(builder, Equipment.Weapon);\n // And we just use the `.Value` property of the already serialized axe.\n Monster.AddEquipped(builder, axe.Value); // Axe\n Monster.AddPath(builder, path);\n Offset orc = Monster.EndMonster(builder);\n ```\n\n=== \"Dart\"\n\n ```dart\n // Serialize a name for our monster, called \"Orc\".\n final int name = builder.writeString('Orc');\n\n // Using the Builder API:\n // Set his hit points to 300 and his mana to 150.\n final int hp = 300;\n final int mana = 150;\n\n final monster = new myGame.MonsterBuilder(builder)\n ..begin()\n ..addNameOffset(name)\n ..addInventoryOffset(inventory)\n ..addWeaponsOffset(weapons)\n ..addEquippedType(myGame.EquipmentTypeId.Weapon)\n ..addEquippedOffset(axe)\n ..addHp(hp)\n ..addMana(mana)\n ..addPos(vec3Builder.finish(1.0, 2.0, 3.0))\n ..addPathOffset(path)\n ..addColor(myGame.Color.Red);\n\n final int orc = monster.finish();\n ```\n\n=== \"Go\"\n\n ```go\n // Serialize a name for our monster, called \"Orc\".\n name := builder.CreateString(\"Orc\")\n\n // Create our monster using `MonsterStart()` and `MonsterEnd()`.\n sample.MonsterStart(builder)\n sample.MonsterAddPos(builder, sample.CreateVec3(builder, 1.0, 2.0, 3.0))\n sample.MonsterAddHp(builder, 300)\n sample.MonsterAddName(builder, name)\n sample.MonsterAddInventory(builder, inv)\n sample.MonsterAddColor(builder, sample.ColorRed)\n sample.MonsterAddWeapons(builder, weapons)\n sample.MonsterAddEquippedType(builder, sample.EquipmentWeapon)\n sample.MonsterAddEquipped(builder, axe)\n sample.MonsterAddPath(builder, path)\n orc := sample.MonsterEnd(builder)\n ```\n\n=== \"Java\"\n\n ```java\n // Serialize a name for our monster, called \"Orc\".\n int name = builder.createString(\"Orc\");\n\n // Create our monster using `startMonster()` and `endMonster()`.\n Monster.startMonster(builder);\n Monster.addPos(builder, Vec3.createVec3(builder, 1.0f, 2.0f, 3.0f));\n Monster.addName(builder, name);\n Monster.addColor(builder, Color.Red);\n Monster.addHp(builder, (short)300);\n Monster.addInventory(builder, inv);\n Monster.addWeapons(builder, weapons);\n Monster.addEquippedType(builder, Equipment.Weapon);\n Monster.addEquipped(builder, axe);\n Monster.addPath(builder, path);\n int orc = Monster.endMonster(builder);\n ```\n\n=== \"JavaScript\"\n\n ```javascript\n // Serialize a name for our monster, called 'Orc'.\n var name = builder.createString('Orc');\n\n // Create our monster by using `startMonster()` and `endMonster()`.\n MyGame.Sample.Monster.startMonster(builder);\n MyGame.Sample.Monster.addPos(builder,\n MyGame.Sample.Vec3.createVec3(builder, 1.0, 2.0, 3.0));\n MyGame.Sample.Monster.addHp(builder, 300);\n MyGame.Sample.Monster.addColor(builder, MyGame.Sample.Color.Red)\n MyGame.Sample.Monster.addName(builder, name);\n MyGame.Sample.Monster.addInventory(builder, inv);\n MyGame.Sample.Monster.addWeapons(builder, weapons);\n MyGame.Sample.Monster.addEquippedType(builder,\n MyGame.Sample.Equipment.Weapon);\n MyGame.Sample.Monster.addEquipped(builder, axe);\n MyGame.Sample.Monster.addPath(builder, path);\n var orc = MyGame.Sample.Monster.endMonster(builder);\n ```\n\n=== \"Kotlin\"\n\n ```kotlin\n // Serialize a name for our monster, called \"Orc\".\n val name = builder.createString(\"Orc\")\n\n // Create our monster using `startMonster()` and `endMonster()`.\n Monster.startMonster(builder)\n Monster.addPos(builder, Vec3.createVec3(builder, 1.0f, 2.0f, 3.0f))\n Monster.addName(builder, name)\n Monster.addColor(builder, Color.Red)\n Monster.addHp(builder, 300.toShort())\n Monster.addInventory(builder, inv)\n Monster.addWeapons(builder, weapons)\n Monster.addEquippedType(builder, Equipment.Weapon)\n Monster.addEquipped(builder, axe)\n Monster.addPath(builder, path)\n val orc = Monster.endMonster(builder)\n ```\n\n=== \"Lobster\"\n\n ```lobster\n // Name of the monster.\n let name = builder.CreateString(\"Orc\")\n\n let orc = MyGame_Sample_MonsterBuilder { b }\n .start()\n .add_pos(b.MyGame_Sample_CreateVec3(1.0, 2.0, 3.0))\n .add_hp(300)\n .add_name(name)\n .add_inventory(inv)\n .add_color(MyGame_Sample_Color_Red)\n .add_weapons(weapons)\n .add_equipped_type(MyGame_Sample_Equipment_Weapon)\n .add_equipped(weapon_offsets[1])\n .add_path(path)\n .end()\n ```\n\n=== \"Lua\"\n\n ```lua\n -- Serialize a name for our monster, called 'orc'\n local name = builder:CreateString(\"Orc\")\n\n -- Create our monster by using Start() andEnd()\n monster.Start(builder)\n monster.AddPos(builder, vec3.CreateVec3(builder, 1.0, 2.0, 3.0))\n monster.AddHp(builder, 300)\n monster.AddName(builder, name)\n monster.AddInventory(builder, inv)\n monster.AddColor(builder, color.Red)\n monster.AddWeapons(builder, weapons)\n monster.AddEquippedType(builder, equipment.Weapon)\n monster.AddEquipped(builder, axe)\n monster.AddPath(builder, path)\n local orc = monster.End(builder)\n ```\n\n=== \"PHP\"\n\n ```php\n // Serialize a name for our monster, called \"Orc\".\n $name = $builder->createString(\"Orc\");\n\n // Create our monster by using `StartMonster()` and `EndMonster()`.\n \\MyGame\\Sample\\Monster::StartMonster($builder);\n \\MyGame\\Sample\\Monster::AddPos($builder,\n \\MyGame\\Sample\\Vec3::CreateVec3($builder, 1.0, 2.0, 3.0));\n \\MyGame\\Sample\\Monster::AddHp($builder, 300);\n \\MyGame\\Sample\\Monster::AddName($builder, $name);\n \\MyGame\\Sample\\Monster::AddInventory($builder, $inv);\n \\MyGame\\Sample\\Monster::AddColor($builder, \\MyGame\\Sample\\Color::Red);\n \\MyGame\\Sample\\Monster::AddWeapons($builder, $weapons);\n \\MyGame\\Sample\\Monster::AddEquippedType($builder,\n \\MyGame\\Sample\\Equipment::Weapon);\n \\MyGame\\Sample\\Monster::AddEquipped($builder, $axe);\n \\MyGame\\Sample\\Monster::AddPath($builder, $path);\n $orc = \\MyGame\\Sample\\Monster::EndMonster($builder);\n ```\n\n=== \"Python\"\n\n ```py\n # Serialize a name for our monster, called \"Orc\".\n name = builder.CreateString(\"Orc\")\n\n # Create our monster by using `Monster.Start()` and `Monster.End()`.\n MyGame.Sample.Monster.Start(builder)\n MyGame.Sample.Monster.AddPos(builder,\n MyGame.Sample.Vec3.CreateVec3(builder, 1.0, 2.0, 3.0))\n MyGame.Sample.Monster.AddHp(builder, 300)\n MyGame.Sample.Monster.AddName(builder, name)\n MyGame.Sample.Monster.AddInventory(builder, inv)\n MyGame.Sample.Monster.AddColor(builder,\n MyGame.Sample.Color.Color().Red)\n MyGame.Sample.Monster.AddWeapons(builder, weapons)\n MyGame.Sample.Monster.AddEquippedType(\n builder, MyGame.Sample.Equipment.Equipment().Weapon)\n MyGame.Sample.Monster.AddEquipped(builder, axe)\n MyGame.Sample.Monster.AddPath(builder, path)\n orc = MyGame.Sample.Monster.End(builder)\n ```\n\n=== \"Rust\"\n\n ```rust\n // Name of the Monster.\n let name = builder.create_string(\"Orc\");\n\n // Create the monster using the `Monster::create` helper function. This\n // function accepts a `MonsterArgs` struct, which supplies all of the data\n // needed to build a `Monster`. To supply empty/default fields, just use the\n // Rust built-in `Default::default()` function, as demonstrated below.\n let orc = Monster::create(&mut builder, &MonsterArgs{\n pos: Some(&Vec3::new(1.0f32, 2.0f32, 3.0f32)),\n mana: 150,\n hp: 80,\n name: Some(name),\n inventory: Some(inventory),\n color: Color::Red,\n weapons: Some(weapons),\n equipped_type: Equipment::Weapon,\n equipped: Some(axe.as_union_value()),\n path: Some(path),\n ..Default::default()\n });\n ```\n\n=== \"Swift\"\n\n ```swift\n // Name of the Monster.\n let name = builder.create(string: \"Orc\")\n\n let orc = Monster.createMonster(\n &builder,\n pos: MyGame_Sample_Vec3(x: 1, y: 2, z: 3),\n hp: 300,\n nameOffset: name,\n inventoryVectorOffset: inventoryOffset,\n color: .red,\n weaponsVectorOffset: weaponsOffset,\n equippedType: .weapon,\n equippedOffset: axe)\n ```\n\n=== \"TypeScript\"\n\n ```ts\n // Serialize a name for our monster, called 'Orc'.\n let name = builder.createString('Orc');\n\n // Create our monster by using `startMonster()` and `endMonster()`.\n MyGame.Sample.Monster.startMonster(builder);\n MyGame.Sample.Monster.addPos(builder,\n MyGame.Sample.Vec3.createVec3(builder, 1.0, 2.0, 3.0));\n MyGame.Sample.Monster.addHp(builder, 300);\n MyGame.Sample.Monster.addColor(builder, MyGame.Sample.Color.Red)\n MyGame.Sample.Monster.addName(builder, name);\n MyGame.Sample.Monster.addInventory(builder, inv);\n MyGame.Sample.Monster.addWeapons(builder, weapons);\n MyGame.Sample.Monster.addEquippedType(builder,\n MyGame.Sample.Equipment.Weapon);\n MyGame.Sample.Monster.addEquipped(builder, axe);\n MyGame.Sample.Monster.addPath(builder, path);\n let orc = MyGame.Sample.Monster.endMonster(builder);\n ```\n\n\n### Finishing\n\nAt this point, we have serialized a `Monster` we've named \"orc\" to the\nflatbuffer and have its offset. The `root_type` of the schema is also a\n`Monster`, so we have everything we need to finish the serialization step.\n\nThis is done by calling the appropriate `finish` method on the Builder, passing\nin the orc offset to indicate this `table` is the \"entry\" point when\ndeserializing the buffer later.\n\n=== \"C++\"\n\n ```c++\n // Call `Finish()` to instruct the builder that this monster is complete.\n // You could also call `FinishMonsterBuffer(builder, orc);`\n builder.Finish(orc);\n ```\n\n=== \"C\"\n\n ```c\n // Because we used `Monster_create_as_root`, we do not need a `finish` call\n // in C.\n ```\n\n=== \"C#\"\n\n ```c#\n // Call `Finish()` to instruct the builder that this monster is complete.\n // You could also call `Monster.FinishMonsterBuffer(builder, orc);`\n builder.Finish(orc.Value);\n ```\n\n=== \"Dart\"\n\n ```dart\n // Call `finish()` to instruct the builder that this monster is complete.\n // See the next code section, as in Dart `finish` will also return the byte\n // array.\n ```\n\n=== \"Go\"\n\n ```go\n // Call `Finish()` to instruct the builder that this monster is complete.\n builder.Finish(orc)\n ```\n\n=== \"Java\"\n\n ```java\n // Call `finish()` to instruct the builder that this monster is complete.\n builder.finish(orc);\n ```\n\n=== \"JavaScript\"\n\n ```javascript\n // Call `finish()` to instruct the builder that this monster is complete.\n builder.finish(orc);\n ```\n\n=== \"Kotlin\"\n\n ```kotlin\n // Call `finish()` to instruct the builder that this monster is complete.\n builder.finish(orc) ;\n ```\n\n=== \"Lobster\"\n\n ```lobster\n // Call `Finish()` to instruct the builder that this monster is complete.\n builder.Finish(orc)\n ```\n\n=== \"Lua\"\n\n ```lua\n -- Call 'Finish()' to instruct the builder that this monster is complete.\n builder:Finish(orc)\n ```\n\n=== \"PHP\"\n\n ```php\n // Call `finish()` to instruct the builder that this monster is complete.\n $builder->finish($orc);\n ```\n\n=== \"Python\"\n\n ```py\n # Call `Finish()` to instruct the builder that this monster is complete.\n builder.Finish(orc)\n ```\n\n=== \"Rust\"\n\n ```rust\n // Call `finish()` to instruct the builder that this monster is complete.\n builder.finish(orc, None);\n ```\n\n=== \"Swift\"\n\n ```swift\n // Call `finish()` to instruct the builder that this monster is complete.\n builder.finish(offset: orc)\n ```\n\n=== \"TypeScript\"\n\n ```ts\n // Call `finish()` to instruct the builder that this monster is complete.\n builder.finish(orc);\n ```\n\n\nOnce you finish a Builder, you can no longer serialize more data to it.\n\n#### Buffer Access\n\nThe flatbuffer is now ready to be stored somewhere, sent over the network,\ncompressed, or whatever you would like to do with it. You access the raw buffer\nlike so:\n\n=== \"C++\"\n\n ```c++\n // This must be called after `Finish()`.\n uint8_t *buf = builder.GetBufferPointer();\n\n // Returns the size of the buffer that `GetBufferPointer()` points to.\n int size = builder.GetSize();\n ```\n\n=== \"C\"\n\n ```c\n uint8_t *buf;\n size_t size;\n\n // Allocate and extract a readable buffer from internal builder heap.\n // The returned buffer must be deallocated using `free`.\n // NOTE: Finalizing the buffer does NOT change the builder, it\n // just creates a snapshot of the builder content.\n buf = flatcc_builder_finalize_buffer(B, &size);\n // use buf\n free(buf);\n\n // Optionally reset builder to reuse builder without deallocating\n // internal stack and heap.\n flatcc_builder_reset(B);\n // build next buffer.\n // ...\n\n // Cleanup.\n flatcc_builder_clear(B);\n ```\n\n=== \"C#\"\n\n ```c#\n // This must be called after `Finish()`.\n //\n // The data in this ByteBuffer does NOT start at 0, but at buf.Position.\n // The end of the data is marked by buf.Length, so the size is\n // buf.Length - buf.Position.\n FlatBuffers.ByteBuffer dataBuffer = builder.DataBuffer;\n\n // Alternatively this copies the above data out of the ByteBuffer for you:\n byte[] buf = builder.SizedByteArray();\n ```\n\n=== \"Dart\"\n\n ```dart\n final Uint8List buf = builder.finish(orc);\n ```\n\n=== \"Go\"\n\n ```go\n // This must be called after `Finish()`.\n buf := builder.FinishedBytes() // Of type `byte[]`.\n ```\n\n=== \"Java\"\n\n ```java\n // This must be called after `finish()`.\n java.nio.ByteBuffer buf = builder.dataBuffer();\n // The data in this ByteBuffer does NOT start at 0, but at buf.position().\n // The number of bytes is buf.remaining().\n\n // Alternatively this copies the above data out of the ByteBuffer for you:\n byte[] buf = builder.sizedByteArray();\n ```\n\n=== \"JavaScript\"\n\n ```javascript\n // This must be called after `finish()`.\n var buf = builder.asUint8Array(); // Of type `Uint8Array`.\n ```\n\n=== \"Kotlin\"\n\n ```kotlin\n // This must be called after `finish()`.\n val buf = builder.dataBuffer()\n // The data in this ByteBuffer does NOT start at 0, but at buf.position().\n // The number of bytes is buf.remaining().\n\n // Alternatively this copies the above data out of the ByteBuffer for you:\n val buf = builder.sizedByteArray()\n ```\n\n=== \"Lobster\"\n\n ```lobster\n // This must be called after `Finish()`.\n let buf = builder.SizedCopy() // Of type `string`.\n ```\n\n=== \"Lua\"\n\n ```lua\n local bufAsString = builder:Output()\n ```\n\n=== \"PHP\"\n\n ```php\n // This must be called after `finish()`.\n $buf = $builder->dataBuffer(); // Of type `Google\\FlatBuffers\\ByteBuffer`\n // The data in this ByteBuffer does NOT start at 0, but at\n // buf->getPosition().\n // The end of the data is marked by buf->capacity(), so the size is\n // buf->capacity() - buf->getPosition().\n ```\n\n=== \"Python\"\n\n ```py\n # This must be called after `Finish()`.\n buf = builder.Output() // Of type `bytearray`.\n ```\n\n=== \"Rust\"\n\n ```rust\n // This must be called after `finish()`.\n // `finished_data` returns a byte slice.\n let buf = builder.finished_data(); // Of type `&[u8]`\n ```\n\n=== \"Swift\"\n\n ```swift\n // This must be called after `finish()`.\n // `sizedByteArray` returns the finished buf of type [UInt8].\n let buf = builder.sizedByteArray\n // or you can use to get an object of type Data\n let bufData = ByteBuffer(data: builder.data)\n // or\n let buf = builder.sizedBuffer\n ```\n\n=== \"TypeScript\"\n\n ```ts\n // This must be called after `finish()`.\n let buf = builder.asUint8Array(); // Of type `Uint8Array`.\n ```\n\n\nNow you can write the bytes to a file or send them over the network. The buffer\nstays valid until the Builder is cleared or destroyed.\n\nMake sure your file mode (or transfer protocol) is set to BINARY, and not TEXT.\nIf you try to transfer a flatbuffer in TEXT mode, the buffer will be corrupted\nand be hard to diagnose.\n\n## Deserialization\n\nDeserialization is a bit of a misnomer, since FlatBuffers doesn't deserialize\nthe whole buffer when accessed. It just \"decodes\" the data that is requested,\nleaving all the other data untouched. It is up to the application to decide if\nthe data is copied out or even read in the first place. However, we continue to\nuse the word `deserialize` to mean accessing data from a binary flatbuffer.\n\nNow that we have successfully create an orc FlatBuffer, the data can be saved,\nsent over a network, etc. At some point, the buffer will be accessed to obtain\nthe underlying data.\n\nThe same application setup used for serialization is needed for deserialization\n(see [application integration](#application-integration)).\n\n### Root Access\n\nAll access to the data in the flatbuffer must first go through the root object.\nThere is only one root object per flatbuffer. The generated code provides\nfunctions to get the root object given the buffer.\n\n=== \"C++\"\n\n ```c++\n uint8_t *buffer_pointer = /* the data you just read */;\n\n // Get a view to the root object inside the buffer.\n Monster monster = GetMonster(buffer_pointer);\n ```\n\n=== \"C\"\n\n ```c\n // Note that we use the `table_t` suffix when reading a table object\n // as opposed to the `ref_t` suffix used during the construction of\n // the buffer.\n ns(Monster_table_t) monster = ns(Monster_as_root(buffer));\n\n // Note: root object pointers are NOT the same as the `buffer` pointer.\n ```\n\n=== \"C#\"\n\n ```c#\n byte[] bytes = /* the data you just read */\n\n // Get a view to the root object inside the buffer.\n Monster monster = Monster.GetRootAsMonster(new ByteBuffer(bytes));\n ```\n\n=== \"Dart\"\n\n ```dart\n List data = ... // the data, e.g. from file or network\n // A generated factory constructor that will read the data.\n myGame.Monster monster = new myGame.Monster(data);\n ```\n\n=== \"Go\"\n\n ```go\n var buf []byte = /* the data you just read */\n\n // Get an accessor to the root object inside the buffer.\n monster := sample.GetRootAsMonster(buf, 0)\n\n // Note: We use `0` for the offset here, which is typical for most buffers\n // you would read. If you wanted to read from `builder.Bytes` directly, you\n // would need to pass in the offset of `builder.Head()`, as the builder\n // constructs the buffer backwards, so may not start at offset 0.\n ```\n\n=== \"Java\"\n\n ```java\n byte[] bytes = /* the data you just read */\n java.nio.ByteBuffer buf = java.nio.ByteBuffer.wrap(bytes);\n\n // Get an accessor to the root object inside the buffer.\n Monster monster = Monster.getRootAsMonster(buf);\n ```\n\n=== \"JavaScript\"\n\n ```javascript\n // the data you just read, as a `Uint8Array`\n // Note that the example here uses `readFileSync` from the built-in `fs`\n // module, but other methods for accessing the file contents will also work.\n var bytes = new Uint8Array(readFileSync('./monsterdata.bin'));\n\n var buf = new flatbuffers.ByteBuffer(bytes);\n\n // Get an accessor to the root object inside the buffer.\n var monster = MyGame.Sample.Monster.getRootAsMonster(buf);\n ```\n\n=== \"Kotlin\"\n\n ```kotlin\n val bytes = /* the data you just read */\n val buf = java.nio.ByteBuffer.wrap(bytes)\n\n // Get an accessor to the root object inside the buffer.\n Monster monster = Monster.getRootAsMonster(buf)\n ```\n\n=== \"Lobster\"\n\n ```lobster\n buf = /* the data you just read, in a string */\n\n // Get an accessor to the root object inside the buffer.\n let monster = MyGame_Sample_GetRootAsMonster(buf)\n ```\n\n=== \"Lua\"\n\n ```lua\n local bufAsString = -- The data you just read in\n\n -- Convert the string representation into binary array Lua structure\n local buf = flatbuffers.binaryArray.New(bufAsString)\n\n -- Get an accessor to the root object insert the buffer\n local mon = monster.GetRootAsMonster(buf, 0)\n ```\n\n=== \"PHP\"\n\n ```php\n $bytes = /* the data you just read, in a string */\n $buf = Google\\FlatBuffers\\ByteBuffer::wrap($bytes);\n\n // Get an accessor to the root object inside the buffer.\n $monster = \\MyGame\\Sample\\Monster::GetRootAsMonster($buf);\n ```\n\n=== \"Python\"\n\n ```py\n buf = /* the data you just read, in an object of type \"bytearray\" */\n\n # Get an accessor to the root object inside the buffer.\n monster = MyGame.Sample.Monster.Monster.GetRootAs(buf, 0)\n\n # Note: We use `0` for the offset here, which is typical for most buffers\n # you would read. If you wanted to read from the `builder.Bytes` directly,\n # you would need to pass in the offset of `builder.Head()`, as the builder\n # constructs the buffer backwards, so may not start at offset 0.\n ```\n\n=== \"Rust\"\n\n ```rust\n let buf = /* the data you just read, in a &[u8] */\n\n // Get an accessor to the root object inside the buffer.\n let monster = root_as_monster(buf).unwrap();\n ```\n\n=== \"Swift\"\n\n ```swift\n // create a ByteBuffer(:) from an [UInt8] or Data()\n var buf = // Get your data\n // Get an accessor to the root object inside the buffer.\n let monster: Monster = try! getCheckedRoot(byteBuffer: &byteBuffer)\n // let monster: Monster = getRoot(byteBuffer: &byteBuffer)\n ```\n\n=== \"TypeScript\"\n\n ```ts\n // the data you just read, as a `Uint8Array`.\n // Note that the example here uses `readFileSync` from the built-in `fs`\n // module, but other methods for accessing the file contents will also work.\n let bytes = new Uint8Array(readFileSync('./monsterdata.bin'));\n\n let buf = new flatbuffers.ByteBuffer(bytes);\n\n // Get an accessor to the root object inside the buffer.\n let monster = MyGame.Sample.Monster.getRootAsMonster(buf);\n ```\n\n\nAgain, make sure you read the bytes in BINARY mode, otherwise the buffer may be\ncorrupted.\n\nIn most languages, the returned object is just a \"view\" of the data with helpful\naccessors. Data is typically not copied out of the backing buffer. This also\nmeans the backing buffer must remain alive for the duration of the views.\n\n### Table Access\n\nIf you look in the generated files emitted by `flatc`, you will see it generated\n, for each `table`, accessors of all its non-`deprecated` fields. For example,\nsome of the accessors of the `Monster` root table would look like:\n\n=== \"C++\"\n\n ```c++\n auto hp = monster->hp();\n auto mana = monster->mana();\n auto name = monster->name()->c_str();\n ```\n\n=== \"C\"\n\n ```c\n uint16_t hp = ns(Monster_hp(monster));\n uint16_t mana = ns(Monster_mana(monster));\n flatbuffers_string_t name = ns(Monster_name(monster));\n ```\n\n=== \"C#\"\n\n ```c#\n // For C#, unlike most other languages support by FlatBuffers, most values\n // (except for vectors and unions) are available as properties instead of\n // accessor methods.\n var hp = monster.Hp;\n var mana = monster.Mana;\n var name = monster.Name;\n ```\n\n=== \"Dart\"\n\n ```dart\n // For Dart, unlike other languages support by FlatBuffers, most values\n // are available as properties instead of accessor methods.\n var hp = monster.hp;\n var mana = monster.mana;\n var name = monster.name;\n ```\n\n=== \"Go\"\n\n ```go\n hp := monster.Hp()\n mana := monster.Mana()\n name := string(monster.Name()) // Note: `monster.Name()` returns a byte[].\n ```\n\n=== \"Java\"\n\n ```java\n short hp = monster.hp();\n short mana = monster.mana();\n String name = monster.name();\n ```\n\n=== \"JavaScript\"\n\n ```javascript\n var hp = monster.hp();\n var mana = monster.mana();\n var name = monster.name();\n ```\n\n=== \"Kotlin\"\n\n ```kotlin\n val hp = monster.hp\n val mana = monster.mana\n val name = monster.name\n ```\n\n=== \"Lobster\"\n\n ```lobster\n let hp = monster.hp\n let mana = monster.mana\n let name = monster.name\n ```\n\n=== \"Lua\"\n\n ```lua\n local hp = mon:Hp()\n local mana = mon:Mana()\n local name = mon:Name()\n ```\n\n=== \"PHP\"\n\n ```php\n $hp = $monster->getHp();\n $mana = $monster->getMana();\n $name = monster->getName();\n ```\n\n=== \"Python\"\n\n ```py\n hp = monster.Hp()\n mana = monster.Mana()\n name = monster.Name()\n ```\n\n=== \"Rust\"\n\n ```rust\n // Get and test some scalar types from the FlatBuffer.\n let hp = monster.hp();\n let mana = monster.mana();\n let name = monster.name();\n ```\n\n=== \"Swift\"\n\n ```swift\n let hp = monster.hp\n let mana = monster.mana\n let name = monster.name // returns an optional string\n ```\n\n=== \"TypeScript\"\n\n ```ts\n let hp = monster.hp();\n let mana = monster.mana();\n let name = monster.name();\n ```\n\n\nThese accessors should hold the values `300`, `150`, and `\"Orc\"` respectively.\n\nThe default value of `150` wasn't stored in the `mana` field, but we are still\nable to retrieve it. That is because the generated accessors return a hard-coded\ndefault value when it doesn't find the value in the buffer.\n\n#### Nested Object Access\n\nAccessing nested objects is very similar, with the nested field pointing to\nanother object type. Be careful, the field could be `null` if not present.\n\nFor example, accessing the `pos` `struct`, which is type `Vec3` you would do:\n\n=== \"C++\"\n\n ```c++\n auto pos = monster->pos();\n auto x = pos->x();\n auto y = pos->y();\n auto z = pos->z();\n ```\n\n=== \"C\"\n\n ```c\n ns(Vec3_struct_t) pos = ns(Monster_pos(monster));\n float x = ns(Vec3_x(pos));\n float y = ns(Vec3_y(pos));\n float z = ns(Vec3_z(pos));\n ```\n\n=== \"C#\"\n\n ```c#\n var pos = monster.Pos.Value;\n var x = pos.X;\n var y = pos.Y;\n var z = pos.Z;\n ```\n\n=== \"Dart\"\n\n ```dart\n myGame.Vec3 pos = monster.pos;\n double x = pos.x;\n double y = pos.y;\n double z = pos.z;\n ```\n\n=== \"Go\"\n\n ```go\n pos := monster.Pos(nil)\n x := pos.X()\n y := pos.Y()\n z := pos.Z()\n\n // Note: Whenever you access a new object, like in `Pos()`, a new temporary\n // accessor object gets created. If your code is very performance sensitive,\n // you can pass in a pointer to an existing `Vec3` instead of `nil`. This\n // allows you to reuse it across many calls to reduce the amount of object\n // allocation/garbage collection.\n ```\n\n=== \"Java\"\n\n ```java\n Vec3 pos = monster.pos();\n float x = pos.x();\n float y = pos.y();\n float z = pos.z();\n ```\n\n=== \"JavaScript\"\n\n ```javascript\n var pos = monster.pos();\n var x = pos.x();\n var y = pos.y();\n var z = pos.z();\n ```\n\n=== \"Kotlin\"\n\n ```kotlin\n val pos = monster.pos!!\n val x = pos.x\n val y = pos.y\n val z = pos.z\n ```\n\n=== \"Lobster\"\n\n ```lobster\n let pos = monster.pos\n let x = pos.x\n let y = pos.y\n let z = pos.z\n ```\n\n=== \"Lua\"\n\n ```lua\n local pos = mon:Pos()\n local x = pos:X()\n local y = pos:Y()\n local z = pos:Z()\n ```\n\n=== \"PHP\"\n\n ```php\n $pos = $monster->getPos();\n $x = $pos->getX();\n $y = $pos->getY();\n $z = $pos->getZ();\n ```\n\n=== \"Python\"\n\n ```py\n pos = monster.Pos()\n x = pos.X()\n y = pos.Y()\n z = pos.Z()\n ```\n\n=== \"Rust\"\n\n ```rust\n let pos = monster.pos().unwrap();\n let x = pos.x();\n let y = pos.y();\n let z = pos.z();\n ```\n\n=== \"Swift\"\n\n ```swift\n let pos = monster.pos\n let x = pos.x\n let y = pos.y\n let z = pos.z\n ```\n\n=== \"TypeScript\"\n\n ```ts\n let pos = monster.pos();\n let x = pos.x();\n let y = pos.y();\n let z = pos.z();\n ```\n\n\nWhere `x`, `y`, and `z` will contain `1.0`, `2.0`, and `3.0` respectively.\n\n### Vector Access\n\nSimilarly, we can access elements of the `inventory` `vector` by indexing it.\nYou can also iterate over the length of the vector.\n\n=== \"C++\"\n\n ```c++\n flatbuffers::Vector inv = monster->inventory();\n auto inv_len = inv->size();\n auto third_item = inv->Get(2);\n ```\n\n=== \"C\"\n\n ```c\n // If `inv` hasn't been set, it will be null. It is valid get\n // the length of null which will be 0, useful for iteration.\n flatbuffers_uint8_vec_t inv = ns(Monster_inventory(monster));\n size_t inv_len = flatbuffers_uint8_vec_len(inv);\n ```\n\n=== \"C#\"\n\n ```c#\n int invLength = monster.InventoryLength;\n var thirdItem = monster.Inventory(2);\n ```\n\n=== \"Dart\"\n\n ```dart\n int invLength = monster.inventory.length;\n var thirdItem = monster.inventory[2];\n ```\n\n=== \"Go\"\n\n ```go\n invLength := monster.InventoryLength()\n thirdItem := monster.Inventory(2)\n ```\n\n=== \"Java\"\n\n ```java\n int invLength = monster.inventoryLength();\n byte thirdItem = monster.inventory(2);\n ```\n\n=== \"JavaScript\"\n\n ```javascript\n var invLength = monster.inventoryLength();\n var thirdItem = monster.inventory(2);\n ```\n\n=== \"Kotlin\"\n\n ```kotlin\n val invLength = monster.inventoryLength\n val thirdItem = monster.inventory(2)!!\n ```\n\n=== \"Lobster\"\n\n ```lobster\n let inv_len = monster.inventory_length\n let third_item = monster.inventory(2)\n ```\n\n=== \"Lua\"\n\n ```lua\n local invLength = mon:InventoryLength()\n local thirdItem = mon:Inventory(3) -- Lua is 1-based\n ```\n\n=== \"PHP\"\n\n ```php\n $inv_len = $monster->getInventoryLength();\n $third_item = $monster->getInventory(2);\n ```\n\n=== \"Python\"\n\n ```py\n inv_len = monster.InventoryLength()\n third_item = monster.Inventory(2)\n ```\n\n=== \"Rust\"\n\n ```rust\n // Get and test an element from the `inventory` FlatBuffer's `vector`.\n let inv = monster.inventory().unwrap();\n\n // Note that this vector is returned as a slice, because direct access for\n // this type, a `u8` vector, is safe on all platforms:\n let third_item = inv[2];\n ```\n\n=== \"Swift\"\n\n ```swift\n // Get a the count of objects in the vector\n let count = monster.inventoryCount\n\n // get item at index 4\n let object = monster.inventory(at: 4)\n\n // or you can fetch the entire array\n let inv = monster.inventory\n // inv[4] should equal object\n ```\n\n=== \"TypeScript\"\n\n ```ts\n let invLength = monster.inventoryLength();\n let thirdItem = monster.inventory(2);\n ```\n\n\nFor vectors of tables, you can access the elements like any other vector, except\nyou need to handle the result as a FlatBuffer table. Here we iterate over the\n`weapons` vector that is houses `Weapon` `tables`.\n\n=== \"C++\"\n\n ```c++\n flatbuffers::Vector weapons = monster->weapons();\n auto weapon_len = weapons->size();\n auto second_weapon_name = weapons->Get(1)->name()->str();\n auto second_weapon_damage = weapons->Get(1)->damage()\n ```\n\n=== \"C\"\n\n ```c\n ns(Weapon_vec_t) weapons = ns(Monster_weapons(monster));\n size_t weapons_len = ns(Weapon_vec_len(weapons));\n // We can use `const char *` instead of `flatbuffers_string_t`.\n const char *second_weapon_name =\n ns(Weapon_name(ns(Weapon_vec_at(weapons, 1))));\n uint16_t second_weapon_damage =\n ns(Weapon_damage(ns(Weapon_vec_at(weapons, 1))));\n ```\n\n=== \"C#\"\n\n ```c#\n int weaponsLength = monster.WeaponsLength;\n var secondWeaponName = monster.Weapons(1).Name;\n var secondWeaponDamage = monster.Weapons(1).Damage;\n ```\n\n=== \"Dart\"\n\n ```dart\n int weaponsLength = monster.weapons.length;\n var secondWeaponName = monster.weapons[1].name;\n var secondWeaponDamage = monster.Weapons[1].damage;\n ```\n\n=== \"Go\"\n\n ```go\n weaponLength := monster.WeaponsLength()\n // We need a `sample.Weapon` to pass into `monster.Weapons()`\n // to capture the output of the function.k\n weapon := new(sample.Weapon)\n if monster.Weapons(weapon, 1) {\n secondWeaponName := weapon.Name()\n secondWeaponDamage := weapon.Damage()\n }\n ```\n\n=== \"Java\"\n\n ```java\n int weaponsLength = monster.weaponsLength();\n String secondWeaponName = monster.weapons(1).name();\n short secondWeaponDamage = monster.weapons(1).damage();\n ```\n\n=== \"JavaScript\"\n\n ```javascript\n var weaponsLength = monster.weaponsLength();\n var secondWeaponName = monster.weapons(1).name();\n var secondWeaponDamage = monster.weapons(1).damage();\n ```\n\n=== \"Kotlin\"\n\n ```kotlin\n val weaponsLength = monster.weaponsLength\n val secondWeaponName = monster.weapons(1)!!.name\n val secondWeaponDamage = monster.weapons(1)!!.damage\n ```\n\n=== \"Lobster\"\n\n ```lobster\n let weapons_length = monster.weapons_length\n let second_weapon_name = monster.weapons(1).name\n let second_weapon_damage = monster.weapons(1).damage\n ```\n\n=== \"Lua\"\n\n ```lua\n local weaponsLength = mon:WeaponsLength()\n local secondWeaponName = mon:Weapon(2):Name()\n local secondWeaponDamage = mon:Weapon(2):Damage()\n ```\n\n=== \"PHP\"\n\n ```php\n $weapons_len = $monster->getWeaponsLength();\n $second_weapon_name = $monster->getWeapons(1)->getName();\n $second_weapon_damage = $monster->getWeapons(1)->getDamage();\n ```\n\n=== \"Python\"\n\n ```py\n weapons_length = monster.WeaponsLength()\n second_weapon_name = monster.Weapons(1).Name()\n second_weapon_damage = monster.Weapons(1).Damage()\n ```\n\n=== \"Rust\"\n\n ```rust\n // Get and test the `weapons` FlatBuffers's `vector`.\n let weps = monster.weapons().unwrap();\n let weps_len = weps.len();\n\n let wep2 = weps.get(1);\n let second_weapon_name = wep2.name();\n let second_weapon_damage = wep2.damage();\n ```\n\n=== \"Swift\"\n\n ```swift\n // Get the count of weapon objects\n let wepsCount = monster.weaponsCount\n\n let weapon2 = monster.weapons(at: 1)\n let weaponName = weapon2.name\n let weaponDmg = weapon2.damage\n ```\n\n=== \"TypeScript\"\n\n ```ts\n let weaponsLength = monster.weaponsLength();\n let secondWeaponName = monster.weapons(1).name();\n let secondWeaponDamage = monster.weapons(1).damage();\n ```\n\n\n### Union Access\n\nLastly , we can access our `equipped` `union` field. Just like when we created\nthe union, we need to get both parts of the union: the type and the data.\n\nWe can access the type to dynamically cast the data as needed (since the union\nonly stores a FlatBuffer `table`).\n\n=== \"C++\"\n\n ```c++\n auto union_type = monster.equipped_type();\n\n if (union_type == Equipment_Weapon) {\n // Requires `static_cast` to type `const Weapon*`.\n auto weapon = static_cast(monster->equipped());\n\n auto weapon_name = weapon->name()->str(); // \"Axe\"\n auto weapon_damage = weapon->damage(); // 5\n }\n ```\n\n=== \"C\"\n\n ```c\n // Access union type field.\n if (ns(Monster_equipped_type(monster)) == ns(Equipment_Weapon)) {\n // Cast to appropriate type:\n // C allows for silent void pointer assignment, so we need no\n // explicit cast.\n ns(Weapon_table_t) weapon = ns(Monster_equipped(monster));\n const char *weapon_name = ns(Weapon_name(weapon)); // \"Axe\"\n uint16_t weapon_damage = ns(Weapon_damage(weapon)); // 5\n }\n ```\n\n=== \"C#\"\n\n ```c#\n var unionType = monster.EquippedType;\n\n if (unionType == Equipment.Weapon) {\n var weapon = monster.Equipped().Value;\n\n var weaponName = weapon.Name; // \"Axe\"\n var weaponDamage = weapon.Damage; // 5\n }\n ```\n\n=== \"Dart\"\n\n ```dart\n var unionType = monster.equippedType.value;\n\n if (unionType == myGame.EquipmentTypeId.Weapon.value) {\n myGame.Weapon weapon = mon.equipped as myGame.Weapon;\n\n var weaponName = weapon.name; // \"Axe\"\n var weaponDamage = weapon.damage; // 5\n }\n ```\n\n=== \"Go\"\n\n ```go\n // We need a `flatbuffers.Table` to capture the output of the\n // `monster.Equipped()` function.\n unionTable := new(flatbuffers.Table)\n\n if monster.Equipped(unionTable) {\n unionType := monster.EquippedType()\n\n if unionType == sample.EquipmentWeapon {\n // Create a `sample.Weapon` object that can be initialized with the\n // contents of the `flatbuffers.Table` (`unionTable`), which was\n // populated by `monster.Equipped()`.\n unionWeapon = new(sample.Weapon)\n unionWeapon.Init(unionTable.Bytes, unionTable.Pos)\n\n weaponName = unionWeapon.Name()\n weaponDamage = unionWeapon.Damage()\n }\n }\n ```\n\n=== \"Java\"\n\n ```java\n int unionType = monster.EquippedType();\n\n if (unionType == Equipment.Weapon) {\n // Requires an explicit cast to `Weapon`.\n Weapon weapon = (Weapon)monster.equipped(new Weapon());\n\n String weaponName = weapon.name(); // \"Axe\"\n short weaponDamage = weapon.damage(); // 5\n }\n ```\n\n=== \"JavaScript\"\n\n ```javascript\n var unionType = monster.equippedType();\n\n if (unionType == MyGame.Sample.Equipment.Weapon) {\n // 'Axe'\n var weaponName = monster.equipped(new MyGame.Sample.Weapon()).name();\n // 5\n var weaponDamage =\n monster.equipped(new MyGame.Sample.Weapon()).damage();\n }\n ```\n\n=== \"Kotlin\"\n\n ```kotlin\n val unionType = monster.EquippedType\n\n if (unionType == Equipment.Weapon) {\n // Requires an explicit cast to `Weapon`.\n val weapon = monster.equipped(Weapon()) as Weapon\n\n val weaponName = weapon.name // \"Axe\"\n val weaponDamage = weapon.damage // 5\n }\n ```\n\n=== \"Lobster\"\n\n ```lobster\n union_type = monster.equipped_type\n\n if union_type == MyGame_Sample_Equipment_Weapon:\n // `monster.equipped_as_Weapon` returns a FlatBuffer handle much like\n // normal table fields, but this is only valid to call if we already\n // know it is the correct type.\n let union_weapon = monster.equipped_as_Weapon\n\n let weapon_name = union_weapon.name // \"Axe\"\n let weapon_damage = union_weapon.damage // 5\n ```\n\n=== \"Lua\"\n\n ```lua\n local unionType = mon:EquippedType()\n\n if unionType == equipment.Weapon then\n local unionWeapon = weapon.New()\n unionWeapon:Init(mon:Equipped().bytes, mon:Equipped().pos)\n\n local weaponName = unionWeapon:Name() -- 'Axe'\n local weaponDamage = unionWeapon:Damage() -- 5\n end\n ```\n\n=== \"PHP\"\n\n ```php\n $union_type = $monster->getEquippedType();\n\n if ($union_type == \\MyGame\\Sample\\Equipment::Weapon) {\n // \"Axe\"\n $weapon_name =\n $monster->getEquipped(new \\MyGame\\Sample\\Weapon())->getName();\n // 5\n $weapon_damage =\n $monster->getEquipped(new \\MyGame\\Sample\\Weapon())->getDamage();\n }\n ```\n\n=== \"Python\"\n\n ```py\n union_type = monster.EquippedType()\n\n if union_type == MyGame.Sample.Equipment.Equipment().Weapon:\n # `monster.Equipped()` returns a `flatbuffers.Table`, which can be used\n # to initialize a `MyGame.Sample.Weapon.Weapon()`.\n union_weapon = MyGame.Sample.Weapon.Weapon()\n union_weapon.Init(monster.Equipped().Bytes, monster.Equipped().Pos)\n\n weapon_name = union_weapon.Name() // 'Axe'\n weapon_damage = union_weapon.Damage() // 5\n ```\n\n=== \"Rust\"\n\n ```rust\n // Get and test the `Equipment` union (`equipped` field).\n // `equipped_as_weapon` returns a FlatBuffer handle much like normal table\n // fields, but this will return `None` if the union is not actually of that\n // type.\n if monster.equipped_type() == Equipment::Weapon {\n let equipped = monster.equipped_as_weapon().unwrap();\n let weapon_name = equipped.name();\n let weapon_damage = equipped.damage();\n ```\n\n=== \"Swift\"\n\n ```swift\n // Get and check if the monster has an equipped item\n if monster.equippedType == .weapon {\n let _weapon = monster.equipped(type: Weapon.self)\n let name = _weapon.name // should return \"Axe\"\n let dmg = _weapon.damage // should return 5\n }\n ```\n\n=== \"TypeScript\"\n\n ```ts\n let unionType = monster.equippedType();\n\n if (unionType == MyGame.Sample.Equipment.Weapon) {\n // 'Axe'\n let weaponName = monster.equipped(new MyGame.Sample.Weapon()).name();\n // 5\n let weaponDamage = monster.equipped(new MyGame.Sample.Weapon()).damage();\n }\n ```\n" }, { "path": "docs/source/white_paper.md", "content": "FlatBuffers white paper {#flatbuffers_white_paper}\n=======================\n\nThis document tries to shed some light on to the \"why\" of FlatBuffers, a\nnew serialization library.\n\n## Motivation\n\nBack in the good old days, performance was all about instructions and\ncycles. Nowadays, processing units have run so far ahead of the memory\nsubsystem, that making an efficient application should start and finish\nwith thinking about memory. How much you use of it. How you lay it out\nand access it. How you allocate it. When you copy it.\n\nSerialization is a pervasive activity in a lot programs, and a common\nsource of memory inefficiency, with lots of temporary data structures\nneeded to parse and represent data, and inefficient allocation patterns\nand locality.\n\nIf it would be possible to do serialization with no temporary objects,\nno additional allocation, no copying, and good locality, this could be\nof great value. The reason serialization systems usually don't manage\nthis is because it goes counter to forwards/backwards compatibility, and\nplatform specifics like endianness and alignment.\n\nFlatBuffers is what you get if you try anyway.\n\nIn particular, FlatBuffers focus is on mobile hardware (where memory\nsize and memory bandwidth is even more constrained than on desktop\nhardware), and applications that have the highest performance needs:\ngames.\n\n## FlatBuffers\n\n*This is a summary of FlatBuffers functionality, with some rationale.\nA more detailed description can be found in the FlatBuffers\ndocumentation.*\n\n### Summary\n\nA FlatBuffer is a binary buffer containing nested objects (structs,\ntables, vectors,..) organized using offsets so that the data can be\ntraversed in-place just like any pointer-based data structure. Unlike\nmost in-memory data structures however, it uses strict rules of\nalignment and endianness (always little) to ensure these buffers are\ncross platform. Additionally, for objects that are tables, FlatBuffers\nprovides forwards/backwards compatibility and general optionality of\nfields, to support most forms of format evolution.\n\nYou define your object types in a schema, which can then be compiled to\nC++ or Java for low to zero overhead reading & writing.\nOptionally, JSON data can be dynamically parsed into buffers.\n\n### Tables\n\nTables are the cornerstone of FlatBuffers, since format evolution is\nessential for most applications of serialization. Typically, dealing\nwith format changes is something that can be done transparently during\nthe parsing process of most serialization solutions out there.\nBut a FlatBuffer isn't parsed before it is accessed.\n\nTables get around this by using an extra indirection to access fields,\nthrough a *vtable*. Each table comes with a vtable (which may be shared\nbetween multiple tables with the same layout), and contains information\nwhere fields for this particular kind of instance of vtable are stored.\nThe vtable may also indicate that the field is not present (because this\nFlatBuffer was written with an older version of the software, or simply\nbecause the information was not necessary for this instance, or deemed\ndeprecated), in which case a default value is returned.\n\nTables have a low overhead in memory (since vtables are small and\nshared) and in access cost (an extra indirection), but provide great\nflexibility. Tables may even cost less memory than the equivalent\nstruct, since fields do not need to be stored when they are equal to\ntheir default.\n\nFlatBuffers additionally offers \"naked\" structs, which do not offer\nforwards/backwards compatibility, but can be even smaller (useful for\nvery small objects that are unlikely to change, like e.g. a coordinate\npair or a RGBA color).\n\n### Schemas\n\nWhile schemas reduce some generality (you can't just read any data\nwithout having its schema), they have a lot of upsides:\n\n- Most information about the format can be factored into the generated\n code, reducing memory needed to store data, and time to access it.\n\n- The strong typing of the data definitions means less error\n checking/handling at runtime (less can go wrong).\n\n- A schema enables us to access a buffer without parsing.\n\nFlatBuffer schemas are fairly similar to those of the incumbent,\nProtocol Buffers, and generally should be readable to those familiar\nwith the C family of languages. We chose to improve upon the features\noffered by .proto files in the following ways:\n\n- Deprecation of fields instead of manual field id assignment.\n Extending an object in a .proto means hunting for a free slot among\n the numbers (preferring lower numbers since they have a more compact\n representation). Besides being inconvenient, it also makes removing\n fields problematic: you either have to keep them, not making it\n obvious that this field shouldn't be read/written anymore, and still\n generating accessors. Or you remove it, but now you risk that\n there's still old data around that uses that field by the time\n someone reuses that field id, with nasty consequences.\n\n- Differentiating between tables and structs (see above). Effectively\n all table fields are `optional`, and all struct fields are\n `required`.\n\n- Having a native vector type instead of `repeated`. This gives you a\n length without having to collect all items, and in the case of\n scalars provides for a more compact representation, and one that\n guarantees adjacency.\n\n- Having a native `union` type instead of using a series of `optional`\n fields, all of which must be checked individually.\n\n- Being able to define defaults for all scalars, instead of having to\n deal with their optionality at each access.\n\n- A parser that can deal with both schemas and data definitions (JSON\n compatible) uniformly.\n\n
\n" }, { "path": "eslint.config.mjs", "content": "import globals from \"globals\";\nimport pluginJs from \"@eslint/js\";\nimport tseslint from \"typescript-eslint\";\n\nexport default [\n {files: [\"**/*.{js,mjs,cjs,ts}\"]},\n {languageOptions: { globals: {...globals.browser, ...globals.node} }},\n pluginJs.configs.recommended,\n ...tseslint.configs.recommended,\n];\n" }, { "path": "examples/go-echo/README.md", "content": "# Go Echo Example\n\nA simple example demonstrating how to send flatbuffers over the network in Go.\n\n## Generate flatbuffer code\n\n```\nflatc -g --gen-object-api --go-module-name echo hero.fbs net.fbs\n```\n\n## Running example\n\n1. Run go mod tidy to get dependencies\n```\ngo mod tidy\n```\n\n2. Start a server\n```\ngo run server/server.go\n```\n\n3. Run the client in another terminal\n```\ngo run client/client.go\n```\n\n" }, { "path": "examples/go-echo/client/client.go", "content": "package main\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"io/ioutil\"\n\t\"net/http\"\n\n\t\"echo/hero\"\n\t\"echo/net\"\n\n\tflatbuffers \"github.com/google/flatbuffers/go\"\n)\n\nfunc RequestBody() *bytes.Reader {\n\tb := flatbuffers.NewBuilder(0)\n\tr := net.RequestT{Player: &hero.WarriorT{Name: \"Krull\", Hp: 100}}\n\tb.Finish(r.Pack(b))\n\treturn bytes.NewReader(b.FinishedBytes())\n}\n\nfunc ReadResponse(r *http.Response) {\n\tbody, err := ioutil.ReadAll(r.Body)\n\tif err != nil {\n\t\tfmt.Printf(\"Unable to read request body: %v\\n\", err)\n\t\treturn\n\t}\n\n\tres := net.GetRootAsResponse(body, 0)\n\tplayer := res.Player(nil)\n\n\tfmt.Printf(\"Got response (name: %v, hp: %v)\\n\", string(player.Name()), player.Hp())\n}\n\nfunc main() {\n\tbody := RequestBody()\n\treq, err := http.NewRequest(\"POST\", \"http://localhost:8080/echo\", body)\n\tif err != nil {\n\t\tfmt.Println(err)\n\t\treturn\n\t}\n\n\tclient := http.DefaultClient\n\tresp, err := client.Do(req)\n\tif err != nil {\n\t\tfmt.Println(err)\n\t\treturn\n\t}\n\n\tReadResponse(resp)\n}\n" }, { "path": "examples/go-echo/go.mod", "content": "module echo\n\ngo 1.19\n\nrequire github.com/google/flatbuffers v22.10.26+incompatible\n" }, { "path": "examples/go-echo/hero/Warrior.go", "content": "// Code generated by the FlatBuffers compiler. DO NOT EDIT.\n\npackage hero\n\nimport (\n\tflatbuffers \"github.com/google/flatbuffers/go\"\n)\n\ntype WarriorT struct {\n\tName string `json:\"name\"`\n\tHp uint32 `json:\"hp\"`\n}\n\nfunc (t *WarriorT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {\n\tif t == nil {\n\t\treturn 0\n\t}\n\tnameOffset := flatbuffers.UOffsetT(0)\n\tif t.Name != \"\" {\n\t\tnameOffset = builder.CreateString(t.Name)\n\t}\n\tWarriorStart(builder)\n\tWarriorAddName(builder, nameOffset)\n\tWarriorAddHp(builder, t.Hp)\n\treturn WarriorEnd(builder)\n}\n\nfunc (rcv *Warrior) UnPackTo(t *WarriorT) {\n\tt.Name = string(rcv.Name())\n\tt.Hp = rcv.Hp()\n}\n\nfunc (rcv *Warrior) UnPack() *WarriorT {\n\tif rcv == nil {\n\t\treturn nil\n\t}\n\tt := &WarriorT{}\n\trcv.UnPackTo(t)\n\treturn t\n}\n\ntype Warrior struct {\n\t_tab flatbuffers.Table\n}\n\nfunc GetRootAsWarrior(buf []byte, offset flatbuffers.UOffsetT) *Warrior {\n\tn := flatbuffers.GetUOffsetT(buf[offset:])\n\tx := &Warrior{}\n\tx.Init(buf, n+offset)\n\treturn x\n}\n\nfunc GetSizePrefixedRootAsWarrior(buf []byte, offset flatbuffers.UOffsetT) *Warrior {\n\tn := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])\n\tx := &Warrior{}\n\tx.Init(buf, n+offset+flatbuffers.SizeUint32)\n\treturn x\n}\n\nfunc (rcv *Warrior) Init(buf []byte, i flatbuffers.UOffsetT) {\n\trcv._tab.Bytes = buf\n\trcv._tab.Pos = i\n}\n\nfunc (rcv *Warrior) Table() flatbuffers.Table {\n\treturn rcv._tab\n}\n\nfunc (rcv *Warrior) Name() []byte {\n\to := flatbuffers.UOffsetT(rcv._tab.Offset(4))\n\tif o != 0 {\n\t\treturn rcv._tab.ByteVector(o + rcv._tab.Pos)\n\t}\n\treturn nil\n}\n\nfunc (rcv *Warrior) Hp() uint32 {\n\to := flatbuffers.UOffsetT(rcv._tab.Offset(6))\n\tif o != 0 {\n\t\treturn rcv._tab.GetUint32(o + rcv._tab.Pos)\n\t}\n\treturn 0\n}\n\nfunc (rcv *Warrior) MutateHp(n uint32) bool {\n\treturn rcv._tab.MutateUint32Slot(6, n)\n}\n\nfunc WarriorStart(builder *flatbuffers.Builder) {\n\tbuilder.StartObject(2)\n}\nfunc WarriorAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {\n\tbuilder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0)\n}\nfunc WarriorAddHp(builder *flatbuffers.Builder, hp uint32) {\n\tbuilder.PrependUint32Slot(1, hp, 0)\n}\nfunc WarriorEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {\n\treturn builder.EndObject()\n}\n" }, { "path": "examples/go-echo/hero.fbs", "content": "namespace hero;\n\ntable Warrior {\n\tname: string;\n\thp: uint32;\n}\n" }, { "path": "examples/go-echo/net/Request.go", "content": "// Code generated by the FlatBuffers compiler. DO NOT EDIT.\n\npackage net\n\nimport (\n\tflatbuffers \"github.com/google/flatbuffers/go\"\n\n\thero \"echo/hero\"\n)\n\ntype RequestT struct {\n\tPlayer *hero.WarriorT `json:\"player\"`\n}\n\nfunc (t *RequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {\n\tif t == nil {\n\t\treturn 0\n\t}\n\tplayerOffset := t.Player.Pack(builder)\n\tRequestStart(builder)\n\tRequestAddPlayer(builder, playerOffset)\n\treturn RequestEnd(builder)\n}\n\nfunc (rcv *Request) UnPackTo(t *RequestT) {\n\tt.Player = rcv.Player(nil).UnPack()\n}\n\nfunc (rcv *Request) UnPack() *RequestT {\n\tif rcv == nil {\n\t\treturn nil\n\t}\n\tt := &RequestT{}\n\trcv.UnPackTo(t)\n\treturn t\n}\n\ntype Request struct {\n\t_tab flatbuffers.Table\n}\n\nfunc GetRootAsRequest(buf []byte, offset flatbuffers.UOffsetT) *Request {\n\tn := flatbuffers.GetUOffsetT(buf[offset:])\n\tx := &Request{}\n\tx.Init(buf, n+offset)\n\treturn x\n}\n\nfunc GetSizePrefixedRootAsRequest(buf []byte, offset flatbuffers.UOffsetT) *Request {\n\tn := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])\n\tx := &Request{}\n\tx.Init(buf, n+offset+flatbuffers.SizeUint32)\n\treturn x\n}\n\nfunc (rcv *Request) Init(buf []byte, i flatbuffers.UOffsetT) {\n\trcv._tab.Bytes = buf\n\trcv._tab.Pos = i\n}\n\nfunc (rcv *Request) Table() flatbuffers.Table {\n\treturn rcv._tab\n}\n\nfunc (rcv *Request) Player(obj *hero.Warrior) *hero.Warrior {\n\to := flatbuffers.UOffsetT(rcv._tab.Offset(4))\n\tif o != 0 {\n\t\tx := rcv._tab.Indirect(o + rcv._tab.Pos)\n\t\tif obj == nil {\n\t\t\tobj = new(hero.Warrior)\n\t\t}\n\t\tobj.Init(rcv._tab.Bytes, x)\n\t\treturn obj\n\t}\n\treturn nil\n}\n\nfunc RequestStart(builder *flatbuffers.Builder) {\n\tbuilder.StartObject(1)\n}\nfunc RequestAddPlayer(builder *flatbuffers.Builder, player flatbuffers.UOffsetT) {\n\tbuilder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(player), 0)\n}\nfunc RequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {\n\treturn builder.EndObject()\n}\n" }, { "path": "examples/go-echo/net/Response.go", "content": "// Code generated by the FlatBuffers compiler. DO NOT EDIT.\n\npackage net\n\nimport (\n\tflatbuffers \"github.com/google/flatbuffers/go\"\n\n\thero \"echo/hero\"\n)\n\ntype ResponseT struct {\n\tPlayer *hero.WarriorT `json:\"player\"`\n}\n\nfunc (t *ResponseT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {\n\tif t == nil {\n\t\treturn 0\n\t}\n\tplayerOffset := t.Player.Pack(builder)\n\tResponseStart(builder)\n\tResponseAddPlayer(builder, playerOffset)\n\treturn ResponseEnd(builder)\n}\n\nfunc (rcv *Response) UnPackTo(t *ResponseT) {\n\tt.Player = rcv.Player(nil).UnPack()\n}\n\nfunc (rcv *Response) UnPack() *ResponseT {\n\tif rcv == nil {\n\t\treturn nil\n\t}\n\tt := &ResponseT{}\n\trcv.UnPackTo(t)\n\treturn t\n}\n\ntype Response struct {\n\t_tab flatbuffers.Table\n}\n\nfunc GetRootAsResponse(buf []byte, offset flatbuffers.UOffsetT) *Response {\n\tn := flatbuffers.GetUOffsetT(buf[offset:])\n\tx := &Response{}\n\tx.Init(buf, n+offset)\n\treturn x\n}\n\nfunc GetSizePrefixedRootAsResponse(buf []byte, offset flatbuffers.UOffsetT) *Response {\n\tn := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])\n\tx := &Response{}\n\tx.Init(buf, n+offset+flatbuffers.SizeUint32)\n\treturn x\n}\n\nfunc (rcv *Response) Init(buf []byte, i flatbuffers.UOffsetT) {\n\trcv._tab.Bytes = buf\n\trcv._tab.Pos = i\n}\n\nfunc (rcv *Response) Table() flatbuffers.Table {\n\treturn rcv._tab\n}\n\nfunc (rcv *Response) Player(obj *hero.Warrior) *hero.Warrior {\n\to := flatbuffers.UOffsetT(rcv._tab.Offset(4))\n\tif o != 0 {\n\t\tx := rcv._tab.Indirect(o + rcv._tab.Pos)\n\t\tif obj == nil {\n\t\t\tobj = new(hero.Warrior)\n\t\t}\n\t\tobj.Init(rcv._tab.Bytes, x)\n\t\treturn obj\n\t}\n\treturn nil\n}\n\nfunc ResponseStart(builder *flatbuffers.Builder) {\n\tbuilder.StartObject(1)\n}\nfunc ResponseAddPlayer(builder *flatbuffers.Builder, player flatbuffers.UOffsetT) {\n\tbuilder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(player), 0)\n}\nfunc ResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {\n\treturn builder.EndObject()\n}\n" }, { "path": "examples/go-echo/net.fbs", "content": "include \"hero.fbs\";\n\nnamespace net;\n\ntable Request {\n\tplayer: hero.Warrior;\n}\n\ntable Response {\n\tplayer: hero.Warrior;\n}\n" }, { "path": "examples/go-echo/server/server.go", "content": "package main\n\nimport (\n\t\"echo/net\"\n\t\"fmt\"\n\t\"io/ioutil\"\n\t\"net/http\"\n)\n\nfunc echo(w http.ResponseWriter, r *http.Request) {\n\tbody, err := ioutil.ReadAll(r.Body)\n\tif err != nil {\n\t\tfmt.Printf(\"Unable to read request body: %v\\n\", err)\n\t\treturn\n\t}\n\n\treq := net.GetRootAsRequest(body, 0)\n\tplayer := req.Player(nil)\n\n\tfmt.Printf(\"Got request (name: %v, hp: %v)\\n\", string(player.Name()), player.Hp())\n\tw.Write(body)\n}\n\nfunc main() {\n\thttp.HandleFunc(\"/echo\", echo)\n\n\tfmt.Println(\"Listening on port :8080\")\n\thttp.ListenAndServe(\":8080\", nil)\n}\n" }, { "path": "extensions.bzl", "content": "\"\"\"Bzlmod extensions\"\"\"\n\nload(\"@bazel_tools//tools/build_defs/repo:http.bzl\", \"http_file\")\n\ndef _non_module_dependencies_impl(_ctx):\n \"\"\"Non module dependencies\"\"\"\n http_file(\n name = \"bazel_linux_x86_64\",\n downloaded_file_path = \"bazel\",\n executable = True,\n sha256 = \"e78fc3394deae5408d6f49a15c7b1e615901969ecf6e50d55ef899996b0b8458\",\n urls = [\n \"https://github.com/bazelbuild/bazel/releases/download/6.3.2/bazel-6.3.2-linux-x86_64\",\n ],\n )\n\nnon_module_dependencies = module_extension(\n implementation = _non_module_dependencies_impl,\n)\n" }, { "path": "go/BUILD.bazel", "content": "load(\"@io_bazel_rules_go//go:def.bzl\", \"go_library\")\n\nalias(\n name = \"go_default_library\",\n actual = \":go\",\n visibility = [\"//visibility:public\"],\n)\n\ngo_library(\n name = \"go\",\n srcs = [\n \"builder.go\",\n \"doc.go\",\n \"encode.go\",\n \"grpc.go\",\n \"lib.go\",\n \"sizes.go\",\n \"struct.go\",\n \"table.go\",\n ],\n importpath = \"github.com/google/flatbuffers/go\",\n visibility = [\"//visibility:public\"],\n)\n" }, { "path": "go/builder.go", "content": "package flatbuffers\n\nimport \"sort\"\n\n// Builder is a state machine for creating FlatBuffer objects.\n// Use a Builder to construct object(s) starting from leaf nodes.\n//\n// A Builder constructs byte buffers in a last-first manner for simplicity and\n// performance.\ntype Builder struct {\n\t// `Bytes` gives raw access to the buffer. Most users will want to use\n\t// FinishedBytes() instead.\n\tBytes []byte\n\n\tminalign int\n\tvtable []UOffsetT\n\tobjectEnd UOffsetT\n\tvtables []UOffsetT\n\thead UOffsetT\n\tnested bool\n\tfinished bool\n\n\tsharedStrings map[string]UOffsetT\n}\n\nconst fileIdentifierLength = 4\nconst sizePrefixLength = 4\n\n// NewBuilder initializes a Builder of size `initial_size`.\n// The internal buffer is grown as needed.\nfunc NewBuilder(initialSize int) *Builder {\n\tif initialSize <= 0 {\n\t\tinitialSize = 0\n\t}\n\n\tb := &Builder{}\n\tb.Bytes = make([]byte, initialSize)\n\tb.head = UOffsetT(initialSize)\n\tb.minalign = 1\n\tb.vtables = make([]UOffsetT, 0, 16) // sensible default capacity\n\treturn b\n}\n\n// Reset truncates the underlying Builder buffer, facilitating alloc-free\n// reuse of a Builder. It also resets bookkeeping data.\nfunc (b *Builder) Reset() {\n\tif b.Bytes != nil {\n\t\tb.Bytes = b.Bytes[:cap(b.Bytes)]\n\t}\n\n\tif b.vtables != nil {\n\t\tb.vtables = b.vtables[:0]\n\t}\n\n\tif b.vtable != nil {\n\t\tb.vtable = b.vtable[:0]\n\t}\n\n\tif b.sharedStrings != nil {\n\t\tfor key := range b.sharedStrings {\n\t\t\tdelete(b.sharedStrings, key)\n\t\t}\n\t}\n\n\tb.head = UOffsetT(len(b.Bytes))\n\tb.minalign = 1\n\tb.nested = false\n\tb.finished = false\n}\n\n// FinishedBytes returns a pointer to the written data in the byte buffer.\n// Panics if the builder is not in a finished state (which is caused by calling\n// `Finish()`).\nfunc (b *Builder) FinishedBytes() []byte {\n\tb.assertFinished()\n\treturn b.Bytes[b.Head():]\n}\n\n// StartObject initializes bookkeeping for writing a new object.\nfunc (b *Builder) StartObject(numfields int) {\n\tb.assertNotNested()\n\tb.nested = true\n\n\t// use 32-bit offsets so that arithmetic doesn't overflow.\n\tif cap(b.vtable) < numfields || b.vtable == nil {\n\t\tb.vtable = make([]UOffsetT, numfields)\n\t} else {\n\t\tb.vtable = b.vtable[:numfields]\n\t\tfor i := 0; i < len(b.vtable); i++ {\n\t\t\tb.vtable[i] = 0\n\t\t}\n\t}\n\n\tb.objectEnd = b.Offset()\n}\n\n// WriteVtable serializes the vtable for the current object, if applicable.\n//\n// Before writing out the vtable, this checks pre-existing vtables for equality\n// to this one. If an equal vtable is found, point the object to the existing\n// vtable and return.\n//\n// Because vtable values are sensitive to alignment of object data, not all\n// logically-equal vtables will be deduplicated.\n//\n// A vtable has the following format:\n//\n//\t \n//\t \n//\t * N, where N is the number of fields in\n//\t\t the schema for this type. Includes deprecated fields.\n//\n// Thus, a vtable is made of 2 + N elements, each SizeVOffsetT bytes wide.\n//\n// An object has the following format:\n//\n//\t\n//\t+\nfunc (b *Builder) WriteVtable() (n UOffsetT) {\n\t// Prepend a zero scalar to the object. Later in this function we'll\n\t// write an offset here that points to the object's vtable:\n\tb.PrependSOffsetT(0)\n\n\tobjectOffset := b.Offset()\n\texistingVtable := UOffsetT(0)\n\n\t// Trim vtable of trailing zeroes.\n\ti := len(b.vtable) - 1\n\tfor ; i >= 0 && b.vtable[i] == 0; i-- {\n\t}\n\tb.vtable = b.vtable[:i+1]\n\n\t// Search backwards through existing vtables, because similar vtables\n\t// are likely to have been recently appended. See\n\t// BenchmarkVtableDeduplication for a case in which this heuristic\n\t// saves about 30% of the time used in writing objects with duplicate\n\t// tables.\n\tfor i := len(b.vtables) - 1; i >= 0; i-- {\n\t\t// Find the other vtable, which is associated with `i`:\n\t\tvt2Offset := b.vtables[i]\n\t\tvt2Start := len(b.Bytes) - int(vt2Offset)\n\t\tvt2Len := GetVOffsetT(b.Bytes[vt2Start:])\n\n\t\tmetadata := VtableMetadataFields * SizeVOffsetT\n\t\tvt2End := vt2Start + int(vt2Len)\n\t\tvt2 := b.Bytes[vt2Start+metadata : vt2End]\n\n\t\t// Compare the other vtable to the one under consideration.\n\t\t// If they are equal, store the offset and break:\n\t\tif vtableEqual(b.vtable, objectOffset, vt2) {\n\t\t\texistingVtable = vt2Offset\n\t\t\tbreak\n\t\t}\n\t}\n\n\tif existingVtable == 0 {\n\t\t// Did not find a vtable, so write this one to the buffer.\n\n\t\t// Write out the current vtable in reverse , because\n\t\t// serialization occurs in last-first order:\n\t\tfor i := len(b.vtable) - 1; i >= 0; i-- {\n\t\t\tvar off UOffsetT\n\t\t\tif b.vtable[i] != 0 {\n\t\t\t\t// Forward reference to field;\n\t\t\t\t// use 32bit number to assert no overflow:\n\t\t\t\toff = objectOffset - b.vtable[i]\n\t\t\t}\n\n\t\t\tb.PrependVOffsetT(VOffsetT(off))\n\t\t}\n\n\t\t// The two metadata fields are written last.\n\n\t\t// First, store the object bytesize:\n\t\tobjectSize := objectOffset - b.objectEnd\n\t\tb.PrependVOffsetT(VOffsetT(objectSize))\n\n\t\t// Second, store the vtable bytesize:\n\t\tvBytes := (len(b.vtable) + VtableMetadataFields) * SizeVOffsetT\n\t\tb.PrependVOffsetT(VOffsetT(vBytes))\n\n\t\t// Next, write the offset to the new vtable in the\n\t\t// already-allocated SOffsetT at the beginning of this object:\n\t\tobjectStart := SOffsetT(len(b.Bytes)) - SOffsetT(objectOffset)\n\t\tWriteSOffsetT(b.Bytes[objectStart:],\n\t\t\tSOffsetT(b.Offset())-SOffsetT(objectOffset))\n\n\t\t// Finally, store this vtable in memory for future\n\t\t// deduplication:\n\t\tb.vtables = append(b.vtables, b.Offset())\n\t} else {\n\t\t// Found a duplicate vtable.\n\n\t\tobjectStart := SOffsetT(len(b.Bytes)) - SOffsetT(objectOffset)\n\t\tb.head = UOffsetT(objectStart)\n\n\t\t// Write the offset to the found vtable in the\n\t\t// already-allocated SOffsetT at the beginning of this object:\n\t\tWriteSOffsetT(b.Bytes[b.head:],\n\t\t\tSOffsetT(existingVtable)-SOffsetT(objectOffset))\n\t}\n\n\tb.vtable = b.vtable[:0]\n\treturn objectOffset\n}\n\n// EndObject writes data necessary to finish object construction.\nfunc (b *Builder) EndObject() UOffsetT {\n\tb.assertNested()\n\tn := b.WriteVtable()\n\tb.nested = false\n\treturn n\n}\n\n// Doubles the size of the byteslice, and copies the old data towards the\n// end of the new byteslice (since we build the buffer backwards).\nfunc (b *Builder) growByteBuffer() {\n\tif (int64(len(b.Bytes)) & int64(0xC0000000)) != 0 {\n\t\tpanic(\"cannot grow buffer beyond 2 gigabytes\")\n\t}\n\tnewLen := len(b.Bytes) * 2\n\tif newLen == 0 {\n\t\tnewLen = 1\n\t}\n\n\tif cap(b.Bytes) >= newLen {\n\t\tb.Bytes = b.Bytes[:newLen]\n\t} else {\n\t\textension := make([]byte, newLen-len(b.Bytes))\n\t\tb.Bytes = append(b.Bytes, extension...)\n\t}\n\n\tmiddle := newLen / 2\n\tcopy(b.Bytes[middle:], b.Bytes[:middle])\n}\n\n// Head gives the start of useful data in the underlying byte buffer.\n// Note: unlike other functions, this value is interpreted as from the left.\nfunc (b *Builder) Head() UOffsetT {\n\treturn b.head\n}\n\n// Offset relative to the end of the buffer.\nfunc (b *Builder) Offset() UOffsetT {\n\treturn UOffsetT(len(b.Bytes)) - b.head\n}\n\n// Pad places zeros at the current offset.\nfunc (b *Builder) Pad(n int) {\n\tfor i := 0; i < n; i++ {\n\t\tb.PlaceByte(0)\n\t}\n}\n\n// Prep prepares to write an element of `size` after `additional_bytes`\n// have been written, e.g. if you write a string, you need to align such\n// the int length field is aligned to SizeInt32, and the string data follows it\n// directly.\n// If all you need to do is align, `additionalBytes` will be 0.\nfunc (b *Builder) Prep(size, additionalBytes int) {\n\t// Track the biggest thing we've ever aligned to.\n\tif size > b.minalign {\n\t\tb.minalign = size\n\t}\n\t// Find the amount of alignment needed such that `size` is properly\n\t// aligned after `additionalBytes`:\n\talignSize := (^(len(b.Bytes) - int(b.Head()) + additionalBytes)) + 1\n\talignSize &= (size - 1)\n\n\t// Reallocate the buffer if needed:\n\tfor int(b.head) <= alignSize+size+additionalBytes {\n\t\toldBufSize := len(b.Bytes)\n\t\tb.growByteBuffer()\n\t\tb.head += UOffsetT(len(b.Bytes) - oldBufSize)\n\t}\n\tb.Pad(alignSize)\n}\n\n// PrependSOffsetT prepends an SOffsetT, relative to where it will be written.\nfunc (b *Builder) PrependSOffsetT(off SOffsetT) {\n\tb.Prep(SizeSOffsetT, 0) // Ensure alignment is already done.\n\tif !(UOffsetT(off) <= b.Offset()) {\n\t\tpanic(\"unreachable: off <= b.Offset()\")\n\t}\n\toff2 := SOffsetT(b.Offset()) - off + SOffsetT(SizeSOffsetT)\n\tb.PlaceSOffsetT(off2)\n}\n\n// PrependUOffsetT prepends an UOffsetT, relative to where it will be written.\nfunc (b *Builder) PrependUOffsetT(off UOffsetT) {\n\tb.Prep(SizeUOffsetT, 0) // Ensure alignment is already done.\n\tif !(off <= b.Offset()) {\n\t\tpanic(\"unreachable: off <= b.Offset()\")\n\t}\n\toff2 := b.Offset() - off + UOffsetT(SizeUOffsetT)\n\tb.PlaceUOffsetT(off2)\n}\n\n// StartVector initializes bookkeeping for writing a new vector.\n//\n// A vector has the following format:\n//\n//\t\n//\t+, where T is the type of elements of this vector.\nfunc (b *Builder) StartVector(elemSize, numElems, alignment int) UOffsetT {\n\tb.assertNotNested()\n\tb.nested = true\n\tb.Prep(SizeUint32, elemSize*numElems)\n\tb.Prep(alignment, elemSize*numElems) // Just in case alignment > int.\n\treturn b.Offset()\n}\n\n// EndVector writes data necessary to finish vector construction.\nfunc (b *Builder) EndVector(vectorNumElems int) UOffsetT {\n\tb.assertNested()\n\n\t// we already made space for this, so write without PrependUint32\n\tb.PlaceUOffsetT(UOffsetT(vectorNumElems))\n\n\tb.nested = false\n\treturn b.Offset()\n}\n\n// CreateVectorOfTables serializes slice of table offsets into a vector.\nfunc (b *Builder) CreateVectorOfTables(offsets []UOffsetT) UOffsetT {\n\tb.assertNotNested()\n\tb.StartVector(4, len(offsets), 4)\n\tfor i := len(offsets) - 1; i >= 0; i-- {\n\t\tb.PrependUOffsetT(offsets[i])\n\t}\n\treturn b.EndVector(len(offsets))\n}\n\ntype KeyCompare func(o1, o2 UOffsetT, buf []byte) bool\n\nfunc (b *Builder) CreateVectorOfSortedTables(offsets []UOffsetT, keyCompare KeyCompare) UOffsetT {\n\tsort.Slice(offsets, func(i, j int) bool {\n\t\treturn keyCompare(offsets[i], offsets[j], b.Bytes)\n\t})\n\treturn b.CreateVectorOfTables(offsets)\n}\n\n// CreateSharedString Checks if the string is already written\n// to the buffer before calling CreateString\nfunc (b *Builder) CreateSharedString(s string) UOffsetT {\n\tif b.sharedStrings == nil {\n\t\tb.sharedStrings = make(map[string]UOffsetT)\n\t}\n\tif v, ok := b.sharedStrings[s]; ok {\n\t\treturn v\n\t}\n\toff := b.CreateString(s)\n\tb.sharedStrings[s] = off\n\treturn off\n}\n\n// CreateString writes a null-terminated string as a vector.\nfunc (b *Builder) CreateString(s string) UOffsetT {\n\tb.assertNotNested()\n\tb.nested = true\n\n\tb.Prep(int(SizeUOffsetT), (len(s)+1)*SizeByte)\n\tb.PlaceByte(0)\n\n\tl := UOffsetT(len(s))\n\n\tb.head -= l\n\tcopy(b.Bytes[b.head:b.head+l], s)\n\n\treturn b.EndVector(len(s))\n}\n\n// CreateByteString writes a byte slice as a string (null-terminated).\nfunc (b *Builder) CreateByteString(s []byte) UOffsetT {\n\tb.assertNotNested()\n\tb.nested = true\n\n\tb.Prep(int(SizeUOffsetT), (len(s)+1)*SizeByte)\n\tb.PlaceByte(0)\n\n\tl := UOffsetT(len(s))\n\n\tb.head -= l\n\tcopy(b.Bytes[b.head:b.head+l], s)\n\n\treturn b.EndVector(len(s))\n}\n\n// CreateByteVector writes a ubyte vector\nfunc (b *Builder) CreateByteVector(v []byte) UOffsetT {\n\tb.assertNotNested()\n\tb.nested = true\n\n\tb.Prep(int(SizeUOffsetT), len(v)*SizeByte)\n\n\tl := UOffsetT(len(v))\n\n\tb.head -= l\n\tcopy(b.Bytes[b.head:b.head+l], v)\n\n\treturn b.EndVector(len(v))\n}\n\nfunc (b *Builder) assertNested() {\n\t// If you get this assert, you're in an object while trying to write\n\t// data that belongs outside of an object.\n\t// To fix this, write non-inline data (like vectors) before creating\n\t// objects.\n\tif !b.nested {\n\t\tpanic(\"Incorrect creation order: must be inside object.\")\n\t}\n}\n\nfunc (b *Builder) assertNotNested() {\n\t// If you hit this, you're trying to construct a Table/Vector/String\n\t// during the construction of its parent table (between the MyTableBuilder\n\t// and builder.Finish()).\n\t// Move the creation of these sub-objects to above the MyTableBuilder to\n\t// not get this assert.\n\t// Ignoring this assert may appear to work in simple cases, but the reason\n\t// it is here is that storing objects in-line may cause vtable offsets\n\t// to not fit anymore. It also leads to vtable duplication.\n\tif b.nested {\n\t\tpanic(\"Incorrect creation order: object must not be nested.\")\n\t}\n}\n\nfunc (b *Builder) assertFinished() {\n\t// If you get this assert, you're attempting to get access a buffer\n\t// which hasn't been finished yet. Be sure to call builder.Finish()\n\t// with your root table.\n\t// If you really need to access an unfinished buffer, use the Bytes\n\t// buffer directly.\n\tif !b.finished {\n\t\tpanic(\"Incorrect use of FinishedBytes(): must call 'Finish' first.\")\n\t}\n}\n\n// PrependBoolSlot prepends a bool onto the object at vtable slot `o`.\n// If value `x` equals default `d`, then the slot will be set to zero and no\n// other data will be written.\nfunc (b *Builder) PrependBoolSlot(o int, x, d bool) {\n\tval := byte(0)\n\tif x {\n\t\tval = 1\n\t}\n\tdef := byte(0)\n\tif d {\n\t\tdef = 1\n\t}\n\tb.PrependByteSlot(o, val, def)\n}\n\n// PrependByteSlot prepends a byte onto the object at vtable slot `o`.\n// If value `x` equals default `d`, then the slot will be set to zero and no\n// other data will be written.\nfunc (b *Builder) PrependByteSlot(o int, x, d byte) {\n\tif x != d {\n\t\tb.PrependByte(x)\n\t\tb.Slot(o)\n\t}\n}\n\n// PrependUint8Slot prepends a uint8 onto the object at vtable slot `o`.\n// If value `x` equals default `d`, then the slot will be set to zero and no\n// other data will be written.\nfunc (b *Builder) PrependUint8Slot(o int, x, d uint8) {\n\tif x != d {\n\t\tb.PrependUint8(x)\n\t\tb.Slot(o)\n\t}\n}\n\n// PrependUint16Slot prepends a uint16 onto the object at vtable slot `o`.\n// If value `x` equals default `d`, then the slot will be set to zero and no\n// other data will be written.\nfunc (b *Builder) PrependUint16Slot(o int, x, d uint16) {\n\tif x != d {\n\t\tb.PrependUint16(x)\n\t\tb.Slot(o)\n\t}\n}\n\n// PrependUint32Slot prepends a uint32 onto the object at vtable slot `o`.\n// If value `x` equals default `d`, then the slot will be set to zero and no\n// other data will be written.\nfunc (b *Builder) PrependUint32Slot(o int, x, d uint32) {\n\tif x != d {\n\t\tb.PrependUint32(x)\n\t\tb.Slot(o)\n\t}\n}\n\n// PrependUint64Slot prepends a uint64 onto the object at vtable slot `o`.\n// If value `x` equals default `d`, then the slot will be set to zero and no\n// other data will be written.\nfunc (b *Builder) PrependUint64Slot(o int, x, d uint64) {\n\tif x != d {\n\t\tb.PrependUint64(x)\n\t\tb.Slot(o)\n\t}\n}\n\n// PrependInt8Slot prepends a int8 onto the object at vtable slot `o`.\n// If value `x` equals default `d`, then the slot will be set to zero and no\n// other data will be written.\nfunc (b *Builder) PrependInt8Slot(o int, x, d int8) {\n\tif x != d {\n\t\tb.PrependInt8(x)\n\t\tb.Slot(o)\n\t}\n}\n\n// PrependInt16Slot prepends a int16 onto the object at vtable slot `o`.\n// If value `x` equals default `d`, then the slot will be set to zero and no\n// other data will be written.\nfunc (b *Builder) PrependInt16Slot(o int, x, d int16) {\n\tif x != d {\n\t\tb.PrependInt16(x)\n\t\tb.Slot(o)\n\t}\n}\n\n// PrependInt32Slot prepends a int32 onto the object at vtable slot `o`.\n// If value `x` equals default `d`, then the slot will be set to zero and no\n// other data will be written.\nfunc (b *Builder) PrependInt32Slot(o int, x, d int32) {\n\tif x != d {\n\t\tb.PrependInt32(x)\n\t\tb.Slot(o)\n\t}\n}\n\n// PrependInt64Slot prepends a int64 onto the object at vtable slot `o`.\n// If value `x` equals default `d`, then the slot will be set to zero and no\n// other data will be written.\nfunc (b *Builder) PrependInt64Slot(o int, x, d int64) {\n\tif x != d {\n\t\tb.PrependInt64(x)\n\t\tb.Slot(o)\n\t}\n}\n\n// PrependFloat32Slot prepends a float32 onto the object at vtable slot `o`.\n// If value `x` equals default `d`, then the slot will be set to zero and no\n// other data will be written.\nfunc (b *Builder) PrependFloat32Slot(o int, x, d float32) {\n\tif x != d {\n\t\tb.PrependFloat32(x)\n\t\tb.Slot(o)\n\t}\n}\n\n// PrependFloat64Slot prepends a float64 onto the object at vtable slot `o`.\n// If value `x` equals default `d`, then the slot will be set to zero and no\n// other data will be written.\nfunc (b *Builder) PrependFloat64Slot(o int, x, d float64) {\n\tif x != d {\n\t\tb.PrependFloat64(x)\n\t\tb.Slot(o)\n\t}\n}\n\n// PrependUOffsetTSlot prepends an UOffsetT onto the object at vtable slot `o`.\n// If value `x` equals default `d`, then the slot will be set to zero and no\n// other data will be written.\nfunc (b *Builder) PrependUOffsetTSlot(o int, x, d UOffsetT) {\n\tif x != d {\n\t\tb.PrependUOffsetT(x)\n\t\tb.Slot(o)\n\t}\n}\n\n// PrependStructSlot prepends a struct onto the object at vtable slot `o`.\n// Structs are stored inline, so nothing additional is being added.\n// In generated code, `d` is always 0.\nfunc (b *Builder) PrependStructSlot(voffset int, x, d UOffsetT) {\n\tif x != d {\n\t\tb.assertNested()\n\t\tif x != b.Offset() {\n\t\t\tpanic(\"inline data write outside of object\")\n\t\t}\n\t\tb.Slot(voffset)\n\t}\n}\n\n// Slot sets the vtable key `voffset` to the current location in the buffer.\nfunc (b *Builder) Slot(slotnum int) {\n\tb.vtable[slotnum] = UOffsetT(b.Offset())\n}\n\n// FinishWithFileIdentifier finalizes a buffer, pointing to the given `rootTable`.\n// as well as applys a file identifier\nfunc (b *Builder) FinishWithFileIdentifier(rootTable UOffsetT, fid []byte) {\n\tif fid == nil || len(fid) != fileIdentifierLength {\n\t\tpanic(\"incorrect file identifier length\")\n\t}\n\t// In order to add a file identifier to the flatbuffer message, we need\n\t// to prepare an alignment and file identifier length\n\tb.Prep(b.minalign, SizeInt32+fileIdentifierLength)\n\tfor i := fileIdentifierLength - 1; i >= 0; i-- {\n\t\t// place the file identifier\n\t\tb.PlaceByte(fid[i])\n\t}\n\t// finish\n\tb.Finish(rootTable)\n}\n\n// FinishSizePrefixed finalizes a buffer, pointing to the given `rootTable`.\n// The buffer is prefixed with the size of the buffer, excluding the size\n// of the prefix itself.\nfunc (b *Builder) FinishSizePrefixed(rootTable UOffsetT) {\n\tb.finish(rootTable, true)\n}\n\n// FinishSizePrefixedWithFileIdentifier finalizes a buffer, pointing to the given `rootTable`\n// and applies a file identifier. The buffer is prefixed with the size of the buffer,\n// excluding the size of the prefix itself.\nfunc (b *Builder) FinishSizePrefixedWithFileIdentifier(rootTable UOffsetT, fid []byte) {\n\tif fid == nil || len(fid) != fileIdentifierLength {\n\t\tpanic(\"incorrect file identifier length\")\n\t}\n\t// In order to add a file identifier and size prefix to the flatbuffer message,\n\t// we need to prepare an alignment, a size prefix length, and file identifier length\n\tb.Prep(b.minalign, SizeInt32+fileIdentifierLength+sizePrefixLength)\n\tfor i := fileIdentifierLength - 1; i >= 0; i-- {\n\t\t// place the file identifier\n\t\tb.PlaceByte(fid[i])\n\t}\n\t// finish\n\tb.finish(rootTable, true)\n}\n\n// Finish finalizes a buffer, pointing to the given `rootTable`.\nfunc (b *Builder) Finish(rootTable UOffsetT) {\n\tb.finish(rootTable, false)\n}\n\n// finish finalizes a buffer, pointing to the given `rootTable`\n// with an optional size prefix.\nfunc (b *Builder) finish(rootTable UOffsetT, sizePrefix bool) {\n\tb.assertNotNested()\n\n\tif sizePrefix {\n\t\tb.Prep(b.minalign, SizeUOffsetT+sizePrefixLength)\n\t} else {\n\t\tb.Prep(b.minalign, SizeUOffsetT)\n\t}\n\n\tb.PrependUOffsetT(rootTable)\n\n\tif sizePrefix {\n\t\tb.PlaceUint32(uint32(b.Offset()))\n\t}\n\n\tb.finished = true\n}\n\n// vtableEqual compares an unwritten vtable to a written vtable.\nfunc vtableEqual(a []UOffsetT, objectStart UOffsetT, b []byte) bool {\n\tif len(a)*SizeVOffsetT != len(b) {\n\t\treturn false\n\t}\n\n\tfor i := 0; i < len(a); i++ {\n\t\tx := GetVOffsetT(b[i*SizeVOffsetT : (i+1)*SizeVOffsetT])\n\n\t\t// Skip vtable entries that indicate a default value.\n\t\tif x == 0 && a[i] == 0 {\n\t\t\tcontinue\n\t\t}\n\n\t\ty := SOffsetT(objectStart) - SOffsetT(a[i])\n\t\tif SOffsetT(x) != y {\n\t\t\treturn false\n\t\t}\n\t}\n\treturn true\n}\n\n// PrependBool prepends a bool to the Builder buffer.\n// Aligns and checks for space.\nfunc (b *Builder) PrependBool(x bool) {\n\tb.Prep(SizeBool, 0)\n\tb.PlaceBool(x)\n}\n\n// PrependUint8 prepends a uint8 to the Builder buffer.\n// Aligns and checks for space.\nfunc (b *Builder) PrependUint8(x uint8) {\n\tb.Prep(SizeUint8, 0)\n\tb.PlaceUint8(x)\n}\n\n// PrependUint16 prepends a uint16 to the Builder buffer.\n// Aligns and checks for space.\nfunc (b *Builder) PrependUint16(x uint16) {\n\tb.Prep(SizeUint16, 0)\n\tb.PlaceUint16(x)\n}\n\n// PrependUint32 prepends a uint32 to the Builder buffer.\n// Aligns and checks for space.\nfunc (b *Builder) PrependUint32(x uint32) {\n\tb.Prep(SizeUint32, 0)\n\tb.PlaceUint32(x)\n}\n\n// PrependUint64 prepends a uint64 to the Builder buffer.\n// Aligns and checks for space.\nfunc (b *Builder) PrependUint64(x uint64) {\n\tb.Prep(SizeUint64, 0)\n\tb.PlaceUint64(x)\n}\n\n// PrependInt8 prepends a int8 to the Builder buffer.\n// Aligns and checks for space.\nfunc (b *Builder) PrependInt8(x int8) {\n\tb.Prep(SizeInt8, 0)\n\tb.PlaceInt8(x)\n}\n\n// PrependInt16 prepends a int16 to the Builder buffer.\n// Aligns and checks for space.\nfunc (b *Builder) PrependInt16(x int16) {\n\tb.Prep(SizeInt16, 0)\n\tb.PlaceInt16(x)\n}\n\n// PrependInt32 prepends a int32 to the Builder buffer.\n// Aligns and checks for space.\nfunc (b *Builder) PrependInt32(x int32) {\n\tb.Prep(SizeInt32, 0)\n\tb.PlaceInt32(x)\n}\n\n// PrependInt64 prepends a int64 to the Builder buffer.\n// Aligns and checks for space.\nfunc (b *Builder) PrependInt64(x int64) {\n\tb.Prep(SizeInt64, 0)\n\tb.PlaceInt64(x)\n}\n\n// PrependFloat32 prepends a float32 to the Builder buffer.\n// Aligns and checks for space.\nfunc (b *Builder) PrependFloat32(x float32) {\n\tb.Prep(SizeFloat32, 0)\n\tb.PlaceFloat32(x)\n}\n\n// PrependFloat64 prepends a float64 to the Builder buffer.\n// Aligns and checks for space.\nfunc (b *Builder) PrependFloat64(x float64) {\n\tb.Prep(SizeFloat64, 0)\n\tb.PlaceFloat64(x)\n}\n\n// PrependByte prepends a byte to the Builder buffer.\n// Aligns and checks for space.\nfunc (b *Builder) PrependByte(x byte) {\n\tb.Prep(SizeByte, 0)\n\tb.PlaceByte(x)\n}\n\n// PrependVOffsetT prepends a VOffsetT to the Builder buffer.\n// Aligns and checks for space.\nfunc (b *Builder) PrependVOffsetT(x VOffsetT) {\n\tb.Prep(SizeVOffsetT, 0)\n\tb.PlaceVOffsetT(x)\n}\n\n// PlaceBool prepends a bool to the Builder, without checking for space.\nfunc (b *Builder) PlaceBool(x bool) {\n\tb.head -= UOffsetT(SizeBool)\n\tWriteBool(b.Bytes[b.head:], x)\n}\n\n// PlaceUint8 prepends a uint8 to the Builder, without checking for space.\nfunc (b *Builder) PlaceUint8(x uint8) {\n\tb.head -= UOffsetT(SizeUint8)\n\tWriteUint8(b.Bytes[b.head:], x)\n}\n\n// PlaceUint16 prepends a uint16 to the Builder, without checking for space.\nfunc (b *Builder) PlaceUint16(x uint16) {\n\tb.head -= UOffsetT(SizeUint16)\n\tWriteUint16(b.Bytes[b.head:], x)\n}\n\n// PlaceUint32 prepends a uint32 to the Builder, without checking for space.\nfunc (b *Builder) PlaceUint32(x uint32) {\n\tb.head -= UOffsetT(SizeUint32)\n\tWriteUint32(b.Bytes[b.head:], x)\n}\n\n// PlaceUint64 prepends a uint64 to the Builder, without checking for space.\nfunc (b *Builder) PlaceUint64(x uint64) {\n\tb.head -= UOffsetT(SizeUint64)\n\tWriteUint64(b.Bytes[b.head:], x)\n}\n\n// PlaceInt8 prepends a int8 to the Builder, without checking for space.\nfunc (b *Builder) PlaceInt8(x int8) {\n\tb.head -= UOffsetT(SizeInt8)\n\tWriteInt8(b.Bytes[b.head:], x)\n}\n\n// PlaceInt16 prepends a int16 to the Builder, without checking for space.\nfunc (b *Builder) PlaceInt16(x int16) {\n\tb.head -= UOffsetT(SizeInt16)\n\tWriteInt16(b.Bytes[b.head:], x)\n}\n\n// PlaceInt32 prepends a int32 to the Builder, without checking for space.\nfunc (b *Builder) PlaceInt32(x int32) {\n\tb.head -= UOffsetT(SizeInt32)\n\tWriteInt32(b.Bytes[b.head:], x)\n}\n\n// PlaceInt64 prepends a int64 to the Builder, without checking for space.\nfunc (b *Builder) PlaceInt64(x int64) {\n\tb.head -= UOffsetT(SizeInt64)\n\tWriteInt64(b.Bytes[b.head:], x)\n}\n\n// PlaceFloat32 prepends a float32 to the Builder, without checking for space.\nfunc (b *Builder) PlaceFloat32(x float32) {\n\tb.head -= UOffsetT(SizeFloat32)\n\tWriteFloat32(b.Bytes[b.head:], x)\n}\n\n// PlaceFloat64 prepends a float64 to the Builder, without checking for space.\nfunc (b *Builder) PlaceFloat64(x float64) {\n\tb.head -= UOffsetT(SizeFloat64)\n\tWriteFloat64(b.Bytes[b.head:], x)\n}\n\n// PlaceByte prepends a byte to the Builder, without checking for space.\nfunc (b *Builder) PlaceByte(x byte) {\n\tb.head -= UOffsetT(SizeByte)\n\tWriteByte(b.Bytes[b.head:], x)\n}\n\n// PlaceVOffsetT prepends a VOffsetT to the Builder, without checking for space.\nfunc (b *Builder) PlaceVOffsetT(x VOffsetT) {\n\tb.head -= UOffsetT(SizeVOffsetT)\n\tWriteVOffsetT(b.Bytes[b.head:], x)\n}\n\n// PlaceSOffsetT prepends a SOffsetT to the Builder, without checking for space.\nfunc (b *Builder) PlaceSOffsetT(x SOffsetT) {\n\tb.head -= UOffsetT(SizeSOffsetT)\n\tWriteSOffsetT(b.Bytes[b.head:], x)\n}\n\n// PlaceUOffsetT prepends a UOffsetT to the Builder, without checking for space.\nfunc (b *Builder) PlaceUOffsetT(x UOffsetT) {\n\tb.head -= UOffsetT(SizeUOffsetT)\n\tWriteUOffsetT(b.Bytes[b.head:], x)\n}\n" }, { "path": "go/doc.go", "content": "// Package flatbuffers provides facilities to read and write flatbuffers\n// objects.\npackage flatbuffers\n" }, { "path": "go/encode.go", "content": "package flatbuffers\n\nimport (\n\t\"math\"\n)\n\ntype (\n\t// A SOffsetT stores a signed offset into arbitrary data.\n\tSOffsetT int32\n\t// A UOffsetT stores an unsigned offset into vector data.\n\tUOffsetT uint32\n\t// A VOffsetT stores an unsigned offset in a vtable.\n\tVOffsetT uint16\n)\n\nconst (\n\t// VtableMetadataFields is the count of metadata fields in each vtable.\n\tVtableMetadataFields = 2\n)\n\n// GetByte decodes a little-endian byte from a byte slice.\nfunc GetByte(buf []byte) byte {\n\treturn byte(GetUint8(buf))\n}\n\n// GetBool decodes a little-endian bool from a byte slice.\nfunc GetBool(buf []byte) bool {\n\treturn buf[0] != 0\n}\n\n// GetUint8 decodes a little-endian uint8 from a byte slice.\nfunc GetUint8(buf []byte) (n uint8) {\n\tn = uint8(buf[0])\n\treturn\n}\n\n// GetUint16 decodes a little-endian uint16 from a byte slice.\nfunc GetUint16(buf []byte) (n uint16) {\n\t_ = buf[1] // Force one bounds check. See: golang.org/issue/14808\n\tn |= uint16(buf[0])\n\tn |= uint16(buf[1]) << 8\n\treturn\n}\n\n// GetUint32 decodes a little-endian uint32 from a byte slice.\nfunc GetUint32(buf []byte) (n uint32) {\n\t_ = buf[3] // Force one bounds check. See: golang.org/issue/14808\n\tn |= uint32(buf[0])\n\tn |= uint32(buf[1]) << 8\n\tn |= uint32(buf[2]) << 16\n\tn |= uint32(buf[3]) << 24\n\treturn\n}\n\n// GetUint64 decodes a little-endian uint64 from a byte slice.\nfunc GetUint64(buf []byte) (n uint64) {\n\t_ = buf[7] // Force one bounds check. See: golang.org/issue/14808\n\tn |= uint64(buf[0])\n\tn |= uint64(buf[1]) << 8\n\tn |= uint64(buf[2]) << 16\n\tn |= uint64(buf[3]) << 24\n\tn |= uint64(buf[4]) << 32\n\tn |= uint64(buf[5]) << 40\n\tn |= uint64(buf[6]) << 48\n\tn |= uint64(buf[7]) << 56\n\treturn\n}\n\n// GetInt8 decodes a little-endian int8 from a byte slice.\nfunc GetInt8(buf []byte) (n int8) {\n\tn = int8(buf[0])\n\treturn\n}\n\n// GetInt16 decodes a little-endian int16 from a byte slice.\nfunc GetInt16(buf []byte) (n int16) {\n\t_ = buf[1] // Force one bounds check. See: golang.org/issue/14808\n\tn |= int16(buf[0])\n\tn |= int16(buf[1]) << 8\n\treturn\n}\n\n// GetInt32 decodes a little-endian int32 from a byte slice.\nfunc GetInt32(buf []byte) (n int32) {\n\t_ = buf[3] // Force one bounds check. See: golang.org/issue/14808\n\tn |= int32(buf[0])\n\tn |= int32(buf[1]) << 8\n\tn |= int32(buf[2]) << 16\n\tn |= int32(buf[3]) << 24\n\treturn\n}\n\n// GetInt64 decodes a little-endian int64 from a byte slice.\nfunc GetInt64(buf []byte) (n int64) {\n\t_ = buf[7] // Force one bounds check. See: golang.org/issue/14808\n\tn |= int64(buf[0])\n\tn |= int64(buf[1]) << 8\n\tn |= int64(buf[2]) << 16\n\tn |= int64(buf[3]) << 24\n\tn |= int64(buf[4]) << 32\n\tn |= int64(buf[5]) << 40\n\tn |= int64(buf[6]) << 48\n\tn |= int64(buf[7]) << 56\n\treturn\n}\n\n// GetFloat32 decodes a little-endian float32 from a byte slice.\nfunc GetFloat32(buf []byte) float32 {\n\tx := GetUint32(buf)\n\treturn math.Float32frombits(x)\n}\n\n// GetFloat64 decodes a little-endian float64 from a byte slice.\nfunc GetFloat64(buf []byte) float64 {\n\tx := GetUint64(buf)\n\treturn math.Float64frombits(x)\n}\n\n// GetUOffsetT decodes a little-endian UOffsetT from a byte slice.\nfunc GetUOffsetT(buf []byte) UOffsetT {\n\treturn UOffsetT(GetUint32(buf))\n}\n\n// GetSOffsetT decodes a little-endian SOffsetT from a byte slice.\nfunc GetSOffsetT(buf []byte) SOffsetT {\n\treturn SOffsetT(GetInt32(buf))\n}\n\n// GetVOffsetT decodes a little-endian VOffsetT from a byte slice.\nfunc GetVOffsetT(buf []byte) VOffsetT {\n\treturn VOffsetT(GetUint16(buf))\n}\n\n// WriteByte encodes a little-endian uint8 into a byte slice.\nfunc WriteByte(buf []byte, n byte) {\n\tWriteUint8(buf, uint8(n))\n}\n\n// WriteBool encodes a little-endian bool into a byte slice.\nfunc WriteBool(buf []byte, b bool) {\n\tbuf[0] = 0\n\tif b {\n\t\tbuf[0] = 1\n\t}\n}\n\n// WriteUint8 encodes a little-endian uint8 into a byte slice.\nfunc WriteUint8(buf []byte, n uint8) {\n\tbuf[0] = byte(n)\n}\n\n// WriteUint16 encodes a little-endian uint16 into a byte slice.\nfunc WriteUint16(buf []byte, n uint16) {\n\t_ = buf[1] // Force one bounds check. See: golang.org/issue/14808\n\tbuf[0] = byte(n)\n\tbuf[1] = byte(n >> 8)\n}\n\n// WriteUint32 encodes a little-endian uint32 into a byte slice.\nfunc WriteUint32(buf []byte, n uint32) {\n\t_ = buf[3] // Force one bounds check. See: golang.org/issue/14808\n\tbuf[0] = byte(n)\n\tbuf[1] = byte(n >> 8)\n\tbuf[2] = byte(n >> 16)\n\tbuf[3] = byte(n >> 24)\n}\n\n// WriteUint64 encodes a little-endian uint64 into a byte slice.\nfunc WriteUint64(buf []byte, n uint64) {\n\t_ = buf[7] // Force one bounds check. See: golang.org/issue/14808\n\tbuf[0] = byte(n)\n\tbuf[1] = byte(n >> 8)\n\tbuf[2] = byte(n >> 16)\n\tbuf[3] = byte(n >> 24)\n\tbuf[4] = byte(n >> 32)\n\tbuf[5] = byte(n >> 40)\n\tbuf[6] = byte(n >> 48)\n\tbuf[7] = byte(n >> 56)\n}\n\n// WriteInt8 encodes a little-endian int8 into a byte slice.\nfunc WriteInt8(buf []byte, n int8) {\n\tbuf[0] = byte(n)\n}\n\n// WriteInt16 encodes a little-endian int16 into a byte slice.\nfunc WriteInt16(buf []byte, n int16) {\n\t_ = buf[1] // Force one bounds check. See: golang.org/issue/14808\n\tbuf[0] = byte(n)\n\tbuf[1] = byte(n >> 8)\n}\n\n// WriteInt32 encodes a little-endian int32 into a byte slice.\nfunc WriteInt32(buf []byte, n int32) {\n\t_ = buf[3] // Force one bounds check. See: golang.org/issue/14808\n\tbuf[0] = byte(n)\n\tbuf[1] = byte(n >> 8)\n\tbuf[2] = byte(n >> 16)\n\tbuf[3] = byte(n >> 24)\n}\n\n// WriteInt64 encodes a little-endian int64 into a byte slice.\nfunc WriteInt64(buf []byte, n int64) {\n\t_ = buf[7] // Force one bounds check. See: golang.org/issue/14808\n\tbuf[0] = byte(n)\n\tbuf[1] = byte(n >> 8)\n\tbuf[2] = byte(n >> 16)\n\tbuf[3] = byte(n >> 24)\n\tbuf[4] = byte(n >> 32)\n\tbuf[5] = byte(n >> 40)\n\tbuf[6] = byte(n >> 48)\n\tbuf[7] = byte(n >> 56)\n}\n\n// WriteFloat32 encodes a little-endian float32 into a byte slice.\nfunc WriteFloat32(buf []byte, n float32) {\n\tWriteUint32(buf, math.Float32bits(n))\n}\n\n// WriteFloat64 encodes a little-endian float64 into a byte slice.\nfunc WriteFloat64(buf []byte, n float64) {\n\tWriteUint64(buf, math.Float64bits(n))\n}\n\n// WriteVOffsetT encodes a little-endian VOffsetT into a byte slice.\nfunc WriteVOffsetT(buf []byte, n VOffsetT) {\n\tWriteUint16(buf, uint16(n))\n}\n\n// WriteSOffsetT encodes a little-endian SOffsetT into a byte slice.\nfunc WriteSOffsetT(buf []byte, n SOffsetT) {\n\tWriteInt32(buf, int32(n))\n}\n\n// WriteUOffsetT encodes a little-endian UOffsetT into a byte slice.\nfunc WriteUOffsetT(buf []byte, n UOffsetT) {\n\tWriteUint32(buf, uint32(n))\n}\n" }, { "path": "go/grpc.go", "content": "package flatbuffers\n\nimport \"errors\"\n\nvar (\n\t// Codec implements gRPC-go Codec which is used to encode and decode messages.\n\tCodec = \"flatbuffers\"\n\n\t// ErrInsufficientData is returned when the data is too short to read the root UOffsetT.\n\tErrInsufficientData = errors.New(\"insufficient data\")\n\n\t// ErrInvalidRootOffset is returned when the root UOffsetT is out of bounds.\n\tErrInvalidRootOffset = errors.New(\"invalid root offset\")\n)\n\n// FlatbuffersCodec defines the interface gRPC uses to encode and decode messages. Note\n// that implementations of this interface must be thread safe; a Codec's\n// methods can be called from concurrent goroutines.\ntype FlatbuffersCodec struct{}\n\n// Marshal returns the wire format of v.\nfunc (FlatbuffersCodec) Marshal(v interface{}) ([]byte, error) {\n\treturn v.(*Builder).FinishedBytes(), nil\n}\n\n// Unmarshal parses the wire format into v.\nfunc (FlatbuffersCodec) Unmarshal(data []byte, v interface{}) error {\n\t// Need at least 4 bytes to read the root table offset (UOffsetT).\n\t// Vtable soffset_t and metadata are read later during field access.\n\tif len(data) < SizeUOffsetT {\n\t\treturn ErrInsufficientData\n\t}\n\n\toff := GetUOffsetT(data)\n\n\t// The root UOffsetT must be within the data buffer\n\t// Compare in the unsigned domain to avoid signedness pitfalls\n\tif off > UOffsetT(len(data)-SizeUOffsetT) {\n\t\treturn ErrInvalidRootOffset\n\t}\n\n\tv.(flatbuffersInit).Init(data, off)\n\treturn nil\n}\n\n// String old gRPC Codec interface func\nfunc (FlatbuffersCodec) String() string {\n\treturn Codec\n}\n\n// Name returns the name of the Codec implementation. The returned string\n// will be used as part of content type in transmission. The result must be\n// static; the result cannot change between calls.\n//\n// add Name() for ForceCodec interface\nfunc (FlatbuffersCodec) Name() string {\n\treturn Codec\n}\n\ntype flatbuffersInit interface {\n\tInit(data []byte, i UOffsetT)\n}\n" }, { "path": "go/lib.go", "content": "package flatbuffers\n\n// FlatBuffer is the interface that represents a flatbuffer.\ntype FlatBuffer interface {\n\tTable() Table\n\tInit(buf []byte, i UOffsetT)\n}\n\n// GetRootAs is a generic helper to initialize a FlatBuffer with the provided buffer bytes and its data offset.\nfunc GetRootAs(buf []byte, offset UOffsetT, fb FlatBuffer) {\n\tn := GetUOffsetT(buf[offset:])\n\tfb.Init(buf, n+offset)\n}\n\n// GetSizePrefixedRootAs is a generic helper to initialize a FlatBuffer with the provided size-prefixed buffer\n// bytes and its data offset\nfunc GetSizePrefixedRootAs(buf []byte, offset UOffsetT, fb FlatBuffer) {\n\tn := GetUOffsetT(buf[offset+sizePrefixLength:])\n\tfb.Init(buf, n+offset+sizePrefixLength)\n}\n\n// GetSizePrefix reads the size from a size-prefixed flatbuffer\nfunc GetSizePrefix(buf []byte, offset UOffsetT) uint32 {\n\treturn GetUint32(buf[offset:])\n}\n\n// GetIndirectOffset retrives the relative offset in the provided buffer stored at `offset`.\nfunc GetIndirectOffset(buf []byte, offset UOffsetT) UOffsetT {\n\treturn offset + GetUOffsetT(buf[offset:])\n}\n\n// GetBufferIdentifier returns the file identifier as string\nfunc GetBufferIdentifier(buf []byte) string {\n\treturn string(buf[SizeUOffsetT:][:fileIdentifierLength])\n}\n\n// GetBufferIdentifier returns the file identifier as string for a size-prefixed buffer\nfunc GetSizePrefixedBufferIdentifier(buf []byte) string {\n\treturn string(buf[SizeUOffsetT+sizePrefixLength:][:fileIdentifierLength])\n}\n\n// BufferHasIdentifier checks if the identifier in a buffer has the expected value\nfunc BufferHasIdentifier(buf []byte, identifier string) bool {\n\treturn GetBufferIdentifier(buf) == identifier\n}\n\n// BufferHasIdentifier checks if the identifier in a buffer has the expected value for a size-prefixed buffer\nfunc SizePrefixedBufferHasIdentifier(buf []byte, identifier string) bool {\n\treturn GetSizePrefixedBufferIdentifier(buf) == identifier\n}\n" }, { "path": "go/sizes.go", "content": "package flatbuffers\n\nimport (\n\t\"unsafe\"\n)\n\nconst (\n\t// See http://golang.org/ref/spec#Numeric_types\n\n\t// SizeUint8 is the byte size of a uint8.\n\tSizeUint8 = 1\n\t// SizeUint16 is the byte size of a uint16.\n\tSizeUint16 = 2\n\t// SizeUint32 is the byte size of a uint32.\n\tSizeUint32 = 4\n\t// SizeUint64 is the byte size of a uint64.\n\tSizeUint64 = 8\n\n\t// SizeInt8 is the byte size of a int8.\n\tSizeInt8 = 1\n\t// SizeInt16 is the byte size of a int16.\n\tSizeInt16 = 2\n\t// SizeInt32 is the byte size of a int32.\n\tSizeInt32 = 4\n\t// SizeInt64 is the byte size of a int64.\n\tSizeInt64 = 8\n\n\t// SizeFloat32 is the byte size of a float32.\n\tSizeFloat32 = 4\n\t// SizeFloat64 is the byte size of a float64.\n\tSizeFloat64 = 8\n\n\t// SizeByte is the byte size of a byte.\n\t// The `byte` type is aliased (by Go definition) to uint8.\n\tSizeByte = 1\n\n\t// SizeBool is the byte size of a bool.\n\t// The `bool` type is aliased (by flatbuffers convention) to uint8.\n\tSizeBool = 1\n\n\t// SizeSOffsetT is the byte size of an SOffsetT.\n\t// The `SOffsetT` type is aliased (by flatbuffers convention) to int32.\n\tSizeSOffsetT = 4\n\t// SizeUOffsetT is the byte size of an UOffsetT.\n\t// The `UOffsetT` type is aliased (by flatbuffers convention) to uint32.\n\tSizeUOffsetT = 4\n\t// SizeVOffsetT is the byte size of an VOffsetT.\n\t// The `VOffsetT` type is aliased (by flatbuffers convention) to uint16.\n\tSizeVOffsetT = 2\n)\n\n// byteSliceToString converts a []byte to string without a heap allocation.\nfunc byteSliceToString(b []byte) string {\n\treturn *(*string)(unsafe.Pointer(&b))\n}\n" }, { "path": "go/struct.go", "content": "package flatbuffers\n\n// Struct wraps a byte slice and provides read access to its data.\n//\n// Structs do not have a vtable.\ntype Struct struct {\n\tTable\n}\n" }, { "path": "go/table.go", "content": "package flatbuffers\n\n// Table wraps a byte slice and provides read access to its data.\n//\n// The variable `Pos` indicates the root of the FlatBuffers object therein.\ntype Table struct {\n\tBytes []byte\n\tPos UOffsetT // Always < 1<<31.\n}\n\n// Offset provides access into the Table's vtable.\n//\n// Fields which are deprecated are ignored by checking against the vtable's length.\nfunc (t *Table) Offset(vtableOffset VOffsetT) VOffsetT {\n\tvtable := UOffsetT(SOffsetT(t.Pos) - t.GetSOffsetT(t.Pos))\n\tif vtableOffset < t.GetVOffsetT(vtable) {\n\t\treturn t.GetVOffsetT(vtable + UOffsetT(vtableOffset))\n\t}\n\treturn 0\n}\n\n// Indirect retrieves the relative offset stored at `offset`.\nfunc (t *Table) Indirect(off UOffsetT) UOffsetT {\n\treturn off + GetUOffsetT(t.Bytes[off:])\n}\n\n// String gets a string from data stored inside the flatbuffer.\nfunc (t *Table) String(off UOffsetT) string {\n\tb := t.ByteVector(off)\n\treturn byteSliceToString(b)\n}\n\n// ByteVector gets a byte slice from data stored inside the flatbuffer.\n// If the offset is invalid or out of bounds, returns nil to prevent crashes.\nfunc (t *Table) ByteVector(off UOffsetT) []byte {\n\tn := UOffsetT(len(t.Bytes))\n\t// Need at least SizeUOffsetT bytes to read the relative vector offset.\n\tu := UOffsetT(SizeUOffsetT)\n\tif n < u || off > n-u {\n\t\treturn nil\n\t}\n\toff += GetUOffsetT(t.Bytes[off:])\n\t// Need at least SizeUOffsetT bytes to read the vector length.\n\tif n < u || off > n-u {\n\t\treturn nil\n\t}\n\tstart := off + UOffsetT(SizeUOffsetT)\n\tlength := GetUOffsetT(t.Bytes[off:])\n\t// Avoid overflow by checking the length against the remaining buffer space.\n\tif length > n-start {\n\t\treturn nil\n\t}\n\treturn t.Bytes[start : start+length]\n}\n\n// VectorLen retrieves the length of the vector whose offset is stored at\n// \"off\" in this object.\nfunc (t *Table) VectorLen(off UOffsetT) int {\n\toff += t.Pos\n\toff += GetUOffsetT(t.Bytes[off:])\n\treturn int(GetUOffsetT(t.Bytes[off:]))\n}\n\n// Vector retrieves the start of data of the vector whose offset is stored\n// at \"off\" in this object.\nfunc (t *Table) Vector(off UOffsetT) UOffsetT {\n\toff += t.Pos\n\tx := off + GetUOffsetT(t.Bytes[off:])\n\t// data starts after metadata containing the vector length\n\tx += UOffsetT(SizeUOffsetT)\n\treturn x\n}\n\n// Union initializes any Table-derived type to point to the union at the given\n// offset.\nfunc (t *Table) Union(t2 *Table, off UOffsetT) {\n\toff += t.Pos\n\tt2.Pos = off + t.GetUOffsetT(off)\n\tt2.Bytes = t.Bytes\n}\n\n// GetBool retrieves a bool at the given offset.\nfunc (t *Table) GetBool(off UOffsetT) bool {\n\treturn GetBool(t.Bytes[off:])\n}\n\n// GetByte retrieves a byte at the given offset.\nfunc (t *Table) GetByte(off UOffsetT) byte {\n\treturn GetByte(t.Bytes[off:])\n}\n\n// GetUint8 retrieves a uint8 at the given offset.\nfunc (t *Table) GetUint8(off UOffsetT) uint8 {\n\treturn GetUint8(t.Bytes[off:])\n}\n\n// GetUint16 retrieves a uint16 at the given offset.\nfunc (t *Table) GetUint16(off UOffsetT) uint16 {\n\treturn GetUint16(t.Bytes[off:])\n}\n\n// GetUint32 retrieves a uint32 at the given offset.\nfunc (t *Table) GetUint32(off UOffsetT) uint32 {\n\treturn GetUint32(t.Bytes[off:])\n}\n\n// GetUint64 retrieves a uint64 at the given offset.\nfunc (t *Table) GetUint64(off UOffsetT) uint64 {\n\treturn GetUint64(t.Bytes[off:])\n}\n\n// GetInt8 retrieves a int8 at the given offset.\nfunc (t *Table) GetInt8(off UOffsetT) int8 {\n\treturn GetInt8(t.Bytes[off:])\n}\n\n// GetInt16 retrieves a int16 at the given offset.\nfunc (t *Table) GetInt16(off UOffsetT) int16 {\n\treturn GetInt16(t.Bytes[off:])\n}\n\n// GetInt32 retrieves a int32 at the given offset.\nfunc (t *Table) GetInt32(off UOffsetT) int32 {\n\treturn GetInt32(t.Bytes[off:])\n}\n\n// GetInt64 retrieves a int64 at the given offset.\nfunc (t *Table) GetInt64(off UOffsetT) int64 {\n\treturn GetInt64(t.Bytes[off:])\n}\n\n// GetFloat32 retrieves a float32 at the given offset.\nfunc (t *Table) GetFloat32(off UOffsetT) float32 {\n\treturn GetFloat32(t.Bytes[off:])\n}\n\n// GetFloat64 retrieves a float64 at the given offset.\nfunc (t *Table) GetFloat64(off UOffsetT) float64 {\n\treturn GetFloat64(t.Bytes[off:])\n}\n\n// GetUOffsetT retrieves a UOffsetT at the given offset.\nfunc (t *Table) GetUOffsetT(off UOffsetT) UOffsetT {\n\treturn GetUOffsetT(t.Bytes[off:])\n}\n\n// GetVOffsetT retrieves a VOffsetT at the given offset.\nfunc (t *Table) GetVOffsetT(off UOffsetT) VOffsetT {\n\treturn GetVOffsetT(t.Bytes[off:])\n}\n\n// GetSOffsetT retrieves a SOffsetT at the given offset.\nfunc (t *Table) GetSOffsetT(off UOffsetT) SOffsetT {\n\treturn GetSOffsetT(t.Bytes[off:])\n}\n\n// GetBoolSlot retrieves the bool that the given vtable location\n// points to. If the vtable value is zero, the default value `d`\n// will be returned.\nfunc (t *Table) GetBoolSlot(slot VOffsetT, d bool) bool {\n\toff := t.Offset(slot)\n\tif off == 0 {\n\t\treturn d\n\t}\n\n\treturn t.GetBool(t.Pos + UOffsetT(off))\n}\n\n// GetByteSlot retrieves the byte that the given vtable location\n// points to. If the vtable value is zero, the default value `d`\n// will be returned.\nfunc (t *Table) GetByteSlot(slot VOffsetT, d byte) byte {\n\toff := t.Offset(slot)\n\tif off == 0 {\n\t\treturn d\n\t}\n\n\treturn t.GetByte(t.Pos + UOffsetT(off))\n}\n\n// GetInt8Slot retrieves the int8 that the given vtable location\n// points to. If the vtable value is zero, the default value `d`\n// will be returned.\nfunc (t *Table) GetInt8Slot(slot VOffsetT, d int8) int8 {\n\toff := t.Offset(slot)\n\tif off == 0 {\n\t\treturn d\n\t}\n\n\treturn t.GetInt8(t.Pos + UOffsetT(off))\n}\n\n// GetUint8Slot retrieves the uint8 that the given vtable location\n// points to. If the vtable value is zero, the default value `d`\n// will be returned.\nfunc (t *Table) GetUint8Slot(slot VOffsetT, d uint8) uint8 {\n\toff := t.Offset(slot)\n\tif off == 0 {\n\t\treturn d\n\t}\n\n\treturn t.GetUint8(t.Pos + UOffsetT(off))\n}\n\n// GetInt16Slot retrieves the int16 that the given vtable location\n// points to. If the vtable value is zero, the default value `d`\n// will be returned.\nfunc (t *Table) GetInt16Slot(slot VOffsetT, d int16) int16 {\n\toff := t.Offset(slot)\n\tif off == 0 {\n\t\treturn d\n\t}\n\n\treturn t.GetInt16(t.Pos + UOffsetT(off))\n}\n\n// GetUint16Slot retrieves the uint16 that the given vtable location\n// points to. If the vtable value is zero, the default value `d`\n// will be returned.\nfunc (t *Table) GetUint16Slot(slot VOffsetT, d uint16) uint16 {\n\toff := t.Offset(slot)\n\tif off == 0 {\n\t\treturn d\n\t}\n\n\treturn t.GetUint16(t.Pos + UOffsetT(off))\n}\n\n// GetInt32Slot retrieves the int32 that the given vtable location\n// points to. If the vtable value is zero, the default value `d`\n// will be returned.\nfunc (t *Table) GetInt32Slot(slot VOffsetT, d int32) int32 {\n\toff := t.Offset(slot)\n\tif off == 0 {\n\t\treturn d\n\t}\n\n\treturn t.GetInt32(t.Pos + UOffsetT(off))\n}\n\n// GetUint32Slot retrieves the uint32 that the given vtable location\n// points to. If the vtable value is zero, the default value `d`\n// will be returned.\nfunc (t *Table) GetUint32Slot(slot VOffsetT, d uint32) uint32 {\n\toff := t.Offset(slot)\n\tif off == 0 {\n\t\treturn d\n\t}\n\n\treturn t.GetUint32(t.Pos + UOffsetT(off))\n}\n\n// GetInt64Slot retrieves the int64 that the given vtable location\n// points to. If the vtable value is zero, the default value `d`\n// will be returned.\nfunc (t *Table) GetInt64Slot(slot VOffsetT, d int64) int64 {\n\toff := t.Offset(slot)\n\tif off == 0 {\n\t\treturn d\n\t}\n\n\treturn t.GetInt64(t.Pos + UOffsetT(off))\n}\n\n// GetUint64Slot retrieves the uint64 that the given vtable location\n// points to. If the vtable value is zero, the default value `d`\n// will be returned.\nfunc (t *Table) GetUint64Slot(slot VOffsetT, d uint64) uint64 {\n\toff := t.Offset(slot)\n\tif off == 0 {\n\t\treturn d\n\t}\n\n\treturn t.GetUint64(t.Pos + UOffsetT(off))\n}\n\n// GetFloat32Slot retrieves the float32 that the given vtable location\n// points to. If the vtable value is zero, the default value `d`\n// will be returned.\nfunc (t *Table) GetFloat32Slot(slot VOffsetT, d float32) float32 {\n\toff := t.Offset(slot)\n\tif off == 0 {\n\t\treturn d\n\t}\n\n\treturn t.GetFloat32(t.Pos + UOffsetT(off))\n}\n\n// GetFloat64Slot retrieves the float64 that the given vtable location\n// points to. If the vtable value is zero, the default value `d`\n// will be returned.\nfunc (t *Table) GetFloat64Slot(slot VOffsetT, d float64) float64 {\n\toff := t.Offset(slot)\n\tif off == 0 {\n\t\treturn d\n\t}\n\n\treturn t.GetFloat64(t.Pos + UOffsetT(off))\n}\n\n// GetVOffsetTSlot retrieves the VOffsetT that the given vtable location\n// points to. If the vtable value is zero, the default value `d`\n// will be returned.\nfunc (t *Table) GetVOffsetTSlot(slot VOffsetT, d VOffsetT) VOffsetT {\n\toff := t.Offset(slot)\n\tif off == 0 {\n\t\treturn d\n\t}\n\treturn VOffsetT(off)\n}\n\n// MutateBool updates a bool at the given offset.\nfunc (t *Table) MutateBool(off UOffsetT, n bool) bool {\n\tWriteBool(t.Bytes[off:], n)\n\treturn true\n}\n\n// MutateByte updates a Byte at the given offset.\nfunc (t *Table) MutateByte(off UOffsetT, n byte) bool {\n\tWriteByte(t.Bytes[off:], n)\n\treturn true\n}\n\n// MutateUint8 updates a Uint8 at the given offset.\nfunc (t *Table) MutateUint8(off UOffsetT, n uint8) bool {\n\tWriteUint8(t.Bytes[off:], n)\n\treturn true\n}\n\n// MutateUint16 updates a Uint16 at the given offset.\nfunc (t *Table) MutateUint16(off UOffsetT, n uint16) bool {\n\tWriteUint16(t.Bytes[off:], n)\n\treturn true\n}\n\n// MutateUint32 updates a Uint32 at the given offset.\nfunc (t *Table) MutateUint32(off UOffsetT, n uint32) bool {\n\tWriteUint32(t.Bytes[off:], n)\n\treturn true\n}\n\n// MutateUint64 updates a Uint64 at the given offset.\nfunc (t *Table) MutateUint64(off UOffsetT, n uint64) bool {\n\tWriteUint64(t.Bytes[off:], n)\n\treturn true\n}\n\n// MutateInt8 updates a Int8 at the given offset.\nfunc (t *Table) MutateInt8(off UOffsetT, n int8) bool {\n\tWriteInt8(t.Bytes[off:], n)\n\treturn true\n}\n\n// MutateInt16 updates a Int16 at the given offset.\nfunc (t *Table) MutateInt16(off UOffsetT, n int16) bool {\n\tWriteInt16(t.Bytes[off:], n)\n\treturn true\n}\n\n// MutateInt32 updates a Int32 at the given offset.\nfunc (t *Table) MutateInt32(off UOffsetT, n int32) bool {\n\tWriteInt32(t.Bytes[off:], n)\n\treturn true\n}\n\n// MutateInt64 updates a Int64 at the given offset.\nfunc (t *Table) MutateInt64(off UOffsetT, n int64) bool {\n\tWriteInt64(t.Bytes[off:], n)\n\treturn true\n}\n\n// MutateFloat32 updates a Float32 at the given offset.\nfunc (t *Table) MutateFloat32(off UOffsetT, n float32) bool {\n\tWriteFloat32(t.Bytes[off:], n)\n\treturn true\n}\n\n// MutateFloat64 updates a Float64 at the given offset.\nfunc (t *Table) MutateFloat64(off UOffsetT, n float64) bool {\n\tWriteFloat64(t.Bytes[off:], n)\n\treturn true\n}\n\n// MutateUOffsetT updates a UOffsetT at the given offset.\nfunc (t *Table) MutateUOffsetT(off UOffsetT, n UOffsetT) bool {\n\tWriteUOffsetT(t.Bytes[off:], n)\n\treturn true\n}\n\n// MutateVOffsetT updates a VOffsetT at the given offset.\nfunc (t *Table) MutateVOffsetT(off UOffsetT, n VOffsetT) bool {\n\tWriteVOffsetT(t.Bytes[off:], n)\n\treturn true\n}\n\n// MutateSOffsetT updates a SOffsetT at the given offset.\nfunc (t *Table) MutateSOffsetT(off UOffsetT, n SOffsetT) bool {\n\tWriteSOffsetT(t.Bytes[off:], n)\n\treturn true\n}\n\n// MutateBoolSlot updates the bool at given vtable location\nfunc (t *Table) MutateBoolSlot(slot VOffsetT, n bool) bool {\n\tif off := t.Offset(slot); off != 0 {\n\t\tt.MutateBool(t.Pos+UOffsetT(off), n)\n\t\treturn true\n\t}\n\n\treturn false\n}\n\n// MutateByteSlot updates the byte at given vtable location\nfunc (t *Table) MutateByteSlot(slot VOffsetT, n byte) bool {\n\tif off := t.Offset(slot); off != 0 {\n\t\tt.MutateByte(t.Pos+UOffsetT(off), n)\n\t\treturn true\n\t}\n\n\treturn false\n}\n\n// MutateInt8Slot updates the int8 at given vtable location\nfunc (t *Table) MutateInt8Slot(slot VOffsetT, n int8) bool {\n\tif off := t.Offset(slot); off != 0 {\n\t\tt.MutateInt8(t.Pos+UOffsetT(off), n)\n\t\treturn true\n\t}\n\n\treturn false\n}\n\n// MutateUint8Slot updates the uint8 at given vtable location\nfunc (t *Table) MutateUint8Slot(slot VOffsetT, n uint8) bool {\n\tif off := t.Offset(slot); off != 0 {\n\t\tt.MutateUint8(t.Pos+UOffsetT(off), n)\n\t\treturn true\n\t}\n\n\treturn false\n}\n\n// MutateInt16Slot updates the int16 at given vtable location\nfunc (t *Table) MutateInt16Slot(slot VOffsetT, n int16) bool {\n\tif off := t.Offset(slot); off != 0 {\n\t\tt.MutateInt16(t.Pos+UOffsetT(off), n)\n\t\treturn true\n\t}\n\n\treturn false\n}\n\n// MutateUint16Slot updates the uint16 at given vtable location\nfunc (t *Table) MutateUint16Slot(slot VOffsetT, n uint16) bool {\n\tif off := t.Offset(slot); off != 0 {\n\t\tt.MutateUint16(t.Pos+UOffsetT(off), n)\n\t\treturn true\n\t}\n\n\treturn false\n}\n\n// MutateInt32Slot updates the int32 at given vtable location\nfunc (t *Table) MutateInt32Slot(slot VOffsetT, n int32) bool {\n\tif off := t.Offset(slot); off != 0 {\n\t\tt.MutateInt32(t.Pos+UOffsetT(off), n)\n\t\treturn true\n\t}\n\n\treturn false\n}\n\n// MutateUint32Slot updates the uint32 at given vtable location\nfunc (t *Table) MutateUint32Slot(slot VOffsetT, n uint32) bool {\n\tif off := t.Offset(slot); off != 0 {\n\t\tt.MutateUint32(t.Pos+UOffsetT(off), n)\n\t\treturn true\n\t}\n\n\treturn false\n}\n\n// MutateInt64Slot updates the int64 at given vtable location\nfunc (t *Table) MutateInt64Slot(slot VOffsetT, n int64) bool {\n\tif off := t.Offset(slot); off != 0 {\n\t\tt.MutateInt64(t.Pos+UOffsetT(off), n)\n\t\treturn true\n\t}\n\n\treturn false\n}\n\n// MutateUint64Slot updates the uint64 at given vtable location\nfunc (t *Table) MutateUint64Slot(slot VOffsetT, n uint64) bool {\n\tif off := t.Offset(slot); off != 0 {\n\t\tt.MutateUint64(t.Pos+UOffsetT(off), n)\n\t\treturn true\n\t}\n\n\treturn false\n}\n\n// MutateFloat32Slot updates the float32 at given vtable location\nfunc (t *Table) MutateFloat32Slot(slot VOffsetT, n float32) bool {\n\tif off := t.Offset(slot); off != 0 {\n\t\tt.MutateFloat32(t.Pos+UOffsetT(off), n)\n\t\treturn true\n\t}\n\n\treturn false\n}\n\n// MutateFloat64Slot updates the float64 at given vtable location\nfunc (t *Table) MutateFloat64Slot(slot VOffsetT, n float64) bool {\n\tif off := t.Offset(slot); off != 0 {\n\t\tt.MutateFloat64(t.Pos+UOffsetT(off), n)\n\t\treturn true\n\t}\n\n\treturn false\n}\n" }, { "path": "goldens/README.md", "content": "# Golden Generated Files\n\nThis directory is a repository for the generated files of `flatc`.\n\nWe check in the generated code so we can see, during a PR review, how the\nchanges affect the generated output. It's also useful as a reference to show\nhow things work across various languages.\n\nThese files are **NOT** intended to be depended on by any code, such as tests or\nor compiled examples.\n\n## Languages Specifics\n\nEach language should keep their generated code in their respective directories.\nHowever, the parent schemas can, and should, be shared so we have a consistent\nview of things across languages. These are kept in the `schema/` directory.\n\nSome languages may not support every generation feature, so each language is\nrequired to specify the `flatc` arguments individually.\n\n* Try to avoid includes and nested directories, preferring it as flat as\npossible.\n\n## Updating\n\nJust run the `generate_goldens.py` script and it should generate them all.\n" }, { "path": "goldens/cpp/basic_generated.h", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n\n\n#ifndef FLATBUFFERS_GENERATED_BASIC_FLATBUFFERS_GOLDENS_H_\n#define FLATBUFFERS_GENERATED_BASIC_FLATBUFFERS_GOLDENS_H_\n\n#include \"flatbuffers/flatbuffers.h\"\n\n// Ensure the included flatbuffers.h is the same version as when this file was\n// generated, otherwise it may not be compatible.\nstatic_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&\n FLATBUFFERS_VERSION_MINOR == 12 &&\n FLATBUFFERS_VERSION_REVISION == 19,\n \"Non-compatible flatbuffers version included\");\n\nnamespace flatbuffers {\nnamespace goldens {\n\nstruct Galaxy;\nstruct GalaxyBuilder;\n\nstruct Universe;\nstruct UniverseBuilder;\n\nstruct Galaxy FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {\n typedef GalaxyBuilder Builder;\n enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {\n VT_NUM_STARS = 4\n };\n int64_t num_stars() const {\n return GetField(VT_NUM_STARS, 0);\n }\n template \n bool Verify(::flatbuffers::VerifierTemplate &verifier) const {\n return VerifyTableStart(verifier) &&\n VerifyField(verifier, VT_NUM_STARS, 8) &&\n verifier.EndTable();\n }\n};\n\nstruct GalaxyBuilder {\n typedef Galaxy Table;\n ::flatbuffers::FlatBufferBuilder &fbb_;\n ::flatbuffers::uoffset_t start_;\n void add_num_stars(int64_t num_stars) {\n fbb_.AddElement(Galaxy::VT_NUM_STARS, num_stars, 0);\n }\n explicit GalaxyBuilder(::flatbuffers::FlatBufferBuilder &_fbb)\n : fbb_(_fbb) {\n start_ = fbb_.StartTable();\n }\n ::flatbuffers::Offset Finish() {\n const auto end = fbb_.EndTable(start_);\n auto o = ::flatbuffers::Offset(end);\n return o;\n }\n};\n\ninline ::flatbuffers::Offset CreateGalaxy(\n ::flatbuffers::FlatBufferBuilder &_fbb,\n int64_t num_stars = 0) {\n GalaxyBuilder builder_(_fbb);\n builder_.add_num_stars(num_stars);\n return builder_.Finish();\n}\n\nstruct Universe FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {\n typedef UniverseBuilder Builder;\n enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {\n VT_AGE = 4,\n VT_GALAXIES = 6\n };\n double age() const {\n return GetField(VT_AGE, 0.0);\n }\n const ::flatbuffers::Vector<::flatbuffers::Offset> *galaxies() const {\n return GetPointer> *>(VT_GALAXIES);\n }\n template \n bool Verify(::flatbuffers::VerifierTemplate &verifier) const {\n return VerifyTableStart(verifier) &&\n VerifyField(verifier, VT_AGE, 8) &&\n VerifyOffset(verifier, VT_GALAXIES) &&\n verifier.VerifyVector(galaxies()) &&\n verifier.VerifyVectorOfTables(galaxies()) &&\n verifier.EndTable();\n }\n};\n\nstruct UniverseBuilder {\n typedef Universe Table;\n ::flatbuffers::FlatBufferBuilder &fbb_;\n ::flatbuffers::uoffset_t start_;\n void add_age(double age) {\n fbb_.AddElement(Universe::VT_AGE, age, 0.0);\n }\n void add_galaxies(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> galaxies) {\n fbb_.AddOffset(Universe::VT_GALAXIES, galaxies);\n }\n explicit UniverseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)\n : fbb_(_fbb) {\n start_ = fbb_.StartTable();\n }\n ::flatbuffers::Offset Finish() {\n const auto end = fbb_.EndTable(start_);\n auto o = ::flatbuffers::Offset(end);\n return o;\n }\n};\n\ninline ::flatbuffers::Offset CreateUniverse(\n ::flatbuffers::FlatBufferBuilder &_fbb,\n double age = 0.0,\n ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> galaxies = 0) {\n UniverseBuilder builder_(_fbb);\n builder_.add_age(age);\n builder_.add_galaxies(galaxies);\n return builder_.Finish();\n}\n\ninline ::flatbuffers::Offset CreateUniverseDirect(\n ::flatbuffers::FlatBufferBuilder &_fbb,\n double age = 0.0,\n const std::vector<::flatbuffers::Offset> *galaxies = nullptr) {\n auto galaxies__ = galaxies ? _fbb.CreateVector<::flatbuffers::Offset>(*galaxies) : 0;\n return flatbuffers::goldens::CreateUniverse(\n _fbb,\n age,\n galaxies__);\n}\n\ninline const flatbuffers::goldens::Universe *GetUniverse(const void *buf) {\n return ::flatbuffers::GetRoot(buf);\n}\n\ninline const flatbuffers::goldens::Universe *GetSizePrefixedUniverse(const void *buf) {\n return ::flatbuffers::GetSizePrefixedRoot(buf);\n}\n\ntemplate \ninline bool VerifyUniverseBuffer(\n ::flatbuffers::VerifierTemplate &verifier) {\n return verifier.template VerifyBuffer(nullptr);\n}\n\ntemplate \ninline bool VerifySizePrefixedUniverseBuffer(\n ::flatbuffers::VerifierTemplate &verifier) {\n return verifier.template VerifySizePrefixedBuffer(nullptr);\n}\n\ninline void FinishUniverseBuffer(\n ::flatbuffers::FlatBufferBuilder &fbb,\n ::flatbuffers::Offset root) {\n fbb.Finish(root);\n}\n\ninline void FinishSizePrefixedUniverseBuffer(\n ::flatbuffers::FlatBufferBuilder &fbb,\n ::flatbuffers::Offset root) {\n fbb.FinishSizePrefixed(root);\n}\n\n} // namespace goldens\n} // namespace flatbuffers\n\n#endif // FLATBUFFERS_GENERATED_BASIC_FLATBUFFERS_GOLDENS_H_\n" }, { "path": "goldens/cpp/generate.py", "content": "from golden_utils import flatc_golden\n\n\ndef flatc(options, schema):\n # Wrap the golden flatc generator with C++ specifics\n flatc_golden(options=[\"--cpp\"] + options, schema=schema, prefix=\"cpp\")\n\n\ndef GenerateCpp():\n flatc([], \"basic.fbs\")\n" }, { "path": "goldens/csharp/flatbuffers/goldens/Galaxy.cs", "content": "// \n// automatically generated by the FlatBuffers compiler, do not modify\n// \n\nnamespace flatbuffers.goldens\n{\n\nusing global::System;\nusing global::System.Collections.Generic;\nusing global::Google.FlatBuffers;\n\npublic struct Galaxy : IFlatbufferObject\n{\n private Table __p;\n public ByteBuffer ByteBuffer { get { return __p.bb; } }\n public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_12_19(); }\n public static Galaxy GetRootAsGalaxy(ByteBuffer _bb) { return GetRootAsGalaxy(_bb, new Galaxy()); }\n public static Galaxy GetRootAsGalaxy(ByteBuffer _bb, Galaxy obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }\n public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }\n public Galaxy __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }\n\n public long NumStars { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }\n\n public static Offset CreateGalaxy(FlatBufferBuilder builder,\n long num_stars = 0) {\n builder.StartTable(1);\n Galaxy.AddNumStars(builder, num_stars);\n return Galaxy.EndGalaxy(builder);\n }\n\n public static void StartGalaxy(FlatBufferBuilder builder) { builder.StartTable(1); }\n public static void AddNumStars(FlatBufferBuilder builder, long numStars) { builder.AddLong(0, numStars, 0); }\n public static Offset EndGalaxy(FlatBufferBuilder builder) {\n int o = builder.EndTable();\n return new Offset(o);\n }\n}\n\n\nstatic public class GalaxyVerify\n{\n static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)\n {\n return verifier.VerifyTableStart(tablePos)\n && verifier.VerifyField(tablePos, 4 /*NumStars*/, 8 /*long*/, 8, false)\n && verifier.VerifyTableEnd(tablePos);\n }\n}\n\n}\n" }, { "path": "goldens/csharp/flatbuffers/goldens/Universe.cs", "content": "// \n// automatically generated by the FlatBuffers compiler, do not modify\n// \n\nnamespace flatbuffers.goldens\n{\n\nusing global::System;\nusing global::System.Collections.Generic;\nusing global::Google.FlatBuffers;\n\npublic struct Universe : IFlatbufferObject\n{\n private Table __p;\n public ByteBuffer ByteBuffer { get { return __p.bb; } }\n public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_12_19(); }\n public static Universe GetRootAsUniverse(ByteBuffer _bb) { return GetRootAsUniverse(_bb, new Universe()); }\n public static Universe GetRootAsUniverse(ByteBuffer _bb, Universe obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }\n public static bool VerifyUniverse(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer(\"\", false, UniverseVerify.Verify); }\n public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }\n public Universe __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }\n\n public double Age { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetDouble(o + __p.bb_pos) : (double)0.0; } }\n public flatbuffers.goldens.Galaxy? Galaxies(int j) { int o = __p.__offset(6); return o != 0 ? (flatbuffers.goldens.Galaxy?)(new flatbuffers.goldens.Galaxy()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }\n public int GalaxiesLength { get { int o = __p.__offset(6); return o != 0 ? __p.__vector_len(o) : 0; } }\n\n public static Offset CreateUniverse(FlatBufferBuilder builder,\n double age = 0.0,\n VectorOffset galaxiesOffset = default(VectorOffset)) {\n builder.StartTable(2);\n Universe.AddAge(builder, age);\n Universe.AddGalaxies(builder, galaxiesOffset);\n return Universe.EndUniverse(builder);\n }\n\n public static void StartUniverse(FlatBufferBuilder builder) { builder.StartTable(2); }\n public static void AddAge(FlatBufferBuilder builder, double age) { builder.AddDouble(0, age, 0.0); }\n public static void AddGalaxies(FlatBufferBuilder builder, VectorOffset galaxiesOffset) { builder.AddOffset(1, galaxiesOffset.Value, 0); }\n public static VectorOffset CreateGalaxiesVector(FlatBufferBuilder builder, Offset[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }\n public static VectorOffset CreateGalaxiesVectorBlock(FlatBufferBuilder builder, Offset[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }\n public static VectorOffset CreateGalaxiesVectorBlock(FlatBufferBuilder builder, ArraySegment> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }\n public static VectorOffset CreateGalaxiesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add>(dataPtr, sizeInBytes); return builder.EndVector(); }\n public static void StartGalaxiesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }\n public static Offset EndUniverse(FlatBufferBuilder builder) {\n int o = builder.EndTable();\n return new Offset(o);\n }\n public static void FinishUniverseBuffer(FlatBufferBuilder builder, Offset offset) { builder.Finish(offset.Value); }\n public static void FinishSizePrefixedUniverseBuffer(FlatBufferBuilder builder, Offset offset) { builder.FinishSizePrefixed(offset.Value); }\n}\n\n\nstatic public class UniverseVerify\n{\n static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)\n {\n return verifier.VerifyTableStart(tablePos)\n && verifier.VerifyField(tablePos, 4 /*Age*/, 8 /*double*/, 8, false)\n && verifier.VerifyVectorOfTables(tablePos, 6 /*Galaxies*/, flatbuffers.goldens.GalaxyVerify.Verify, false)\n && verifier.VerifyTableEnd(tablePos);\n }\n}\n\n}\n" }, { "path": "goldens/csharp/generate.py", "content": "from golden_utils import flatc_golden\n\n\ndef flatc(options, schema):\n # Wrap the golden flatc generator with C# specifics\n flatc_golden(options=[\"--csharp\"] + options, schema=schema, prefix=\"csharp\")\n\n\ndef GenerateCSharp():\n flatc([], \"basic.fbs\")\n" }, { "path": "goldens/dart/basic_flatbuffers.goldens_generated.dart", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable, constant_identifier_names\n\nlibrary flatbuffers.goldens;\n\nimport 'dart:typed_data' show Uint8List;\nimport 'package:flat_buffers/flat_buffers.dart' as fb;\n\n\n\nclass Galaxy {\n Galaxy._(this._bc, this._bcOffset);\n factory Galaxy(List bytes) {\n final rootRef = fb.BufferContext.fromBytes(bytes);\n return reader.read(rootRef, 0);\n }\n\n static const fb.Reader reader = _GalaxyReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n int get numStars => const fb.Int64Reader().vTableGet(_bc, _bcOffset, 4, 0);\n\n @override\n String toString() {\n return 'Galaxy{numStars: ${numStars}}';\n }\n}\n\nclass _GalaxyReader extends fb.TableReader {\n const _GalaxyReader();\n\n @override\n Galaxy createObject(fb.BufferContext bc, int offset) => \n Galaxy._(bc, offset);\n}\n\nclass GalaxyBuilder {\n GalaxyBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n void begin() {\n fbBuilder.startTable(1);\n }\n\n int addNumStars(int? numStars) {\n fbBuilder.addInt64(0, numStars);\n return fbBuilder.offset;\n }\n\n int finish() {\n return fbBuilder.endTable();\n }\n}\n\nclass GalaxyObjectBuilder extends fb.ObjectBuilder {\n final int? _numStars;\n\n GalaxyObjectBuilder({\n int? numStars,\n })\n : _numStars = numStars;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n fbBuilder.startTable(1);\n fbBuilder.addInt64(0, _numStars);\n return fbBuilder.endTable();\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\nclass Universe {\n Universe._(this._bc, this._bcOffset);\n factory Universe(List bytes) {\n final rootRef = fb.BufferContext.fromBytes(bytes);\n return reader.read(rootRef, 0);\n }\n\n static const fb.Reader reader = _UniverseReader();\n\n final fb.BufferContext _bc;\n final int _bcOffset;\n\n double get age => const fb.Float64Reader().vTableGet(_bc, _bcOffset, 4, 0.0);\n List? get galaxies => const fb.ListReader(Galaxy.reader).vTableGetNullable(_bc, _bcOffset, 6);\n\n @override\n String toString() {\n return 'Universe{age: ${age}, galaxies: ${galaxies}}';\n }\n}\n\nclass _UniverseReader extends fb.TableReader {\n const _UniverseReader();\n\n @override\n Universe createObject(fb.BufferContext bc, int offset) => \n Universe._(bc, offset);\n}\n\nclass UniverseBuilder {\n UniverseBuilder(this.fbBuilder);\n\n final fb.Builder fbBuilder;\n\n void begin() {\n fbBuilder.startTable(2);\n }\n\n int addAge(double? age) {\n fbBuilder.addFloat64(0, age);\n return fbBuilder.offset;\n }\n int addGalaxiesOffset(int? offset) {\n fbBuilder.addOffset(1, offset);\n return fbBuilder.offset;\n }\n\n int finish() {\n return fbBuilder.endTable();\n }\n}\n\nclass UniverseObjectBuilder extends fb.ObjectBuilder {\n final double? _age;\n final List? _galaxies;\n\n UniverseObjectBuilder({\n double? age,\n List? galaxies,\n })\n : _age = age,\n _galaxies = galaxies;\n\n /// Finish building, and store into the [fbBuilder].\n @override\n int finish(fb.Builder fbBuilder) {\n final int? galaxiesOffset = _galaxies == null ? null\n : fbBuilder.writeList(_galaxies!.map((b) => b.getOrCreateOffset(fbBuilder)).toList());\n fbBuilder.startTable(2);\n fbBuilder.addFloat64(0, _age);\n fbBuilder.addOffset(1, galaxiesOffset);\n return fbBuilder.endTable();\n }\n\n /// Convenience method to serialize to byte list.\n @override\n Uint8List toBytes([String? fileIdentifier]) {\n final fbBuilder = fb.Builder(deduplicateTables: false);\n fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n return fbBuilder.buffer;\n }\n}\n" }, { "path": "goldens/dart/generate.py", "content": "from golden_utils import flatc_golden\n\n\ndef flatc(options, schema):\n # Wrap the golden flatc generator with Dart specifics\n flatc_golden(options=[\"--dart\"] + options, schema=schema, prefix=\"dart\")\n\n\ndef GenerateDart():\n flatc([], \"basic.fbs\")\n" }, { "path": "goldens/generate_goldens.py", "content": "#!/usr/bin/env python3\n\nfrom cpp.generate import GenerateCpp\nfrom csharp.generate import GenerateCSharp\nfrom dart.generate import GenerateDart\nfrom go.generate import GenerateGo\nfrom java.generate import GenerateJava\nfrom kotlin.generate import GenerateKotlin\nfrom lobster.generate import GenerateLobster\nfrom lua.generate import GenerateLua\nfrom nim.generate import GenerateNim\nfrom php.generate import GeneratePhp\nfrom py.generate import GeneratePython\nfrom rust.generate import GenerateRust\nfrom swift.generate import GenerateSwift\nfrom ts.generate import GenerateTs\n\n# Run each language generation logic\nGenerateCpp()\nGenerateCSharp()\nGenerateDart()\nGenerateGo()\nGenerateJava()\nGenerateKotlin()\nGenerateLobster()\nGenerateLua()\nGenerateNim()\nGeneratePhp()\nGeneratePython()\nGenerateRust()\nGenerateSwift()\nGenerateTs()\n" }, { "path": "goldens/go/flatbuffers/goldens/Galaxy.go", "content": "// Code generated by the FlatBuffers compiler. DO NOT EDIT.\n\npackage goldens\n\nimport (\n\tflatbuffers \"github.com/google/flatbuffers/go\"\n)\n\ntype Galaxy struct {\n\t_tab flatbuffers.Table\n}\n\nfunc GetRootAsGalaxy(buf []byte, offset flatbuffers.UOffsetT) *Galaxy {\n\tn := flatbuffers.GetUOffsetT(buf[offset:])\n\tx := &Galaxy{}\n\tx.Init(buf, n+offset)\n\treturn x\n}\n\nfunc FinishGalaxyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {\n\tbuilder.Finish(offset)\n}\n\nfunc GetSizePrefixedRootAsGalaxy(buf []byte, offset flatbuffers.UOffsetT) *Galaxy {\n\tn := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])\n\tx := &Galaxy{}\n\tx.Init(buf, n+offset+flatbuffers.SizeUint32)\n\treturn x\n}\n\nfunc FinishSizePrefixedGalaxyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {\n\tbuilder.FinishSizePrefixed(offset)\n}\n\nfunc (rcv *Galaxy) Init(buf []byte, i flatbuffers.UOffsetT) {\n\trcv._tab.Bytes = buf\n\trcv._tab.Pos = i\n}\n\nfunc (rcv *Galaxy) Table() flatbuffers.Table {\n\treturn rcv._tab\n}\n\nfunc (rcv *Galaxy) NumStars() int64 {\n\to := flatbuffers.UOffsetT(rcv._tab.Offset(4))\n\tif o != 0 {\n\t\treturn rcv._tab.GetInt64(o + rcv._tab.Pos)\n\t}\n\treturn 0\n}\n\nfunc (rcv *Galaxy) MutateNumStars(n int64) bool {\n\treturn rcv._tab.MutateInt64Slot(4, n)\n}\n\nfunc GalaxyStart(builder *flatbuffers.Builder) {\n\tbuilder.StartObject(1)\n}\nfunc GalaxyAddNumStars(builder *flatbuffers.Builder, numStars int64) {\n\tbuilder.PrependInt64Slot(0, numStars, 0)\n}\nfunc GalaxyEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {\n\treturn builder.EndObject()\n}\n" }, { "path": "goldens/go/flatbuffers/goldens/Universe.go", "content": "// Code generated by the FlatBuffers compiler. DO NOT EDIT.\n\npackage goldens\n\nimport (\n\tflatbuffers \"github.com/google/flatbuffers/go\"\n)\n\ntype Universe struct {\n\t_tab flatbuffers.Table\n}\n\nfunc GetRootAsUniverse(buf []byte, offset flatbuffers.UOffsetT) *Universe {\n\tn := flatbuffers.GetUOffsetT(buf[offset:])\n\tx := &Universe{}\n\tx.Init(buf, n+offset)\n\treturn x\n}\n\nfunc FinishUniverseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {\n\tbuilder.Finish(offset)\n}\n\nfunc GetSizePrefixedRootAsUniverse(buf []byte, offset flatbuffers.UOffsetT) *Universe {\n\tn := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])\n\tx := &Universe{}\n\tx.Init(buf, n+offset+flatbuffers.SizeUint32)\n\treturn x\n}\n\nfunc FinishSizePrefixedUniverseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {\n\tbuilder.FinishSizePrefixed(offset)\n}\n\nfunc (rcv *Universe) Init(buf []byte, i flatbuffers.UOffsetT) {\n\trcv._tab.Bytes = buf\n\trcv._tab.Pos = i\n}\n\nfunc (rcv *Universe) Table() flatbuffers.Table {\n\treturn rcv._tab\n}\n\nfunc (rcv *Universe) Age() float64 {\n\to := flatbuffers.UOffsetT(rcv._tab.Offset(4))\n\tif o != 0 {\n\t\treturn rcv._tab.GetFloat64(o + rcv._tab.Pos)\n\t}\n\treturn 0.0\n}\n\nfunc (rcv *Universe) MutateAge(n float64) bool {\n\treturn rcv._tab.MutateFloat64Slot(4, n)\n}\n\nfunc (rcv *Universe) Galaxies(obj *Galaxy, j int) bool {\n\to := flatbuffers.UOffsetT(rcv._tab.Offset(6))\n\tif o != 0 {\n\t\tx := rcv._tab.Vector(o)\n\t\tx += flatbuffers.UOffsetT(j) * 4\n\t\tx = rcv._tab.Indirect(x)\n\t\tobj.Init(rcv._tab.Bytes, x)\n\t\treturn true\n\t}\n\treturn false\n}\n\nfunc (rcv *Universe) GalaxiesLength() int {\n\to := flatbuffers.UOffsetT(rcv._tab.Offset(6))\n\tif o != 0 {\n\t\treturn rcv._tab.VectorLen(o)\n\t}\n\treturn 0\n}\n\nfunc UniverseStart(builder *flatbuffers.Builder) {\n\tbuilder.StartObject(2)\n}\nfunc UniverseAddAge(builder *flatbuffers.Builder, age float64) {\n\tbuilder.PrependFloat64Slot(0, age, 0.0)\n}\nfunc UniverseAddGalaxies(builder *flatbuffers.Builder, galaxies flatbuffers.UOffsetT) {\n\tbuilder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(galaxies), 0)\n}\nfunc UniverseStartGalaxiesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {\n\treturn builder.StartVector(4, numElems, 4)\n}\nfunc UniverseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {\n\treturn builder.EndObject()\n}\n" }, { "path": "goldens/go/generate.py", "content": "from golden_utils import flatc_golden\n\n\ndef flatc(options, schema):\n # Wrap the golden flatc generator with Go specifics\n flatc_golden(options=[\"--go\"] + options, schema=schema, prefix=\"go\")\n\n\ndef GenerateGo():\n flatc([], \"basic.fbs\")\n" }, { "path": "goldens/golden_utils.py", "content": "from pathlib import Path\nimport sys\n\n# Get the path where this script is located so we can invoke the script from\n# any directory and have the paths work correctly.\nscript_path = Path(__file__).parent.resolve()\n\n# Get the root path as an absolute path, so all derived paths are absolute.\nroot_path = script_path.parent.absolute()\n\n# Get the location of the schema\nschema_path = Path(script_path, \"schema\")\n\n# Too add the util package in /scripts/util.py\nsys.path.append(str(root_path.absolute()))\n\nfrom scripts.util import flatc\n\n\ndef flatc_golden(options, schema, prefix):\n # wrap the generic flatc call with specifis for these goldens.\n flatc(\n options=options,\n # where the files are generated, typically the language (e.g. \"cpp\").\n prefix=prefix,\n # The schema are relative to the schema directory.\n schema=str(Path(schema_path, schema)),\n # Run flatc from this location.\n cwd=script_path,\n )\n" }, { "path": "goldens/java/flatbuffers/goldens/Galaxy.java", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n\npackage flatbuffers.goldens;\n\nimport com.google.flatbuffers.BaseVector;\nimport com.google.flatbuffers.BooleanVector;\nimport com.google.flatbuffers.ByteVector;\nimport com.google.flatbuffers.Constants;\nimport com.google.flatbuffers.DoubleVector;\nimport com.google.flatbuffers.FlatBufferBuilder;\nimport com.google.flatbuffers.FloatVector;\nimport com.google.flatbuffers.IntVector;\nimport com.google.flatbuffers.LongVector;\nimport com.google.flatbuffers.ShortVector;\nimport com.google.flatbuffers.StringVector;\nimport com.google.flatbuffers.Struct;\nimport com.google.flatbuffers.UnionVector;\nimport java.nio.ByteBuffer;\nimport java.nio.ByteOrder;\n\n@SuppressWarnings(\"unused\")\npublic final class Galaxy extends com.google.flatbuffers.Table {\n public static void ValidateVersion() { Constants.FLATBUFFERS_25_12_19(); }\n public static Galaxy getRootAsGalaxy(ByteBuffer _bb) { return getRootAsGalaxy(_bb, new Galaxy()); }\n public static Galaxy getRootAsGalaxy(ByteBuffer _bb, Galaxy obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }\n public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }\n public Galaxy __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }\n\n public long numStars() { int o = __offset(4); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }\n\n public static int createGalaxy(FlatBufferBuilder builder,\n long numStars) {\n builder.startTable(1);\n Galaxy.addNumStars(builder, numStars);\n return Galaxy.endGalaxy(builder);\n }\n\n public static void startGalaxy(FlatBufferBuilder builder) { builder.startTable(1); }\n public static void addNumStars(FlatBufferBuilder builder, long numStars) { builder.addLong(0, numStars, 0L); }\n public static int endGalaxy(FlatBufferBuilder builder) {\n int o = builder.endTable();\n return o;\n }\n\n public static final class Vector extends BaseVector {\n public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }\n\n public Galaxy get(int j) { return get(new Galaxy(), j); }\n public Galaxy get(Galaxy obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); }\n }\n}\n\n" }, { "path": "goldens/java/flatbuffers/goldens/Universe.java", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n\npackage flatbuffers.goldens;\n\nimport com.google.flatbuffers.BaseVector;\nimport com.google.flatbuffers.BooleanVector;\nimport com.google.flatbuffers.ByteVector;\nimport com.google.flatbuffers.Constants;\nimport com.google.flatbuffers.DoubleVector;\nimport com.google.flatbuffers.FlatBufferBuilder;\nimport com.google.flatbuffers.FloatVector;\nimport com.google.flatbuffers.IntVector;\nimport com.google.flatbuffers.LongVector;\nimport com.google.flatbuffers.ShortVector;\nimport com.google.flatbuffers.StringVector;\nimport com.google.flatbuffers.Struct;\nimport com.google.flatbuffers.UnionVector;\nimport java.nio.ByteBuffer;\nimport java.nio.ByteOrder;\n\n@SuppressWarnings(\"unused\")\npublic final class Universe extends com.google.flatbuffers.Table {\n public static void ValidateVersion() { Constants.FLATBUFFERS_25_12_19(); }\n public static Universe getRootAsUniverse(ByteBuffer _bb) { return getRootAsUniverse(_bb, new Universe()); }\n public static Universe getRootAsUniverse(ByteBuffer _bb, Universe obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }\n public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }\n public Universe __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }\n\n public double age() { int o = __offset(4); return o != 0 ? bb.getDouble(o + bb_pos) : 0.0; }\n public flatbuffers.goldens.Galaxy galaxies(int j) { return galaxies(new flatbuffers.goldens.Galaxy(), j); }\n public flatbuffers.goldens.Galaxy galaxies(flatbuffers.goldens.Galaxy obj, int j) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; }\n public int galaxiesLength() { int o = __offset(6); return o != 0 ? __vector_len(o) : 0; }\n public flatbuffers.goldens.Galaxy.Vector galaxiesVector() { return galaxiesVector(new flatbuffers.goldens.Galaxy.Vector()); }\n public flatbuffers.goldens.Galaxy.Vector galaxiesVector(flatbuffers.goldens.Galaxy.Vector obj) { int o = __offset(6); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }\n\n public static int createUniverse(FlatBufferBuilder builder,\n double age,\n int galaxiesOffset) {\n builder.startTable(2);\n Universe.addAge(builder, age);\n Universe.addGalaxies(builder, galaxiesOffset);\n return Universe.endUniverse(builder);\n }\n\n public static void startUniverse(FlatBufferBuilder builder) { builder.startTable(2); }\n public static void addAge(FlatBufferBuilder builder, double age) { builder.addDouble(0, age, 0.0); }\n public static void addGalaxies(FlatBufferBuilder builder, int galaxiesOffset) { builder.addOffset(1, galaxiesOffset, 0); }\n public static int createGalaxiesVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }\n public static void startGalaxiesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }\n public static int endUniverse(FlatBufferBuilder builder) {\n int o = builder.endTable();\n return o;\n }\n public static void finishUniverseBuffer(FlatBufferBuilder builder, int offset) { builder.finish(offset); }\n public static void finishSizePrefixedUniverseBuffer(FlatBufferBuilder builder, int offset) { builder.finishSizePrefixed(offset); }\n\n public static final class Vector extends BaseVector {\n public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }\n\n public Universe get(int j) { return get(new Universe(), j); }\n public Universe get(Universe obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); }\n }\n}\n\n" }, { "path": "goldens/java/generate.py", "content": "from golden_utils import flatc_golden\n\n\ndef flatc(options, schema):\n # Wrap the golden flatc generator with Java specifics\n flatc_golden(options=[\"--java\"] + options, schema=schema, prefix=\"java\")\n\n\ndef GenerateJava():\n flatc([], \"basic.fbs\")\n" }, { "path": "goldens/kotlin/flatbuffers/goldens/Galaxy.kt", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n\npackage flatbuffers.goldens\n\nimport com.google.flatbuffers.BaseVector\nimport com.google.flatbuffers.BooleanVector\nimport com.google.flatbuffers.ByteVector\nimport com.google.flatbuffers.Constants\nimport com.google.flatbuffers.DoubleVector\nimport com.google.flatbuffers.FlatBufferBuilder\nimport com.google.flatbuffers.FloatVector\nimport com.google.flatbuffers.LongVector\nimport com.google.flatbuffers.StringVector\nimport com.google.flatbuffers.Struct\nimport com.google.flatbuffers.Table\nimport com.google.flatbuffers.UnionVector\nimport java.nio.ByteBuffer\nimport java.nio.ByteOrder\nimport kotlin.math.sign\n\n@Suppress(\"unused\")\nclass Galaxy : Table() {\n\n fun __init(_i: Int, _bb: ByteBuffer) {\n __reset(_i, _bb)\n }\n fun __assign(_i: Int, _bb: ByteBuffer) : Galaxy {\n __init(_i, _bb)\n return this\n }\n val numStars : Long\n get() {\n val o = __offset(4)\n return if(o != 0) bb.getLong(o + bb_pos) else 0L\n }\n companion object {\n fun validateVersion() = Constants.FLATBUFFERS_25_12_19()\n fun getRootAsGalaxy(_bb: ByteBuffer): Galaxy = getRootAsGalaxy(_bb, Galaxy())\n fun getRootAsGalaxy(_bb: ByteBuffer, obj: Galaxy): Galaxy {\n _bb.order(ByteOrder.LITTLE_ENDIAN)\n return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))\n }\n fun createGalaxy(builder: FlatBufferBuilder, numStars: Long) : Int {\n builder.startTable(1)\n addNumStars(builder, numStars)\n return endGalaxy(builder)\n }\n fun startGalaxy(builder: FlatBufferBuilder) = builder.startTable(1)\n fun addNumStars(builder: FlatBufferBuilder, numStars: Long) = builder.addLong(0, numStars, 0L)\n fun endGalaxy(builder: FlatBufferBuilder) : Int {\n val o = builder.endTable()\n return o\n }\n }\n}\n" }, { "path": "goldens/kotlin/flatbuffers/goldens/Universe.kt", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n\npackage flatbuffers.goldens\n\nimport com.google.flatbuffers.BaseVector\nimport com.google.flatbuffers.BooleanVector\nimport com.google.flatbuffers.ByteVector\nimport com.google.flatbuffers.Constants\nimport com.google.flatbuffers.DoubleVector\nimport com.google.flatbuffers.FlatBufferBuilder\nimport com.google.flatbuffers.FloatVector\nimport com.google.flatbuffers.LongVector\nimport com.google.flatbuffers.StringVector\nimport com.google.flatbuffers.Struct\nimport com.google.flatbuffers.Table\nimport com.google.flatbuffers.UnionVector\nimport java.nio.ByteBuffer\nimport java.nio.ByteOrder\nimport kotlin.math.sign\n\n@Suppress(\"unused\")\nclass Universe : Table() {\n\n fun __init(_i: Int, _bb: ByteBuffer) {\n __reset(_i, _bb)\n }\n fun __assign(_i: Int, _bb: ByteBuffer) : Universe {\n __init(_i, _bb)\n return this\n }\n val age : Double\n get() {\n val o = __offset(4)\n return if(o != 0) bb.getDouble(o + bb_pos) else 0.0\n }\n fun galaxies(j: Int) : flatbuffers.goldens.Galaxy? = galaxies(flatbuffers.goldens.Galaxy(), j)\n fun galaxies(obj: flatbuffers.goldens.Galaxy, j: Int) : flatbuffers.goldens.Galaxy? {\n val o = __offset(6)\n return if (o != 0) {\n obj.__assign(__indirect(__vector(o) + j * 4), bb)\n } else {\n null\n }\n }\n val galaxiesLength : Int\n get() {\n val o = __offset(6); return if (o != 0) __vector_len(o) else 0\n }\n companion object {\n fun validateVersion() = Constants.FLATBUFFERS_25_12_19()\n fun getRootAsUniverse(_bb: ByteBuffer): Universe = getRootAsUniverse(_bb, Universe())\n fun getRootAsUniverse(_bb: ByteBuffer, obj: Universe): Universe {\n _bb.order(ByteOrder.LITTLE_ENDIAN)\n return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))\n }\n fun createUniverse(builder: FlatBufferBuilder, age: Double, galaxiesOffset: Int) : Int {\n builder.startTable(2)\n addAge(builder, age)\n addGalaxies(builder, galaxiesOffset)\n return endUniverse(builder)\n }\n fun startUniverse(builder: FlatBufferBuilder) = builder.startTable(2)\n fun addAge(builder: FlatBufferBuilder, age: Double) = builder.addDouble(0, age, 0.0)\n fun addGalaxies(builder: FlatBufferBuilder, galaxies: Int) = builder.addOffset(1, galaxies, 0)\n fun createGalaxiesVector(builder: FlatBufferBuilder, data: IntArray) : Int {\n builder.startVector(4, data.size, 4)\n for (i in data.size - 1 downTo 0) {\n builder.addOffset(data[i])\n }\n return builder.endVector()\n }\n fun startGalaxiesVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4)\n fun endUniverse(builder: FlatBufferBuilder) : Int {\n val o = builder.endTable()\n return o\n }\n fun finishUniverseBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finish(offset)\n fun finishSizePrefixedUniverseBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finishSizePrefixed(offset)\n }\n}\n" }, { "path": "goldens/kotlin/generate.py", "content": "from golden_utils import flatc_golden\n\n\ndef flatc(options, schema):\n # Wrap the golden flatc generator with Kotlin specifics\n flatc_golden(options=[\"--kotlin\"] + options, schema=schema, prefix=\"kotlin\")\n\n\ndef GenerateKotlin():\n flatc([], \"basic.fbs\")\n" }, { "path": "goldens/lobster/basic_generated.lobster", "content": "// automatically generated by the FlatBuffers compiler, do not modify\nimport flatbuffers\n\nnamespace flatbuffers.goldens\n\nclass Galaxy\n\nclass Universe\n\nclass Galaxy : flatbuffers.handle\n def num_stars() -> int:\n return flatbuffers.field_int64(buf_, pos_, 4, 0)\n\ndef GetRootAsGalaxy(buf:string): return Galaxy { buf, flatbuffers.indirect(buf, 0) }\n\nstruct GalaxyBuilder:\n b_:flatbuffers.builder\n def start():\n b_.StartObject(1)\n return this\n def add_num_stars(num_stars:int):\n b_.PrependInt64Slot(0, num_stars, 0)\n return this\n def end():\n return b_.EndObject()\n\nclass Universe : flatbuffers.handle\n def age() -> float:\n return flatbuffers.field_float64(buf_, pos_, 4, 0.0)\n def galaxies(i:int) -> flatbuffers.goldens.Galaxy:\n return flatbuffers.goldens.Galaxy { buf_, flatbuffers.indirect(buf_, flatbuffers.field_vector(buf_, pos_, 6) + i * 4) }\n def galaxies_length() -> int:\n return flatbuffers.field_vector_len(buf_, pos_, 6)\n\ndef GetRootAsUniverse(buf:string): return Universe { buf, flatbuffers.indirect(buf, 0) }\n\nstruct UniverseBuilder:\n b_:flatbuffers.builder\n def start():\n b_.StartObject(2)\n return this\n def add_age(age:float):\n b_.PrependFloat64Slot(0, age, 0.0)\n return this\n def add_galaxies(galaxies:flatbuffers.offset):\n b_.PrependUOffsetTRelativeSlot(1, galaxies)\n return this\n def end():\n return b_.EndObject()\n\ndef UniverseStartGalaxiesVector(b_:flatbuffers.builder, n_:int):\n b_.StartVector(4, n_, 4)\ndef UniverseCreateGalaxiesVector(b_:flatbuffers.builder, v_:[flatbuffers.offset]):\n b_.StartVector(4, v_.length, 4)\n reverse(v_) e_: b_.PrependUOffsetTRelative(e_)\n return b_.EndVector(v_.length)\n\n" }, { "path": "goldens/lobster/generate.py", "content": "from golden_utils import flatc_golden\n\n\ndef flatc(options, schema):\n # Wrap the golden flatc generator with Lobster specifics\n flatc_golden(options=[\"--lobster\"] + options, schema=schema, prefix=\"lobster\")\n\n\ndef GenerateLobster():\n flatc([], \"basic.fbs\")\n" }, { "path": "goldens/lua/Galaxy.lua", "content": "--[[ Galaxy\n\n Automatically generated by the FlatBuffers compiler, do not modify.\n Or modify. I'm a message, not a cop.\n\n flatc version: 23.5.26\n\n Declared by : //basic.fbs\n Rooting type : Universe (//basic.fbs)\n\n--]]\n\nlocal flatbuffers = require('flatbuffers')\n\nlocal Galaxy = {}\nlocal mt = {}\n\nfunction Galaxy.New()\n local o = {}\n setmetatable(o, {__index = mt})\n return o\nend\n\nfunction mt:Init(buf, pos)\n self.view = flatbuffers.view.New(buf, pos)\nend\n\nfunction mt:NumStars()\n local o = self.view:Offset(4)\n if o ~= 0 then\n return self.view:Get(flatbuffers.N.Int64, self.view.pos + o)\n end\n return 0\nend\n\nfunction Galaxy.Start(builder)\n builder:StartObject(1)\nend\n\nfunction Galaxy.AddNumStars(builder, numStars)\n builder:PrependInt64Slot(0, numStars, 0)\nend\n\nfunction Galaxy.End(builder)\n return builder:EndObject()\nend\n\nreturn Galaxy" }, { "path": "goldens/lua/Universe.lua", "content": "--[[ Universe\n\n Automatically generated by the FlatBuffers compiler, do not modify.\n Or modify. I'm a message, not a cop.\n\n flatc version: 23.5.26\n\n Declared by : //basic.fbs\n Rooting type : Universe (//basic.fbs)\n\n--]]\n\nlocal __Galaxy = require('Galaxy')\nlocal flatbuffers = require('flatbuffers')\n\nlocal Universe = {}\nlocal mt = {}\n\nfunction Universe.New()\n local o = {}\n setmetatable(o, {__index = mt})\n return o\nend\n\nfunction Universe.GetRootAsUniverse(buf, offset)\n if type(buf) == \"string\" then\n buf = flatbuffers.binaryArray.New(buf)\n end\n\n local n = flatbuffers.N.UOffsetT:Unpack(buf, offset)\n local o = Universe.New()\n o:Init(buf, n + offset)\n return o\nend\n\nfunction mt:Init(buf, pos)\n self.view = flatbuffers.view.New(buf, pos)\nend\n\nfunction mt:Age()\n local o = self.view:Offset(4)\n if o ~= 0 then\n return self.view:Get(flatbuffers.N.Float64, self.view.pos + o)\n end\n return 0.0\nend\n\nfunction mt:Galaxies(j)\n local o = self.view:Offset(6)\n if o ~= 0 then\n local x = self.view:Vector(o)\n x = x + ((j-1) * 4)\n x = self.view:Indirect(x)\n local obj = __Galaxy.New()\n obj:Init(self.view.bytes, x)\n return obj\n end\nend\n\nfunction mt:GalaxiesLength()\n local o = self.view:Offset(6)\n if o ~= 0 then\n return self.view:VectorLen(o)\n end\n return 0\nend\n\nfunction Universe.Start(builder)\n builder:StartObject(2)\nend\n\nfunction Universe.AddAge(builder, age)\n builder:PrependFloat64Slot(0, age, 0.0)\nend\n\nfunction Universe.AddGalaxies(builder, galaxies)\n builder:PrependUOffsetTRelativeSlot(1, galaxies, 0)\nend\n\nfunction Universe.StartGalaxiesVector(builder, numElems)\n return builder:StartVector(4, numElems, 4)\nend\n\nfunction Universe.End(builder)\n return builder:EndObject()\nend\n\nreturn Universe" }, { "path": "goldens/lua/generate.py", "content": "from golden_utils import flatc_golden\n\n\ndef flatc(options, schema):\n # Wrap the golden flatc generator with Lua specifics\n flatc_golden(options=[\"--lua\"] + options, schema=schema, prefix=\"lua\")\n\n\ndef GenerateLua():\n flatc([], \"basic.fbs\")\n" }, { "path": "goldens/nim/Galaxy.nim", "content": "#[ Galaxy\n Automatically generated by the FlatBuffers compiler, do not modify.\n Or modify. I'm a message, not a cop.\n\n flatc version: 23.5.26\n\n Declared by : //basic.fbs\n Rooting type : Universe (//basic.fbs)\n]#\n\nimport flatbuffers\n\ntype Galaxy* = object of FlatObj\nfunc numStars*(self: Galaxy): int64 =\n let o = self.tab.Offset(4)\n if o != 0:\n return Get[int64](self.tab, self.tab.Pos + o)\n return 0\nfunc `numStars=`*(self: var Galaxy, n: int64): bool =\n return self.tab.MutateSlot(4, n)\nproc GalaxyStart*(builder: var Builder) =\n builder.StartObject(1)\nproc GalaxyAddnumStars*(builder: var Builder, numStars: int64) =\n builder.PrependSlot(0, numStars, default(int64))\nproc GalaxyEnd*(builder: var Builder): uoffset =\n return builder.EndObject()\n" }, { "path": "goldens/nim/Universe.nim", "content": "#[ Universe\n Automatically generated by the FlatBuffers compiler, do not modify.\n Or modify. I'm a message, not a cop.\n\n flatc version: 23.5.26\n\n Declared by : //basic.fbs\n Rooting type : Universe (//basic.fbs)\n]#\n\nimport Galaxy as Galaxy\nimport flatbuffers\nimport std/options\n\ntype Universe* = object of FlatObj\nfunc age*(self: Universe): float64 =\n let o = self.tab.Offset(4)\n if o != 0:\n return Get[float64](self.tab, self.tab.Pos + o)\n return 0.0\nfunc `age=`*(self: var Universe, n: float64): bool =\n return self.tab.MutateSlot(4, n)\nfunc galaxiesLength*(self: Universe): int = \n let o = self.tab.Offset(6)\n if o != 0:\n return self.tab.VectorLen(o)\nfunc galaxies*(self: Universe, j: int): Galaxy.Galaxy = \n let o = self.tab.Offset(6)\n if o != 0:\n var x = self.tab.Vector(o)\n x += j.uoffset * 4.uoffset\n return Galaxy.Galaxy(tab: Vtable(Bytes: self.tab.Bytes, Pos: x))\nfunc galaxies*(self: Universe): seq[Galaxy.Galaxy] = \n let len = self.galaxiesLength\n for i in countup(0, len - 1):\n result.add(self.galaxies(i))\nproc UniverseStart*(builder: var Builder) =\n builder.StartObject(2)\nproc UniverseAddage*(builder: var Builder, age: float64) =\n builder.PrependSlot(0, age, default(float64))\nproc UniverseAddgalaxies*(builder: var Builder, galaxies: uoffset) =\n builder.PrependSlot(1, galaxies, default(uoffset))\nproc UniverseStartgalaxiesVector*(builder: var Builder, numElems: uoffset) =\n builder.StartVector(4, numElems, 4)\nproc UniverseEnd*(builder: var Builder): uoffset =\n return builder.EndObject()\n" }, { "path": "goldens/nim/generate.py", "content": "from golden_utils import flatc_golden\n\n\ndef flatc(options, schema):\n # Wrap the golden flatc generator with Nim specifics\n flatc_golden(options=[\"--nim\"] + options, schema=schema, prefix=\"nim\")\n\n\ndef GenerateNim():\n flatc([], \"basic.fbs\")\n" }, { "path": "goldens/php/flatbuffers/goldens/Galaxy.php", "content": "init($bb->getInt($bb->getPosition()) + $bb->getPosition(), $bb));\n }\n\n /**\n * @param int $_i offset\n * @param ByteBuffer $_bb\n * @return Galaxy\n **/\n public function init($_i, ByteBuffer $_bb)\n {\n $this->bb_pos = $_i;\n $this->bb = $_bb;\n return $this;\n }\n\n /**\n * @return long\n */\n public function getNumStars()\n {\n $o = $this->__offset(4);\n return $o != 0 ? $this->bb->getLong($o + $this->bb_pos) : 0;\n }\n\n /**\n * @param FlatBufferBuilder $builder\n * @return void\n */\n public static function startGalaxy(FlatBufferBuilder $builder)\n {\n $builder->StartObject(1);\n }\n\n /**\n * @param FlatBufferBuilder $builder\n * @return Galaxy\n */\n public static function createGalaxy(FlatBufferBuilder $builder, $num_stars)\n {\n $builder->startObject(1);\n self::addNumStars($builder, $num_stars);\n $o = $builder->endObject();\n return $o;\n }\n\n /**\n * @param FlatBufferBuilder $builder\n * @param long\n * @return void\n */\n public static function addNumStars(FlatBufferBuilder $builder, $numStars)\n {\n $builder->addLongX(0, $numStars, 0);\n }\n\n /**\n * @param FlatBufferBuilder $builder\n * @return int table offset\n */\n public static function endGalaxy(FlatBufferBuilder $builder)\n {\n $o = $builder->endObject();\n return $o;\n }\n}\n" }, { "path": "goldens/php/flatbuffers/goldens/Universe.php", "content": "init($bb->getInt($bb->getPosition()) + $bb->getPosition(), $bb));\n }\n\n /**\n * @param int $_i offset\n * @param ByteBuffer $_bb\n * @return Universe\n **/\n public function init($_i, ByteBuffer $_bb)\n {\n $this->bb_pos = $_i;\n $this->bb = $_bb;\n return $this;\n }\n\n /**\n * @return double\n */\n public function getAge()\n {\n $o = $this->__offset(4);\n return $o != 0 ? $this->bb->getDouble($o + $this->bb_pos) : 0.0;\n }\n\n /**\n * @returnVectorOffset\n */\n public function getGalaxies($j)\n {\n $o = $this->__offset(6);\n $obj = new Galaxy();\n return $o != 0 ? $obj->init($this->__indirect($this->__vector($o) + $j * 4), $this->bb) : null;\n }\n\n /**\n * @return int\n */\n public function getGalaxiesLength()\n {\n $o = $this->__offset(6);\n return $o != 0 ? $this->__vector_len($o) : 0;\n }\n\n /**\n * @param FlatBufferBuilder $builder\n * @return void\n */\n public static function startUniverse(FlatBufferBuilder $builder)\n {\n $builder->StartObject(2);\n }\n\n /**\n * @param FlatBufferBuilder $builder\n * @return Universe\n */\n public static function createUniverse(FlatBufferBuilder $builder, $age, $galaxies)\n {\n $builder->startObject(2);\n self::addAge($builder, $age);\n self::addGalaxies($builder, $galaxies);\n $o = $builder->endObject();\n return $o;\n }\n\n /**\n * @param FlatBufferBuilder $builder\n * @param double\n * @return void\n */\n public static function addAge(FlatBufferBuilder $builder, $age)\n {\n $builder->addDoubleX(0, $age, 0.0);\n }\n\n /**\n * @param FlatBufferBuilder $builder\n * @param VectorOffset\n * @return void\n */\n public static function addGalaxies(FlatBufferBuilder $builder, $galaxies)\n {\n $builder->addOffsetX(1, $galaxies, 0);\n }\n\n /**\n * @param FlatBufferBuilder $builder\n * @param array offset array\n * @return int vector offset\n */\n public static function createGalaxiesVector(FlatBufferBuilder $builder, array $data)\n {\n $builder->startVector(4, count($data), 4);\n for ($i = count($data) - 1; $i >= 0; $i--) {\n $builder->putOffset($data[$i]);\n }\n return $builder->endVector();\n }\n\n /**\n * @param FlatBufferBuilder $builder\n * @param int $numElems\n * @return void\n */\n public static function startGalaxiesVector(FlatBufferBuilder $builder, $numElems)\n {\n $builder->startVector(4, $numElems, 4);\n }\n\n /**\n * @param FlatBufferBuilder $builder\n * @return int table offset\n */\n public static function endUniverse(FlatBufferBuilder $builder)\n {\n $o = $builder->endObject();\n return $o;\n }\n\n public static function finishUniverseBuffer(FlatBufferBuilder $builder, $offset)\n {\n $builder->finish($offset);\n }\n}\n" }, { "path": "goldens/php/generate.py", "content": "from golden_utils import flatc_golden\n\n\ndef flatc(options, schema):\n # Wrap the golden flatc generator with PHP specifics\n flatc_golden(options=[\"--php\"] + options, schema=schema, prefix=\"php\")\n\n\ndef GeneratePhp():\n flatc([], \"basic.fbs\")\n" }, { "path": "goldens/py/__init__.py", "content": "" }, { "path": "goldens/py/flatbuffers/__init__.py", "content": "" }, { "path": "goldens/py/flatbuffers/goldens/Galaxy.py", "content": "# automatically generated by the FlatBuffers compiler, do not modify\n\n# namespace: goldens\n\nimport flatbuffers\nfrom flatbuffers.compat import import_numpy\nnp = import_numpy()\n\nclass Galaxy(object):\n __slots__ = ['_tab']\n\n @classmethod\n def GetRootAs(cls, buf, offset=0):\n n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)\n x = Galaxy()\n x.Init(buf, n + offset)\n return x\n\n @classmethod\n def GetRootAsGalaxy(cls, buf, offset=0):\n \"\"\"This method is deprecated. Please switch to GetRootAs.\"\"\"\n return cls.GetRootAs(buf, offset)\n # Galaxy\n def Init(self, buf, pos):\n self._tab = flatbuffers.table.Table(buf, pos)\n\n # Galaxy\n def NumStars(self):\n o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))\n if o != 0:\n return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)\n return 0\n\ndef GalaxyStart(builder):\n builder.StartObject(1)\n\ndef Start(builder):\n GalaxyStart(builder)\n\ndef GalaxyAddNumStars(builder, numStars):\n builder.PrependInt64Slot(0, numStars, 0)\n\ndef AddNumStars(builder, numStars):\n GalaxyAddNumStars(builder, numStars)\n\ndef GalaxyEnd(builder):\n return builder.EndObject()\n\ndef End(builder):\n return GalaxyEnd(builder)\n" }, { "path": "goldens/py/flatbuffers/goldens/Universe.py", "content": "# automatically generated by the FlatBuffers compiler, do not modify\n\n# namespace: goldens\n\nimport flatbuffers\nfrom flatbuffers.compat import import_numpy\nnp = import_numpy()\n\nclass Universe(object):\n __slots__ = ['_tab']\n\n @classmethod\n def GetRootAs(cls, buf, offset=0):\n n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)\n x = Universe()\n x.Init(buf, n + offset)\n return x\n\n @classmethod\n def GetRootAsUniverse(cls, buf, offset=0):\n \"\"\"This method is deprecated. Please switch to GetRootAs.\"\"\"\n return cls.GetRootAs(buf, offset)\n # Universe\n def Init(self, buf, pos):\n self._tab = flatbuffers.table.Table(buf, pos)\n\n # Universe\n def Age(self):\n o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))\n if o != 0:\n return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)\n return 0.0\n\n # Universe\n def Galaxies(self, j):\n o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))\n if o != 0:\n x = self._tab.Vector(o)\n x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4\n x = self._tab.Indirect(x)\n from flatbuffers.goldens.Galaxy import Galaxy\n obj = Galaxy()\n obj.Init(self._tab.Bytes, x)\n return obj\n return None\n\n # Universe\n def GalaxiesLength(self):\n o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))\n if o != 0:\n return self._tab.VectorLen(o)\n return 0\n\n # Universe\n def GalaxiesIsNone(self):\n o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))\n return o == 0\n\ndef UniverseStart(builder):\n builder.StartObject(2)\n\ndef Start(builder):\n UniverseStart(builder)\n\ndef UniverseAddAge(builder, age):\n builder.PrependFloat64Slot(0, age, 0.0)\n\ndef AddAge(builder, age):\n UniverseAddAge(builder, age)\n\ndef UniverseAddGalaxies(builder, galaxies):\n builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(galaxies), 0)\n\ndef AddGalaxies(builder, galaxies):\n UniverseAddGalaxies(builder, galaxies)\n\ndef UniverseStartGalaxiesVector(builder, numElems):\n return builder.StartVector(4, numElems, 4)\n\ndef StartGalaxiesVector(builder, numElems):\n return UniverseStartGalaxiesVector(builder, numElems)\n\ndef UniverseCreateGalaxiesVector(builder, data):\n return builder.CreateVectorOfTables(data)\n\ndef CreateGalaxiesVector(builder, data):\n UniverseCreateGalaxiesVector(builder, data)\n\ndef UniverseEnd(builder):\n return builder.EndObject()\n\ndef End(builder):\n return UniverseEnd(builder)\n" }, { "path": "goldens/py/flatbuffers/goldens/__init__.py", "content": "" }, { "path": "goldens/py/generate.py", "content": "from golden_utils import flatc_golden\n\n\ndef flatc(options, schema):\n # Wrap the golden flatc generator with Python specifics\n flatc_golden(options=[\"--python\"] + options, schema=schema, prefix=\"py\")\n\n\ndef GeneratePython():\n flatc([], \"basic.fbs\")\n" }, { "path": "goldens/rust/basic_generated.rs", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n// @generated\nextern crate alloc;\n\n#[allow(unused_imports, dead_code)]\npub mod flatbuffers {\n extern crate alloc;\n\n #[allow(unused_imports, dead_code)]\n pub mod goldens {\n extern crate alloc;\n\n pub enum GalaxyOffset {}\n\n #[derive(Copy, Clone, PartialEq)]\n pub struct Galaxy<'a> {\n pub _tab: ::flatbuffers::Table<'a>,\n }\n\n impl<'a> ::flatbuffers::Follow<'a> for Galaxy<'a> {\n type Inner = Galaxy<'a>;\n\n #[inline]\n unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {\n Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }\n }\n }\n\n impl<'a> Galaxy<'a> {\n pub const VT_NUM_STARS: ::flatbuffers::VOffsetT = 4;\n\n #[inline]\n pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {\n Galaxy { _tab: table }\n }\n\n #[allow(unused_mut)]\n pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(\n _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,\n args: &'args GalaxyArgs\n ) -> ::flatbuffers::WIPOffset> {\n let mut builder = GalaxyBuilder::new(_fbb);\n builder.add_num_stars(args.num_stars);\n builder.finish()\n }\n\n\n #[inline]\n pub fn num_stars(&self) -> i64 {\n // Safety:\n // Created from valid Table for this object\n // which contains a valid value in this slot\n unsafe { self._tab.get::(Galaxy::VT_NUM_STARS, Some(0)).unwrap()}\n }\n }\n\n impl ::flatbuffers::Verifiable for Galaxy<'_> {\n #[inline]\n fn run_verifier(\n v: &mut ::flatbuffers::Verifier, pos: usize\n ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {\n v.visit_table(pos)?\n .visit_field::(\"num_stars\", Self::VT_NUM_STARS, false)?\n .finish();\n Ok(())\n }\n }\n\n pub struct GalaxyArgs {\n pub num_stars: i64,\n }\n\n impl<'a> Default for GalaxyArgs {\n #[inline]\n fn default() -> Self {\n GalaxyArgs {\n num_stars: 0,\n }\n }\n }\n\n pub struct GalaxyBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {\n fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,\n start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,\n }\n\n impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GalaxyBuilder<'a, 'b, A> {\n #[inline]\n pub fn add_num_stars(&mut self, num_stars: i64) {\n self.fbb_.push_slot::(Galaxy::VT_NUM_STARS, num_stars, 0);\n }\n\n #[inline]\n pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> GalaxyBuilder<'a, 'b, A> {\n let start = _fbb.start_table();\n GalaxyBuilder {\n fbb_: _fbb,\n start_: start,\n }\n }\n\n #[inline]\n pub fn finish(self) -> ::flatbuffers::WIPOffset> {\n let o = self.fbb_.end_table(self.start_);\n ::flatbuffers::WIPOffset::new(o.value())\n }\n }\n\n impl ::core::fmt::Debug for Galaxy<'_> {\n fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {\n let mut ds = f.debug_struct(\"Galaxy\");\n ds.field(\"num_stars\", &self.num_stars());\n ds.finish()\n }\n }\n\n pub enum UniverseOffset {}\n\n #[derive(Copy, Clone, PartialEq)]\n pub struct Universe<'a> {\n pub _tab: ::flatbuffers::Table<'a>,\n }\n\n impl<'a> ::flatbuffers::Follow<'a> for Universe<'a> {\n type Inner = Universe<'a>;\n\n #[inline]\n unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {\n Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }\n }\n }\n\n impl<'a> Universe<'a> {\n pub const VT_AGE: ::flatbuffers::VOffsetT = 4;\n pub const VT_GALAXIES: ::flatbuffers::VOffsetT = 6;\n\n #[inline]\n pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {\n Universe { _tab: table }\n }\n\n #[allow(unused_mut)]\n pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(\n _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,\n args: &'args UniverseArgs<'args>\n ) -> ::flatbuffers::WIPOffset> {\n let mut builder = UniverseBuilder::new(_fbb);\n builder.add_age(args.age);\n if let Some(x) = args.galaxies { builder.add_galaxies(x); }\n builder.finish()\n }\n\n\n #[inline]\n pub fn age(&self) -> f64 {\n // Safety:\n // Created from valid Table for this object\n // which contains a valid value in this slot\n unsafe { self._tab.get::(Universe::VT_AGE, Some(0.0)).unwrap()}\n }\n\n #[inline]\n pub fn galaxies(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>> {\n // Safety:\n // Created from valid Table for this object\n // which contains a valid value in this slot\n unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>(Universe::VT_GALAXIES, None)}\n }\n }\n\n impl ::flatbuffers::Verifiable for Universe<'_> {\n #[inline]\n fn run_verifier(\n v: &mut ::flatbuffers::Verifier, pos: usize\n ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {\n v.visit_table(pos)?\n .visit_field::(\"age\", Self::VT_AGE, false)?\n .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset>>>(\"galaxies\", Self::VT_GALAXIES, false)?\n .finish();\n Ok(())\n }\n }\n\n pub struct UniverseArgs<'a> {\n pub age: f64,\n pub galaxies: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset>>>>,\n }\n\n impl<'a> Default for UniverseArgs<'a> {\n #[inline]\n fn default() -> Self {\n UniverseArgs {\n age: 0.0,\n galaxies: None,\n }\n }\n }\n\n pub struct UniverseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {\n fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,\n start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,\n }\n\n impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UniverseBuilder<'a, 'b, A> {\n #[inline]\n pub fn add_age(&mut self, age: f64) {\n self.fbb_.push_slot::(Universe::VT_AGE, age, 0.0);\n }\n\n #[inline]\n pub fn add_galaxies(&mut self, galaxies: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset>>>) {\n self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Universe::VT_GALAXIES, galaxies);\n }\n\n #[inline]\n pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> UniverseBuilder<'a, 'b, A> {\n let start = _fbb.start_table();\n UniverseBuilder {\n fbb_: _fbb,\n start_: start,\n }\n }\n\n #[inline]\n pub fn finish(self) -> ::flatbuffers::WIPOffset> {\n let o = self.fbb_.end_table(self.start_);\n ::flatbuffers::WIPOffset::new(o.value())\n }\n }\n\n impl ::core::fmt::Debug for Universe<'_> {\n fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {\n let mut ds = f.debug_struct(\"Universe\");\n ds.field(\"age\", &self.age());\n ds.field(\"galaxies\", &self.galaxies());\n ds.finish()\n }\n }\n\n /// Verifies that a buffer of bytes contains a `Universe`\n /// and returns it.\n /// Note that verification is still experimental and may not\n /// catch every error, or be maximally performant. For the\n /// previous, unchecked, behavior use\n /// `root_as_universe_unchecked`.\n #[inline]\n pub fn root_as_universe(buf: &[u8]) -> Result, ::flatbuffers::InvalidFlatbuffer> {\n ::flatbuffers::root::(buf)\n }\n\n /// Verifies that a buffer of bytes contains a size prefixed\n /// `Universe` and returns it.\n /// Note that verification is still experimental and may not\n /// catch every error, or be maximally performant. For the\n /// previous, unchecked, behavior use\n /// `size_prefixed_root_as_universe_unchecked`.\n #[inline]\n pub fn size_prefixed_root_as_universe(buf: &[u8]) -> Result, ::flatbuffers::InvalidFlatbuffer> {\n ::flatbuffers::size_prefixed_root::(buf)\n }\n\n /// Verifies, with the given options, that a buffer of bytes\n /// contains a `Universe` and returns it.\n /// Note that verification is still experimental and may not\n /// catch every error, or be maximally performant. For the\n /// previous, unchecked, behavior use\n /// `root_as_universe_unchecked`.\n #[inline]\n pub fn root_as_universe_with_opts<'b, 'o>(\n opts: &'o ::flatbuffers::VerifierOptions,\n buf: &'b [u8],\n ) -> Result, ::flatbuffers::InvalidFlatbuffer> {\n ::flatbuffers::root_with_opts::>(opts, buf)\n }\n\n /// Verifies, with the given verifier options, that a buffer of\n /// bytes contains a size prefixed `Universe` and returns\n /// it. Note that verification is still experimental and may not\n /// catch every error, or be maximally performant. For the\n /// previous, unchecked, behavior use\n /// `root_as_universe_unchecked`.\n #[inline]\n pub fn size_prefixed_root_as_universe_with_opts<'b, 'o>(\n opts: &'o ::flatbuffers::VerifierOptions,\n buf: &'b [u8],\n ) -> Result, ::flatbuffers::InvalidFlatbuffer> {\n ::flatbuffers::size_prefixed_root_with_opts::>(opts, buf)\n }\n\n /// Assumes, without verification, that a buffer of bytes contains a Universe and returns it.\n /// # Safety\n /// Callers must trust the given bytes do indeed contain a valid `Universe`.\n #[inline]\n pub unsafe fn root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> {\n unsafe { ::flatbuffers::root_unchecked::(buf) }\n }\n\n /// Assumes, without verification, that a buffer of bytes contains a size prefixed Universe and returns it.\n /// # Safety\n /// Callers must trust the given bytes do indeed contain a valid size prefixed `Universe`.\n #[inline]\n pub unsafe fn size_prefixed_root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> {\n unsafe { ::flatbuffers::size_prefixed_root_unchecked::(buf) }\n }\n\n #[inline]\n pub fn finish_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(\n fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,\n root: ::flatbuffers::WIPOffset>\n ) {\n fbb.finish(root, None);\n }\n\n #[inline]\n pub fn finish_size_prefixed_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(\n fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,\n root: ::flatbuffers::WIPOffset>\n ) {\n fbb.finish_size_prefixed(root, None);\n }\n } // pub mod goldens\n} // pub mod flatbuffers\n" }, { "path": "goldens/rust/generate.py", "content": "from golden_utils import flatc_golden\n\n\ndef flatc(options, schema):\n # Wrap the golden flatc generator with Rust specifics\n flatc_golden(options=[\"--rust\"] + options, schema=schema, prefix=\"rust\")\n\n\ndef GenerateRust():\n flatc([], \"basic.fbs\")\n" }, { "path": "goldens/schema/basic.fbs", "content": "// This file should contain the basics of flatbuffers that all languages should\n// support.\n\nnamespace flatbuffers.goldens;\n\ntable Galaxy {\n num_stars:long;\n}\n\ntable Universe {\n age:double;\n galaxies:[Galaxy];\n}\n\nroot_type Universe;" }, { "path": "goldens/swift/__init__.py", "content": "" }, { "path": "goldens/swift/basic_generated.swift", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n// swiftlint:disable all\n// swiftformat:disable all\n\n#if canImport(Common)\nimport Common\n#endif\n\nimport FlatBuffers\n\npublic struct flatbuffers_goldens_Galaxy: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable {\n\n static func validateVersion() { FlatBuffersVersion_25_12_19() }\n public var __buffer: ByteBuffer! { return _accessor.bb }\n private var _accessor: Table\n\n private init(_ t: Table) { _accessor = t }\n public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }\n\n private enum VTOFFSET: VOffset {\n case numStars = 4\n var v: Int32 { Int32(self.rawValue) }\n var p: VOffset { self.rawValue }\n }\n\n public var numStars: Int64 { let o = _accessor.offset(VTOFFSET.numStars.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }\n public static func startGalaxy(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }\n public static func add(numStars: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: numStars, def: 0, at: VTOFFSET.numStars.p) }\n public static func endGalaxy(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }\n public static func createGalaxy(\n _ fbb: inout FlatBufferBuilder,\n numStars: Int64 = 0\n ) -> Offset {\n let __start = flatbuffers_goldens_Galaxy.startGalaxy(&fbb)\n flatbuffers_goldens_Galaxy.add(numStars: numStars, &fbb)\n return flatbuffers_goldens_Galaxy.endGalaxy(&fbb, start: __start)\n }\n\n public static func verify(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {\n var _v = try verifier.visitTable(at: position)\n try _v.visit(field: VTOFFSET.numStars.p, fieldName: \"numStars\", required: false, type: Int64.self)\n _v.finish()\n }\n}\n\npublic struct flatbuffers_goldens_Universe: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable {\n\n static func validateVersion() { FlatBuffersVersion_25_12_19() }\n public var __buffer: ByteBuffer! { return _accessor.bb }\n private var _accessor: Table\n\n private init(_ t: Table) { _accessor = t }\n public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }\n\n private enum VTOFFSET: VOffset {\n case age = 4\n case galaxies = 6\n var v: Int32 { Int32(self.rawValue) }\n var p: VOffset { self.rawValue }\n }\n\n public var age: Double { let o = _accessor.offset(VTOFFSET.age.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }\n public var galaxies: FlatbufferVector { return _accessor.vector(at: VTOFFSET.galaxies.v, byteSize: 4) }\n public static func startUniverse(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 2) }\n public static func add(age: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: age, def: 0.0, at: VTOFFSET.age.p) }\n public static func addVectorOf(galaxies: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: galaxies, at: VTOFFSET.galaxies.p) }\n public static func endUniverse(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }\n public static func createUniverse(\n _ fbb: inout FlatBufferBuilder,\n age: Double = 0.0,\n galaxiesVectorOffset galaxies: Offset = Offset()\n ) -> Offset {\n let __start = flatbuffers_goldens_Universe.startUniverse(&fbb)\n flatbuffers_goldens_Universe.add(age: age, &fbb)\n flatbuffers_goldens_Universe.addVectorOf(galaxies: galaxies, &fbb)\n return flatbuffers_goldens_Universe.endUniverse(&fbb, start: __start)\n }\n\n public static func verify(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {\n var _v = try verifier.visitTable(at: position)\n try _v.visit(field: VTOFFSET.age.p, fieldName: \"age\", required: false, type: Double.self)\n try _v.visit(field: VTOFFSET.galaxies.p, fieldName: \"galaxies\", required: false, type: ForwardOffset, flatbuffers_goldens_Galaxy>>.self)\n _v.finish()\n }\n}\n\n" }, { "path": "goldens/swift/generate.py", "content": "from golden_utils import flatc_golden\n\n\ndef flatc(options, schema):\n # Wrap the golden flatc generator with Swift specifics\n flatc_golden(options=[\"--swift\"] + options, schema=schema, prefix=\"swift\")\n\n\ndef GenerateSwift():\n flatc([], \"basic.fbs\")\n" }, { "path": "goldens/ts/basic.ts", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nexport {Galaxy} from './galaxy.js';\nexport {Universe} from './universe.js';\n" }, { "path": "goldens/ts/flatbuffers/goldens/galaxy.ts", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nexport class Galaxy {\n bb: flatbuffers.ByteBuffer|null = null;\n bb_pos = 0;\n __init(i:number, bb:flatbuffers.ByteBuffer):Galaxy {\n this.bb_pos = i;\n this.bb = bb;\n return this;\n}\n\nstatic getRootAsGalaxy(bb:flatbuffers.ByteBuffer, obj?:Galaxy):Galaxy {\n return (obj || new Galaxy()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n}\n\nstatic getSizePrefixedRootAsGalaxy(bb:flatbuffers.ByteBuffer, obj?:Galaxy):Galaxy {\n bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n return (obj || new Galaxy()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n}\n\nnumStars():bigint {\n const offset = this.bb!.__offset(this.bb_pos, 4);\n return offset ? this.bb!.readInt64(this.bb_pos + offset) : BigInt('0');\n}\n\nstatic startGalaxy(builder:flatbuffers.Builder) {\n builder.startObject(1);\n}\n\nstatic addNumStars(builder:flatbuffers.Builder, numStars:bigint) {\n builder.addFieldInt64(0, numStars, BigInt('0'));\n}\n\nstatic endGalaxy(builder:flatbuffers.Builder):flatbuffers.Offset {\n const offset = builder.endObject();\n return offset;\n}\n\nstatic createGalaxy(builder:flatbuffers.Builder, numStars:bigint):flatbuffers.Offset {\n Galaxy.startGalaxy(builder);\n Galaxy.addNumStars(builder, numStars);\n return Galaxy.endGalaxy(builder);\n}\n}\n" }, { "path": "goldens/ts/flatbuffers/goldens/universe.ts", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\nimport { Galaxy } from './galaxy.js';\n\n\nexport class Universe {\n bb: flatbuffers.ByteBuffer|null = null;\n bb_pos = 0;\n __init(i:number, bb:flatbuffers.ByteBuffer):Universe {\n this.bb_pos = i;\n this.bb = bb;\n return this;\n}\n\nstatic getRootAsUniverse(bb:flatbuffers.ByteBuffer, obj?:Universe):Universe {\n return (obj || new Universe()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n}\n\nstatic getSizePrefixedRootAsUniverse(bb:flatbuffers.ByteBuffer, obj?:Universe):Universe {\n bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n return (obj || new Universe()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n}\n\nage():number {\n const offset = this.bb!.__offset(this.bb_pos, 4);\n return offset ? this.bb!.readFloat64(this.bb_pos + offset) : 0.0;\n}\n\ngalaxies(index: number, obj?:Galaxy):Galaxy|null {\n const offset = this.bb!.__offset(this.bb_pos, 6);\n return offset ? (obj || new Galaxy()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null;\n}\n\ngalaxiesLength():number {\n const offset = this.bb!.__offset(this.bb_pos, 6);\n return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n}\n\nstatic startUniverse(builder:flatbuffers.Builder) {\n builder.startObject(2);\n}\n\nstatic addAge(builder:flatbuffers.Builder, age:number) {\n builder.addFieldFloat64(0, age, 0.0);\n}\n\nstatic addGalaxies(builder:flatbuffers.Builder, galaxiesOffset:flatbuffers.Offset) {\n builder.addFieldOffset(1, galaxiesOffset, 0);\n}\n\nstatic createGalaxiesVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset {\n builder.startVector(4, data.length, 4);\n for (let i = data.length - 1; i >= 0; i--) {\n builder.addOffset(data[i]!);\n }\n return builder.endVector();\n}\n\nstatic startGalaxiesVector(builder:flatbuffers.Builder, numElems:number) {\n builder.startVector(4, numElems, 4);\n}\n\nstatic endUniverse(builder:flatbuffers.Builder):flatbuffers.Offset {\n const offset = builder.endObject();\n return offset;\n}\n\nstatic finishUniverseBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {\n builder.finish(offset);\n}\n\nstatic finishSizePrefixedUniverseBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {\n builder.finish(offset, undefined, true);\n}\n\nstatic createUniverse(builder:flatbuffers.Builder, age:number, galaxiesOffset:flatbuffers.Offset):flatbuffers.Offset {\n Universe.startUniverse(builder);\n Universe.addAge(builder, age);\n Universe.addGalaxies(builder, galaxiesOffset);\n return Universe.endUniverse(builder);\n}\n}\n" }, { "path": "goldens/ts/flatbuffers/goldens.ts", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nexport { Galaxy } from './goldens/galaxy.js';\nexport { Universe } from './goldens/universe.js';\n" }, { "path": "goldens/ts/generate.py", "content": "from golden_utils import flatc_golden\n\n\ndef flatc(options, schema):\n # Wrap the golden flatc generator with Swift specifics\n flatc_golden(options=[\"--ts\"] + options, schema=schema, prefix=\"ts\")\n\n\ndef GenerateTs():\n flatc([], \"basic.fbs\")\n" }, { "path": "grpc/BUILD.bazel", "content": "" }, { "path": "grpc/README.md", "content": "GRPC implementation and test\n\nNOTE: files in `src/` are shared with the GRPC project, and maintained there\n(any changes should be submitted to GRPC instead). These files are copied\nfrom GRPC, and work with both the Protobuf and FlatBuffers code generator.\n\n`tests/` contains a GRPC specific test, you need to have built and installed\nthe GRPC libraries for this to compile. This test will build using the\n`FLATBUFFERS_BUILD_GRPCTEST` option to the main FlatBuffers CMake project.\n\n## Building Flatbuffers with gRPC\n\n### Linux\n\n1. Download, build and install gRPC. See [instructions](https://github.com/grpc/grpc/tree/master/src/cpp).\n * Lets say your gRPC clone is at `/your/path/to/grpc_repo`.\n * Install gRPC in a custom directory by running `make install prefix=/your/path/to/grpc_repo/install`.\n2. `export GRPC_INSTALL_PATH=/your/path/to/grpc_repo/install`\n3. `export PROTOBUF_DOWNLOAD_PATH=/your/path/to/grpc_repo/third_party/protobuf`\n4. `mkdir build ; cd build`\n5. `cmake -DFLATBUFFERS_BUILD_GRPCTEST=ON -DGRPC_INSTALL_PATH=${GRPC_INSTALL_PATH} -DPROTOBUF_DOWNLOAD_PATH=${PROTOBUF_DOWNLOAD_PATH} ..`\n6. `make`\n\nFor Bazel users:\n\n```shell\n$bazel test src/compiler/...\n```\n\n## Running FlatBuffer gRPC tests\n\n### Linux\n\n1. `export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${GRPC_INSTALL_PATH}/lib`\n2. `make test ARGS=-V`\n\nFor Bazel users:\n\n```shell\n$bazel test tests/...\n```\n\n## C++ Callback API Generation\n\nFlatBuffers gRPC C++ code generation now optionally supports the modern gRPC Callback API.\n\nTo enable generation of a `CallbackService` skeleton alongside the existing `Service` and async mixins, invoke `flatc` with both `--grpc` and `--grpc-callback-api`:\n\n```shell\nflatc --cpp --grpc --grpc-callback-api your_service.fbs\n```\n\nThis adds (guarded by `#if defined(GRPC_CALLBACK_API_NONEXPERIMENTAL)`) a class:\n\n```cpp\nclass YourService::CallbackService : public ::grpc::Service { /* reactor virtuals */ };\n```\n\nEach RPC shape maps to the appropriate reactor return type:\n\n- Unary -> `::grpc::ServerUnaryReactor*` Method(...)\n- Client streaming -> `::grpc::ServerReadReactor*`\n- Server streaming -> `::grpc::ServerWriteReactor*`\n- Bidi streaming -> `::grpc::ServerBidiReactor*`\n\nDefault generated implementations return `nullptr`; override in your derived class and return a reactor instance you manage (see gRPC docs for lifecycle patterns).\n\nIf your gRPC library predates the stable callback API macro, the code inside the guard will be skipped (no breaking changes). Ensure you build against a recent gRPC (1.38+; verify current minimum in grpc repo) to use this feature.\n\n### Client Callback Stubs\n\nWhen `--grpc-callback-api` is supplied, the generated C++ client stub gains native callback / reactor based async methods in addition to the existing synchronous / generic async flavors, guarded by the same macro. For each RPC named `Foo`:\n\nUnary:\n\n```\nvoid async_Foo(::grpc::ClientContext*, const Request&, Response*, std::function);\nvoid async_Foo(::grpc::ClientContext*, const Request&, Response*, ::grpc::ClientUnaryReactor*);\n```\n\nClient streaming:\n\n```\n::grpc::ClientWriteReactor* async_Foo(::grpc::ClientContext*, Response*, ::grpc::ClientWriteReactor*);\n```\n\nServer streaming:\n\n```\n::grpc::ClientReadReactor* async_Foo(::grpc::ClientContext*, const Request&, ::grpc::ClientReadReactor*);\n```\n\nBidirectional streaming:\n\n```\n::grpc::ClientBidiReactor* async_Foo(::grpc::ClientContext*, ::grpc::ClientBidiReactor*);\n```\n\nThese map directly onto the native gRPC callback API factories (e.g. `CallbackUnaryCall`, `ClientCallbackWriterFactory::Create`, etc.) and do not spawn threads. Override the appropriate reactor callbacks per gRPC's documentation to drive I/O.\n\nIf your build uses an older gRPC lacking the non-experimental macro, these symbols will not be emitted, preserving backwards compatibility.\n" }, { "path": "grpc/boringssl.patch", "content": "diff --git a/CMakeLists.txt b/CMakeLists.txt\nindex 1645a264a..12f8ca999 100644\n--- a/CMakeLists.txt\n+++ b/CMakeLists.txt\n@@ -635,6 +635,8 @@ add_library(\n src/ssl/tls_record.cc\n )\n \n+target_link_libraries(ssl crypto)\n+\n add_executable(\n bssl\n \ndiff --git a/src/crypto/x509/t_x509.c b/src/crypto/x509/t_x509.c\nindex 7c32a8798..6e50d040e 100644\n--- a/src/crypto/x509/t_x509.c\n+++ b/src/crypto/x509/t_x509.c\n@@ -318,9 +318,7 @@ int X509_signature_print(BIO *bp, const X509_ALGOR *sigalg,\n int X509_NAME_print(BIO *bp, const X509_NAME *name, int obase)\n {\n char *s, *c, *b;\n- int ret = 0, l, i;\n-\n- l = 80 - 2 - obase;\n+ int ret = 0, i;\n\n b = X509_NAME_oneline(name, NULL, 0);\n if (!b)\n@@ -347,12 +345,10 @@ int X509_NAME_print(BIO *bp, const X509_NAME *name, int obase)\n if (BIO_write(bp, \", \", 2) != 2)\n goto err;\n }\n- l--;\n }\n if (*s == '\\0')\n break;\n s++;\n- l--;\n }\n\n ret = 1;\n" }, { "path": "grpc/build_grpc.sh", "content": "#!/bin/bash\n\ngrpc_1_39_0_githash=58602e20a3f3e48f24a4114c757099b25b947f7b\n\nfunction build_grpc () {\n git clone https://github.com/grpc/grpc.git google/grpc\n cd google/grpc\n git checkout ${grpc_1_39_0_githash}\n git submodule update --init\n # Apply boringssl build patch\n cd third_party/boringssl-with-bazel\n git apply ../../../../grpc/boringssl.patch\n cd ../..\n mkdir ../grpc_build\n cd ../grpc_build\n cmake ../grpc -DgRPC_INSTALL=ON -DgRPC_BUILD_TESTS=OFF -DABSL_ENABLE_INSTALL=ON -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX=`pwd`/../grpc/install\n cmake --build . --target install ${JOBS:+-j$JOBS}\n cd ../..\n}\n\nGRPC_INSTALL_PATH=`pwd`/google/grpc/install\nPROTOBUF_DOWNLOAD_PATH=`pwd`/google/grpc/third_party/protobuf\n\nbuild_grpc\n" }, { "path": "grpc/build_grpc_with_cxx14.patch", "content": "diff --git a/bazel/copts.bzl b/bazel/copts.bzl\nindex 10be944f25..879518b92f 100644\n--- a/bazel/copts.bzl\n+++ b/bazel/copts.bzl\n@@ -59,4 +59,7 @@ GRPC_LLVM_WARNING_FLAGS = [\n GRPC_DEFAULT_COPTS = select({\n \"//:use_strict_warning\": GRPC_LLVM_WARNING_FLAGS + [\"-DUSE_STRICT_WARNING=1\"],\n \"//conditions:default\": [],\n-})\n+}) + select({\n+ \"@bazel_tools//src/conditions:windows\": [\"/std:c++14\"],\n+ \"//conditions:default\": [\"-std=c++14\"],\n+})\n" }, { "path": "grpc/examples/README.md", "content": "## Languages known issues\n\n### Python\n\n- Assert the type required in your server/client since python is able to receive `Bytes array` or `utf8 strings`.\n\n```python\ndef SayHello(self, request, context):\n # request might be a byte array or a utf8 string\n\n r = HelloRequest.HelloRequest().GetRootAs(request, 0)\n reply = \"Unknown\"\n if r.Name():\n reply = r.Name()\n # Issues might happen if type checking isnt present.\n # thus encoding it as a `reply.decode('UTF-8')`\n return build_reply(\"welcome \" + reply.decode('UTF-8'))\n\n```\n\nThis can be prevented by making sure all the requests coming to/from python are `Bytes array`\n\n```python\ndef say_hello(stub, builder):\n hello_request = bytes(builder.Output())\n reply = stub.SayHello(hello_request)\n r = HelloReply.HelloReply.GetRootAs(reply)\n print(r.Message())\n```\n\n### Go\n\n- Always requires the `content-type` of the payload to be set to `application/grpc+flatbuffers`\n\nexample: `.SayHello(ctx, b, grpc.CallContentSubtype(\"flatbuffers\"))`\n" }, { "path": "grpc/examples/go/format.sh", "content": "#!/bin/bash\n#\n# Copyright 2021 Google Inc. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nset -e\n\n\nformat_greeter() {\n cd greeter\n\n # Format client\n cd client\n gofmt -w .\n cd ..\n\n # Format server\n cd server\n gofmt -w .\n cd ..\n\n cd ..\n}\n\nformat_greeter" }, { "path": "grpc/examples/go/greeter/.gitignore", "content": "**/server\n**/client" }, { "path": "grpc/examples/go/greeter/README.md", "content": "# Go Greeter example\n\n## Project Structure\n\n .\n ├── server # Server module\n ├── client # Client module\n ├── models # Flatbuffers models & main grpc code.\n └── README.md\n\n## How to run Server:\n\n- `cd server`\n\n- `go clean`\n\n- `go run main.go`\n\n## How to run Client:\n\n- `cd client`\n\n- `go clean`\n\n- `go run main.go --name NAME`\n" }, { "path": "grpc/examples/go/greeter/models/Greeter_grpc.go", "content": "//Generated by gRPC Go plugin\n//If you make any local changes, they will be lost\n//source: greeter\n\npackage models\n\nimport (\n\tcontext \"context\"\n\tflatbuffers \"github.com/google/flatbuffers/go\"\n\tgrpc \"google.golang.org/grpc\"\n\t\"google.golang.org/grpc/codes\"\n\t\"google.golang.org/grpc/status\"\n)\n\n// Client API for Greeter service\ntype GreeterClient interface {\n\tSayHello(ctx context.Context, in *flatbuffers.Builder,\n\t\topts ...grpc.CallOption) (*HelloReply, error)\n\tSayManyHellos(ctx context.Context, in *flatbuffers.Builder,\n\t\topts ...grpc.CallOption) (Greeter_SayManyHellosClient, error)\n}\n\ntype greeterClient struct {\n\tcc grpc.ClientConnInterface\n}\n\nfunc NewGreeterClient(cc grpc.ClientConnInterface) GreeterClient {\n\treturn &greeterClient{cc}\n}\n\nfunc (c *greeterClient) SayHello(ctx context.Context, in *flatbuffers.Builder,\n\topts ...grpc.CallOption) (*HelloReply, error) {\n\tout := new(HelloReply)\n\terr := c.cc.Invoke(ctx, \"/models.Greeter/SayHello\", in, out, opts...)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn out, nil\n}\n\nfunc (c *greeterClient) SayManyHellos(ctx context.Context, in *flatbuffers.Builder,\n\topts ...grpc.CallOption) (Greeter_SayManyHellosClient, error) {\n\tstream, err := c.cc.NewStream(ctx, &_Greeter_serviceDesc.Streams[0], \"/models.Greeter/SayManyHellos\", opts...)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tx := &greeterSayManyHellosClient{stream}\n\tif err := x.ClientStream.SendMsg(in); err != nil {\n\t\treturn nil, err\n\t}\n\tif err := x.ClientStream.CloseSend(); err != nil {\n\t\treturn nil, err\n\t}\n\treturn x, nil\n}\n\ntype Greeter_SayManyHellosClient interface {\n\tRecv() (*HelloReply, error)\n\tgrpc.ClientStream\n}\n\ntype greeterSayManyHellosClient struct {\n\tgrpc.ClientStream\n}\n\nfunc (x *greeterSayManyHellosClient) Recv() (*HelloReply, error) {\n\tm := new(HelloReply)\n\tif err := x.ClientStream.RecvMsg(m); err != nil {\n\t\treturn nil, err\n\t}\n\treturn m, nil\n}\n\n// Server API for Greeter service\ntype GreeterServer interface {\n\tSayHello(context.Context, *HelloRequest) (*flatbuffers.Builder, error)\n\tSayManyHellos(*HelloRequest, Greeter_SayManyHellosServer) error\n\tmustEmbedUnimplementedGreeterServer()\n}\n\ntype UnimplementedGreeterServer struct {\n}\n\nfunc (UnimplementedGreeterServer) SayHello(context.Context, *HelloRequest) (*flatbuffers.Builder, error) {\n\treturn nil, status.Errorf(codes.Unimplemented, \"method SayHello not implemented\")\n}\n\nfunc (UnimplementedGreeterServer) SayManyHellos(*HelloRequest, Greeter_SayManyHellosServer) error {\n\treturn status.Errorf(codes.Unimplemented, \"method SayManyHellos not implemented\")\n}\n\nfunc (UnimplementedGreeterServer) mustEmbedUnimplementedGreeterServer() {}\n\ntype UnsafeGreeterServer interface {\n\tmustEmbedUnimplementedGreeterServer()\n}\n\nfunc RegisterGreeterServer(s grpc.ServiceRegistrar, srv GreeterServer) {\n\ts.RegisterService(&_Greeter_serviceDesc, srv)\n}\n\nfunc _Greeter_SayHello_Handler(srv interface{}, ctx context.Context,\n\tdec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {\n\tin := new(HelloRequest)\n\tif err := dec(in); err != nil {\n\t\treturn nil, err\n\t}\n\tif interceptor == nil {\n\t\treturn srv.(GreeterServer).SayHello(ctx, in)\n\t}\n\tinfo := &grpc.UnaryServerInfo{\n\t\tServer: srv,\n\t\tFullMethod: \"/models.Greeter/SayHello\",\n\t}\n\n\thandler := func(ctx context.Context, req interface{}) (interface{}, error) {\n\t\treturn srv.(GreeterServer).SayHello(ctx, req.(*HelloRequest))\n\t}\n\treturn interceptor(ctx, in, info, handler)\n}\nfunc _Greeter_SayManyHellos_Handler(srv interface{}, stream grpc.ServerStream) error {\n\tm := new(HelloRequest)\n\tif err := stream.RecvMsg(m); err != nil {\n\t\treturn err\n\t}\n\treturn srv.(GreeterServer).SayManyHellos(m, &greeterSayManyHellosServer{stream})\n}\n\ntype Greeter_SayManyHellosServer interface {\n\tSend(*flatbuffers.Builder) error\n\tgrpc.ServerStream\n}\n\ntype greeterSayManyHellosServer struct {\n\tgrpc.ServerStream\n}\n\nfunc (x *greeterSayManyHellosServer) Send(m *flatbuffers.Builder) error {\n\treturn x.ServerStream.SendMsg(m)\n}\n\nvar _Greeter_serviceDesc = grpc.ServiceDesc{\n\tServiceName: \"models.Greeter\",\n\tHandlerType: (*GreeterServer)(nil),\n\tMethods: []grpc.MethodDesc{\n\t\t{\n\t\t\tMethodName: \"SayHello\",\n\t\t\tHandler: _Greeter_SayHello_Handler,\n\t\t},\n\t},\n\tStreams: []grpc.StreamDesc{\n\t\t{\n\t\t\tStreamName: \"SayManyHellos\",\n\t\t\tHandler: _Greeter_SayManyHellos_Handler,\n\t\t\tServerStreams: true,\n\t\t},\n\t},\n}\n" }, { "path": "grpc/examples/go/greeter/models/HelloReply.go", "content": "// Code generated by the FlatBuffers compiler. DO NOT EDIT.\n\npackage models\n\nimport (\n\tflatbuffers \"github.com/google/flatbuffers/go\"\n)\n\ntype HelloReply struct {\n\t_tab flatbuffers.Table\n}\n\nfunc GetRootAsHelloReply(buf []byte, offset flatbuffers.UOffsetT) *HelloReply {\n\tn := flatbuffers.GetUOffsetT(buf[offset:])\n\tx := &HelloReply{}\n\tx.Init(buf, n+offset)\n\treturn x\n}\n\nfunc FinishHelloReplyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {\n\tbuilder.Finish(offset)\n}\n\nfunc GetSizePrefixedRootAsHelloReply(buf []byte, offset flatbuffers.UOffsetT) *HelloReply {\n\tn := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])\n\tx := &HelloReply{}\n\tx.Init(buf, n+offset+flatbuffers.SizeUint32)\n\treturn x\n}\n\nfunc FinishSizePrefixedHelloReplyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {\n\tbuilder.FinishSizePrefixed(offset)\n}\n\nfunc (rcv *HelloReply) Init(buf []byte, i flatbuffers.UOffsetT) {\n\trcv._tab.Bytes = buf\n\trcv._tab.Pos = i\n}\n\nfunc (rcv *HelloReply) Table() flatbuffers.Table {\n\treturn rcv._tab\n}\n\nfunc (rcv *HelloReply) Message() []byte {\n\to := flatbuffers.UOffsetT(rcv._tab.Offset(4))\n\tif o != 0 {\n\t\treturn rcv._tab.ByteVector(o + rcv._tab.Pos)\n\t}\n\treturn nil\n}\n\nfunc HelloReplyStart(builder *flatbuffers.Builder) {\n\tbuilder.StartObject(1)\n}\nfunc HelloReplyAddMessage(builder *flatbuffers.Builder, message flatbuffers.UOffsetT) {\n\tbuilder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(message), 0)\n}\nfunc HelloReplyEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {\n\treturn builder.EndObject()\n}\n" }, { "path": "grpc/examples/go/greeter/models/HelloRequest.go", "content": "// Code generated by the FlatBuffers compiler. DO NOT EDIT.\n\npackage models\n\nimport (\n\tflatbuffers \"github.com/google/flatbuffers/go\"\n)\n\ntype HelloRequest struct {\n\t_tab flatbuffers.Table\n}\n\nfunc GetRootAsHelloRequest(buf []byte, offset flatbuffers.UOffsetT) *HelloRequest {\n\tn := flatbuffers.GetUOffsetT(buf[offset:])\n\tx := &HelloRequest{}\n\tx.Init(buf, n+offset)\n\treturn x\n}\n\nfunc FinishHelloRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {\n\tbuilder.Finish(offset)\n}\n\nfunc GetSizePrefixedRootAsHelloRequest(buf []byte, offset flatbuffers.UOffsetT) *HelloRequest {\n\tn := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])\n\tx := &HelloRequest{}\n\tx.Init(buf, n+offset+flatbuffers.SizeUint32)\n\treturn x\n}\n\nfunc FinishSizePrefixedHelloRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {\n\tbuilder.FinishSizePrefixed(offset)\n}\n\nfunc (rcv *HelloRequest) Init(buf []byte, i flatbuffers.UOffsetT) {\n\trcv._tab.Bytes = buf\n\trcv._tab.Pos = i\n}\n\nfunc (rcv *HelloRequest) Table() flatbuffers.Table {\n\treturn rcv._tab\n}\n\nfunc (rcv *HelloRequest) Name() []byte {\n\to := flatbuffers.UOffsetT(rcv._tab.Offset(4))\n\tif o != 0 {\n\t\treturn rcv._tab.ByteVector(o + rcv._tab.Pos)\n\t}\n\treturn nil\n}\n\nfunc HelloRequestStart(builder *flatbuffers.Builder) {\n\tbuilder.StartObject(1)\n}\nfunc HelloRequestAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {\n\tbuilder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0)\n}\nfunc HelloRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {\n\treturn builder.EndObject()\n}\n" }, { "path": "grpc/examples/go/greeter/models/go.mod", "content": "module github.com/google/flatbuffers/grpc/examples/go/greeter/models\n\ngo 1.15\n\nrequire (\n\tgithub.com/google/flatbuffers v2.0.8+incompatible\n\tgoogle.golang.org/grpc v1.56.3\n)\n" }, { "path": "grpc/examples/greeter.fbs", "content": "namespace models;\n\ntable HelloReply {\n message:string;\n}\n\ntable HelloRequest {\n name:string;\n}\n\nrpc_service Greeter {\n SayHello(HelloRequest):HelloReply;\n SayManyHellos(HelloRequest):HelloReply (streaming: \"server\");\n}\n" }, { "path": "grpc/examples/python/greeter/README.md", "content": "# Python Greeter example\n\n## Prerequisite\n\n- You need to have grpc python installed on your device `pip install grpcio`\n## How to run Server:\n\n- `python server.py ${PORT}`\n\n## How to run Client:\n\n- `python client.py ${PORT} ${NAME}`\n" }, { "path": "grpc/examples/python/greeter/client.py", "content": "import argparse\nimport sys\nimport grpc\n\nsys.path.insert(0, \"../../../../../flatbuffers/python\")\n\nimport flatbuffers\nfrom models import HelloReply, HelloRequest, greeter_grpc_fb\n\nparser = argparse.ArgumentParser()\nparser.add_argument(\"port\", help=\"server port to connect to\", default=3000)\nparser.add_argument(\n \"name\", help=\"name to be sent to server\", default=\"flatbuffers\"\n)\n\n\ndef say_hello(stub, hello_request):\n reply = stub.SayHello(hello_request)\n r = HelloReply.HelloReply.GetRootAs(reply)\n print(r.Message())\n\n\ndef say_many_hellos(stub, hello_request):\n greetings = stub.SayManyHellos(hello_request)\n for greeting in greetings:\n r = HelloReply.HelloReply.GetRootAs(greeting)\n print(r.Message())\n\n\ndef main():\n args = parser.parse_args()\n\n with grpc.insecure_channel(\"localhost:\" + args.port) as channel:\n builder = flatbuffers.Builder()\n ind = builder.CreateString(args.name)\n HelloRequest.HelloRequestStart(builder)\n HelloRequest.HelloRequestAddName(builder, ind)\n root = HelloRequest.HelloRequestEnd(builder)\n builder.Finish(root)\n output = bytes(builder.Output())\n stub = greeter_grpc_fb.GreeterStub(channel)\n say_hello(stub, output)\n say_many_hellos(stub, output)\n\n\nmain()\n" }, { "path": "grpc/examples/python/greeter/greeter_grpc.fb.py", "content": "# Generated by the gRPC FlatBuffers compiler. DO NOT EDIT!\n\nimport flatbuffers\nimport grpc\nfrom models.HelloReply import HelloReply\nfrom models.HelloRequest import HelloRequest\n\n\nclass GreeterStub(object):\n \"\"\"Interface exported by the server.\"\"\"\n\n def __init__(self, channel):\n \"\"\"Constructor.\n\n Args:\n channel: A grpc.Channel.\n \"\"\"\n\n self.SayHello = channel.unary_unary(method='/models.Greeter/SayHello')\n\n self.SayManyHellos = channel.unary_stream(\n method='/models.Greeter/SayManyHellos'\n )\n\n\nclass GreeterServicer(object):\n \"\"\"Interface exported by the server.\"\"\"\n\n def SayHello(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')\n\n def SayManyHellos(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')\n\n\ndef add_GreeterServicer_to_server(servicer, server):\n rpc_method_handlers = {\n 'SayHello': grpc.unary_unary_rpc_method_handler(servicer.SayHello),\n 'SayManyHellos': grpc.unary_stream_rpc_method_handler(\n servicer.SayManyHellos\n ),\n }\n\n generic_handler = grpc.method_handlers_generic_handler(\n 'models.Greeter', rpc_method_handlers\n )\n\n server.add_generic_rpc_handlers((generic_handler,))\n" }, { "path": "grpc/examples/python/greeter/models/HelloReply.py", "content": "# automatically generated by the FlatBuffers compiler, do not modify\n\n# namespace: models\n\nimport flatbuffers\nfrom flatbuffers.compat import import_numpy\nnp = import_numpy()\n\nclass HelloReply(object):\n __slots__ = ['_tab']\n\n @classmethod\n def GetRootAs(cls, buf, offset=0):\n n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)\n x = HelloReply()\n x.Init(buf, n + offset)\n return x\n\n @classmethod\n def GetRootAsHelloReply(cls, buf, offset=0):\n \"\"\"This method is deprecated. Please switch to GetRootAs.\"\"\"\n return cls.GetRootAs(buf, offset)\n # HelloReply\n def Init(self, buf, pos):\n self._tab = flatbuffers.table.Table(buf, pos)\n\n # HelloReply\n def Message(self):\n o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))\n if o != 0:\n return self._tab.String(o + self._tab.Pos)\n return None\n\ndef HelloReplyStart(builder):\n builder.StartObject(1)\n\ndef Start(builder):\n HelloReplyStart(builder)\n\ndef HelloReplyAddMessage(builder, message):\n builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0)\n\ndef AddMessage(builder, message):\n HelloReplyAddMessage(builder, message)\n\ndef HelloReplyEnd(builder):\n return builder.EndObject()\n\ndef End(builder):\n return HelloReplyEnd(builder)\n" }, { "path": "grpc/examples/python/greeter/models/HelloRequest.py", "content": "# automatically generated by the FlatBuffers compiler, do not modify\n\n# namespace: models\n\nimport flatbuffers\nfrom flatbuffers.compat import import_numpy\nnp = import_numpy()\n\nclass HelloRequest(object):\n __slots__ = ['_tab']\n\n @classmethod\n def GetRootAs(cls, buf, offset=0):\n n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)\n x = HelloRequest()\n x.Init(buf, n + offset)\n return x\n\n @classmethod\n def GetRootAsHelloRequest(cls, buf, offset=0):\n \"\"\"This method is deprecated. Please switch to GetRootAs.\"\"\"\n return cls.GetRootAs(buf, offset)\n # HelloRequest\n def Init(self, buf, pos):\n self._tab = flatbuffers.table.Table(buf, pos)\n\n # HelloRequest\n def Name(self):\n o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))\n if o != 0:\n return self._tab.String(o + self._tab.Pos)\n return None\n\ndef HelloRequestStart(builder):\n builder.StartObject(1)\n\ndef Start(builder):\n HelloRequestStart(builder)\n\ndef HelloRequestAddName(builder, name):\n builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)\n\ndef AddName(builder, name):\n HelloRequestAddName(builder, name)\n\ndef HelloRequestEnd(builder):\n return builder.EndObject()\n\ndef End(builder):\n return HelloRequestEnd(builder)\n" }, { "path": "grpc/examples/python/greeter/models/__init__.py", "content": "" }, { "path": "grpc/examples/python/greeter/models/greeter_grpc_fb.py", "content": "# Generated by the gRPC FlatBuffers compiler. DO NOT EDIT!\n\nimport flatbuffers\nimport grpc\n\nfrom models.HelloReply import HelloReply\nfrom models.HelloRequest import HelloRequest\n\n\nclass GreeterStub(object):\n '''Interface exported by the server.'''\n\n def __init__(self, channel):\n '''Constructor.\n\n Args:\n channel: A grpc.Channel.\n '''\n\n self.SayHello = channel.unary_unary(\n method='/models.Greeter/SayHello')\n\n self.SayManyHellos = channel.unary_stream(\n method='/models.Greeter/SayManyHellos')\n\n\nclass GreeterServicer(object):\n '''Interface exported by the server.'''\n\n def SayHello(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')\n\n def SayManyHellos(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')\n\n\ndef add_GreeterServicer_to_server(servicer, server):\n rpc_method_handlers = {\n 'SayHello': grpc.unary_unary_rpc_method_handler(\n servicer.SayHello),\n 'SayManyHellos': grpc.unary_stream_rpc_method_handler(\n servicer.SayManyHellos),\n }\n\n generic_handler = grpc.method_handlers_generic_handler(\n 'models.Greeter', rpc_method_handlers)\n\n server.add_generic_rpc_handlers((generic_handler,))\n\n\n" }, { "path": "grpc/examples/python/greeter/server.py", "content": "import argparse\nfrom concurrent import futures\nimport sys\nimport grpc\n\nsys.path.insert(0, \"../../../../../flatbuffers/python\")\n\nimport flatbuffers\nfrom models import HelloReply, HelloRequest, greeter_grpc_fb\n\nparser = argparse.ArgumentParser()\nparser.add_argument(\"port\", help=\"server on port\", default=3000)\n\n\ndef build_reply(message):\n builder = flatbuffers.Builder()\n ind = builder.CreateString(message)\n HelloReply.HelloReplyStart(builder)\n HelloReply.HelloReplyAddMessage(builder, ind)\n root = HelloReply.HelloReplyEnd(builder)\n builder.Finish(root)\n return bytes(builder.Output())\n\n\nclass GreeterServicer(greeter_grpc_fb.GreeterServicer):\n\n def __init__(self):\n self.greetings = [\"Hi\", \"Hallo\", \"Ciao\"]\n\n def SayHello(self, request, context):\n r = HelloRequest.HelloRequest().GetRootAs(request, 0)\n reply = \"Unknown\"\n if r.Name():\n reply = r.Name()\n return build_reply(\"welcome \" + reply.decode(\"UTF-8\"))\n\n def SayManyHellos(self, request, context):\n r = HelloRequest.HelloRequest().GetRootAs(request, 0)\n reply = \"Unknown\"\n if r.Name():\n reply = r.Name()\n\n for greeting in self.greetings:\n print(type(reply))\n yield build_reply(greeting + \" \" + reply.decode(\"UTF-8\"))\n\n\ndef serve():\n args = parser.parse_args()\n server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))\n greeter_grpc_fb.add_GreeterServicer_to_server(GreeterServicer(), server)\n server.add_insecure_port(\"[::]:\" + args.port)\n server.start()\n server.wait_for_termination()\n\n\nif __name__ == \"__main__\":\n serve()\n" }, { "path": "grpc/examples/swift/Greeter/Package.swift", "content": "// swift-tools-version:5.10\n/*\n * Copyright 2020 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport PackageDescription\n\nlet package = Package(\n name: \"Greeter\",\n platforms: [\n .iOS(.v12),\n .macOS(.v10_14),\n ],\n dependencies: [\n .package(path: \"../../../../swift\"),\n .package(url: \"https://github.com/grpc/grpc-swift.git\", from: \"1.0.0\"),\n ],\n targets: [\n // Targets are the basic building blocks of a package. A target can define a module or a test suite.\n // Targets can depend on other targets in this package, and on products in packages which this package depends on.\n .target(\n name: \"Model\",\n dependencies: [\n \"GRPC\",\n \"FlatBuffers\",\n ],\n path: \"Sources/Model\"),\n\n // Client for the Greeter example\n .target(\n name: \"Client\",\n dependencies: [\n \"GRPC\",\n \"Model\",\n ],\n path: \"Sources/client\"),\n\n // Server for the Greeter example\n .target(\n name: \"Server\",\n dependencies: [\n \"GRPC\",\n \"Model\",\n ],\n path: \"Sources/server\"),\n ])\n" }, { "path": "grpc/examples/swift/Greeter/README.md", "content": "# FlatBuffers.GRPC.Swift\n\nThe following is Swift example on how GRPC would be with Swift Flatbuffers, you can simply run the following commands:\n\n`swift run Server`\n\n`swift run Client {port} {name}`\n" }, { "path": "grpc/examples/swift/Greeter/Sources/Model/greeter.grpc.swift", "content": "// Generated GRPC code for FlatBuffers swift!\n/// The following code is generated by the Flatbuffers library which might not be in sync with grpc-swift\n/// in case of an issue please open github issue, though it would be maintained\n\n// swiftlint:disable all\n// swiftformat:disable all\n\n#if !os(Windows)\nimport Foundation\nimport GRPC\nimport NIO\nimport NIOHTTP1\nimport FlatBuffers\n\npublic protocol GRPCFlatBufPayload: GRPCPayload, FlatBufferGRPCMessage {}\npublic extension GRPCFlatBufPayload {\n init(serializedByteBuffer: inout NIO.ByteBuffer) throws {\n self.init(byteBuffer: FlatBuffers.ByteBuffer(contiguousBytes: serializedByteBuffer.readableBytesView, count: serializedByteBuffer.readableBytes))\n }\n func serialize(into buffer: inout NIO.ByteBuffer) throws {\n withUnsafeReadableBytes { buffer.writeBytes($0) }\n }\n}\nextension Message: GRPCFlatBufPayload {}\n\n/// Usage: instantiate models_GreeterServiceClient, then call methods of this protocol to make API calls.\npublic protocol models_GreeterClientProtocol: GRPCClient {\n\n var serviceName: String { get }\n\n var interceptors: models_GreeterClientInterceptorFactoryProtocol? { get }\n\n func SayHello(\n _ request: Message\n , callOptions: CallOptions?\n ) -> UnaryCall, Message>\n\n func SayManyHellos(\n _ request: Message\n , callOptions: CallOptions?,\n handler: @escaping (Message) -> Void\n ) -> ServerStreamingCall, Message>\n\n}\n\nextension models_GreeterClientProtocol {\n\n public var serviceName: String { \"models.Greeter\" }\n\n public func SayHello(\n _ request: Message\n , callOptions: CallOptions? = nil\n ) -> UnaryCall, Message> {\n return self.makeUnaryCall(\n path: \"/models.Greeter/SayHello\",\n request: request,\n callOptions: callOptions ?? self.defaultCallOptions,\n interceptors: self.interceptors?.makeSayHelloInterceptors() ?? []\n )\n }\n\n public func SayManyHellos(\n _ request: Message\n , callOptions: CallOptions? = nil,\n handler: @escaping (Message) -> Void\n ) -> ServerStreamingCall, Message> {\n return self.makeServerStreamingCall(\n path: \"/models.Greeter/SayManyHellos\",\n request: request,\n callOptions: callOptions ?? self.defaultCallOptions,\n interceptors: self.interceptors?.makeSayManyHellosInterceptors() ?? [],\n handler: handler\n )\n }\n}\n\npublic protocol models_GreeterClientInterceptorFactoryProtocol {\n /// - Returns: Interceptors to use when invoking 'SayHello'.\n func makeSayHelloInterceptors() -> [ClientInterceptor, Message>]\n\n /// - Returns: Interceptors to use when invoking 'SayManyHellos'.\n func makeSayManyHellosInterceptors() -> [ClientInterceptor, Message>]\n\n}\n\npublic final class models_GreeterServiceClient: models_GreeterClientProtocol {\n public let channel: GRPCChannel\n public var defaultCallOptions: CallOptions\n public var interceptors: models_GreeterClientInterceptorFactoryProtocol?\n\n public init(\n channel: GRPCChannel,\n defaultCallOptions: CallOptions = CallOptions(),\n interceptors: models_GreeterClientInterceptorFactoryProtocol? = nil\n ) {\n self.channel = channel\n self.defaultCallOptions = defaultCallOptions\n self.interceptors = interceptors\n }\n}\n\npublic protocol models_GreeterProvider: CallHandlerProvider {\n var interceptors: models_GreeterServerInterceptorFactoryProtocol? { get }\n func SayHello(request: Message, context: StatusOnlyCallContext) -> EventLoopFuture>\n func SayManyHellos(request: Message, context: StreamingResponseCallContext>) -> EventLoopFuture\n}\n\npublic extension models_GreeterProvider {\n\n var serviceName: Substring { return \"models.Greeter\" }\n\n func handle(method name: Substring, context: CallHandlerContext) -> GRPCServerHandlerProtocol? {\n switch name {\n case \"SayHello\":\n return UnaryServerHandler(\n context: context,\n requestDeserializer: GRPCPayloadDeserializer>(),\n responseSerializer: GRPCPayloadSerializer>(),\n interceptors: self.interceptors?.makeSayHelloInterceptors() ?? [],\n userFunction: self.SayHello(request:context:))\n\n case \"SayManyHellos\":\n return ServerStreamingServerHandler(\n context: context,\n requestDeserializer: GRPCPayloadDeserializer>(),\n responseSerializer: GRPCPayloadSerializer>(),\n interceptors: self.interceptors?.makeSayManyHellosInterceptors() ?? [],\n userFunction: self.SayManyHellos(request:context:))\n\n default: return nil;\n }\n }\n\n}\n\npublic protocol models_GreeterServerInterceptorFactoryProtocol {\n /// - Returns: Interceptors to use when handling 'SayHello'.\n /// Defaults to calling `self.makeInterceptors()`.\n func makeSayHelloInterceptors() -> [ServerInterceptor, Message>]\n\n /// - Returns: Interceptors to use when handling 'SayManyHellos'.\n /// Defaults to calling `self.makeInterceptors()`.\n func makeSayManyHellosInterceptors() -> [ServerInterceptor, Message>]\n\n}\n#endif\n\n" }, { "path": "grpc/examples/swift/Greeter/Sources/Model/greeter_generated.swift", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n// swiftlint:disable all\n// swiftformat:disable all\n\n#if canImport(Common)\nimport Common\n#endif\n\nimport FlatBuffers\n\npublic struct models_HelloReply: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable {\n\n static func validateVersion() { FlatBuffersVersion_25_12_19() }\n public var __buffer: ByteBuffer! { return _accessor.bb }\n private var _accessor: Table\n\n private init(_ t: Table) { _accessor = t }\n public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }\n\n private struct VT {\n static let message: VOffset = 4\n }\n\n public var message: String? { let o = _accessor.offset(VT.message); return o == 0 ? nil : _accessor.string(at: o) }\n public var messageSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.message) }\n public static func startHelloReply(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }\n public static func add(message: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: message, at: VT.message) }\n public static func endHelloReply(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }\n public static func createHelloReply(\n _ fbb: inout FlatBufferBuilder,\n messageOffset message: Offset = Offset()\n ) -> Offset {\n let __start = models_HelloReply.startHelloReply(&fbb)\n models_HelloReply.add(message: message, &fbb)\n return models_HelloReply.endHelloReply(&fbb, start: __start)\n }\n\n public static func verify(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {\n var _v = try verifier.visitTable(at: position)\n try _v.visit(field: VT.message, fieldName: \"message\", required: false, type: ForwardOffset.self)\n _v.finish()\n }\n}\n\nextension models_HelloReply: Encodable {\n enum CodingKeys: String, CodingKey {\n case message = \"message\"\n }\n\n public func encode(to encoder: Encoder) throws {\n var container = encoder.container(keyedBy: CodingKeys.self)\n try container.encodeIfPresent(message, forKey: .message)\n }\n}\n\npublic struct models_HelloRequest: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable {\n\n static func validateVersion() { FlatBuffersVersion_25_12_19() }\n public var __buffer: ByteBuffer! { return _accessor.bb }\n private var _accessor: Table\n\n private init(_ t: Table) { _accessor = t }\n public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }\n\n private struct VT {\n static let name: VOffset = 4\n }\n\n public var name: String? { let o = _accessor.offset(VT.name); return o == 0 ? nil : _accessor.string(at: o) }\n public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.name) }\n public static func startHelloRequest(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }\n public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VT.name) }\n public static func endHelloRequest(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }\n public static func createHelloRequest(\n _ fbb: inout FlatBufferBuilder,\n nameOffset name: Offset = Offset()\n ) -> Offset {\n let __start = models_HelloRequest.startHelloRequest(&fbb)\n models_HelloRequest.add(name: name, &fbb)\n return models_HelloRequest.endHelloRequest(&fbb, start: __start)\n }\n\n public static func verify(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {\n var _v = try verifier.visitTable(at: position)\n try _v.visit(field: VT.name, fieldName: \"name\", required: false, type: ForwardOffset.self)\n _v.finish()\n }\n}\n\nextension models_HelloRequest: Encodable {\n enum CodingKeys: String, CodingKey {\n case name = \"name\"\n }\n\n public func encode(to encoder: Encoder) throws {\n var container = encoder.container(keyedBy: CodingKeys.self)\n try container.encodeIfPresent(name, forKey: .name)\n }\n}\n\n" }, { "path": "grpc/examples/swift/Greeter/Sources/client/main.swift", "content": "/*\n * Copyright 2024 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport FlatBuffers\nimport GRPC\nimport Logging\nimport Model\nimport NIO\n\n// Quieten the logs.\nLoggingSystem.bootstrap {\n var handler = StreamLogHandler.standardOutput(label: $0)\n handler.logLevel = .critical\n return handler\n}\n\nfunc greet(name: String, client greeter: models_GreeterServiceClient) {\n // Form the request with the name, if one was provided.\n var builder = FlatBufferBuilder()\n let nameOff = builder.create(string: name)\n let root = models_HelloRequest.createHelloRequest(\n &builder,\n nameOffset: nameOff)\n builder.finish(offset: root)\n\n // Make the RPC call to the server.\n let sayHello =\n greeter\n .SayHello(Message(builder: &builder))\n\n // wait() on the response to stop the program from exiting before the response is received.\n do {\n let response = try sayHello.response.wait()\n print(\"Greeter SayHello received: \\(response.object.message ?? \"Unknown\")\")\n } catch {\n print(\"Greeter failed: \\(error)\")\n }\n\n let surname = builder.create(string: name)\n let manyRoot = models_HelloRequest.createHelloRequest(\n &builder,\n nameOffset: surname)\n builder.finish(offset: manyRoot)\n\n let call = greeter.SayManyHellos(Message(builder: &builder)) { message in\n print(\n \"Greeter SayManyHellos received: \\(message.object.message ?? \"Unknown\")\")\n }\n\n let status = try! call.status.recover { _ in .processingError }.wait()\n if status.code != .ok {\n print(\"RPC failed: \\(status)\")\n }\n}\n\nfunc main(args: [String]) {\n // arg0 (dropped) is the program name. We expect arg1 to be the port, and arg2 (optional) to be\n // the name sent in the request.\n let arg1 = args.dropFirst(1).first\n let arg2 = args.dropFirst(2).first\n\n switch (arg1.flatMap(Int.init), arg2) {\n case (.none, _):\n print(\"Usage: PORT [NAME]\")\n exit(1)\n\n case (.some(let port), let name):\n // Setup an `EventLoopGroup` for the connection to run on.\n //\n // See: https://github.com/apple/swift-nio#eventloops-and-eventloopgroups\n let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)\n\n // Make sure the group is shutdown when we're done with it.\n defer {\n try! group.syncShutdownGracefully()\n }\n\n // Configure the channel, we're not using TLS so the connection is `insecure`.\n let channel = ClientConnection.insecure(group: group)\n .connect(host: \"localhost\", port: port)\n\n // Close the connection when we're done with it.\n defer {\n try! channel.close().wait()\n }\n\n // Provide the connection to the generated client.\n let greeter = models_GreeterServiceClient(channel: channel)\n\n // Do the greeting.\n greet(name: name ?? \"FlatBuffers!\", client: greeter)\n }\n}\n\nmain(args: CommandLine.arguments)\n" }, { "path": "grpc/examples/swift/Greeter/Sources/server/main.swift", "content": "/*\n * Copyright 2024 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport FlatBuffers\nimport GRPC\nimport Logging\nimport Model\nimport NIO\n\nclass Greeter: models_GreeterProvider {\n\n var interceptors: models_GreeterServerInterceptorFactoryProtocol?\n\n let greetings: [String]\n\n init() {\n greetings = [\"Hi\", \"Hallo\", \"Ciao\"]\n }\n\n func SayHello(\n request: Message,\n context: StatusOnlyCallContext)\n -> EventLoopFuture>\n {\n let recipient = request.object.name ?? \"Stranger\"\n\n var builder = FlatBufferBuilder()\n let off = builder.create(string: \"Hello \\(recipient)\")\n let root = models_HelloReply.createHelloReply(&builder, messageOffset: off)\n builder.finish(offset: root)\n return context.eventLoop\n .makeSucceededFuture(Message(builder: &builder))\n }\n\n func SayManyHellos(\n request: Message,\n context: StreamingResponseCallContext>)\n -> EventLoopFuture\n {\n for name in greetings {\n var builder = FlatBufferBuilder()\n let off =\n builder\n .create(string: \"\\(name) \\(request.object.name ?? \"Unknown\")\")\n let root = models_HelloReply.createHelloReply(\n &builder,\n messageOffset: off)\n builder.finish(offset: root)\n _ = context.sendResponse(Message(builder: &builder))\n }\n return context.eventLoop.makeSucceededFuture(.ok)\n }\n}\n\n// Quieten the logs.\nLoggingSystem.bootstrap {\n var handler = StreamLogHandler.standardOutput(label: $0)\n handler.logLevel = .critical\n return handler\n}\n\nlet group = MultiThreadedEventLoopGroup(numberOfThreads: 1)\ndefer {\n try! group.syncShutdownGracefully()\n}\n\n// Create some configuration for the server:\nlet configuration = Server.Configuration(\n target: .hostAndPort(\"localhost\", 0),\n eventLoopGroup: group,\n serviceProviders: [Greeter()])\n\n// Start the server and print its address once it has started.\nlet server = Server.start(configuration: configuration)\nserver.map {\n $0.channel.localAddress\n}.whenSuccess { address in\n print(\"server started on port \\(address!.port!)\")\n}\n\n// Wait on the server's `onClose` future to stop the program from exiting.\n_ = try server.flatMap {\n $0.onClose\n}.wait()\n" }, { "path": "grpc/examples/ts/greeter/README.md", "content": "# TS Greeter example\n\nThe following is an example on how to run the TS grpc server. Make sure that you have `Typescript` installed\n\nyou would need to run `npm run build` or simply use `npm install && tsc`\n\n## How to run Server:\n\n- `npm run server`\n\n## How to run Client:\n\n- `npm run client 3000`\n" }, { "path": "grpc/examples/ts/greeter/package.json", "content": "{\n \"name\": \"flatbuffers-js-grpc\",\n \"version\": \"1.0.0\",\n \"author\": \"mustii@mmk.one\",\n \"scripts\": {\n \"build\": \"npm install && tsc\",\n \"client\": \"node dist/client.js\",\n \"server\": \"node dist/server.js\"\n },\n \"dependencies\": {\n \"@grpc/grpc-js\": \"^1.3.2\",\n \"flatbuffers\": \"^2.0.0\"\n }\n}\n" }, { "path": "grpc/examples/ts/greeter/src/client.ts", "content": "import * as grpc from '@grpc/grpc-js';\nimport * as flatbuffers from 'flatbuffers';\nimport {GreeterClient} from './greeter_grpc';\nimport {HelloReply} from './models/hello-reply';\nimport {HelloRequest} from './models/hello-request';\n\nasync function main(PORT: Number, name: string) {\n const client = new GreeterClient(\n `localhost:${PORT}`,\n grpc.credentials.createInsecure(),\n );\n const builder = new flatbuffers.Builder();\n const offset = builder.createString(name);\n const root = HelloRequest.createHelloRequest(builder, offset);\n builder.finish(root);\n const buffer = HelloRequest.getRootAsHelloRequest(\n new flatbuffers.ByteBuffer(builder.asUint8Array()),\n );\n\n client.SayHello(buffer, (err, response) => {\n console.log(response.message());\n });\n\n const data = client.SayManyHellos(buffer, null);\n\n data.on('data', (data) => {\n console.log(data.message());\n });\n}\n\nconst args = process.argv.slice(2);\nconst PORT = Number(args[0]);\nconst name: string = args[1] ?? 'flatbuffers';\n\nif (PORT) {\n main(PORT, name);\n} else {\n throw new Error('Requires a valid port number.');\n}\n" }, { "path": "grpc/examples/ts/greeter/src/greeter.ts", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nexport * as models from './models.js';\n" }, { "path": "grpc/examples/ts/greeter/src/greeter_generated.ts", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n\nexport {HelloReply} from './models/hello-reply.js';\nexport {HelloRequest} from './models/hello-request.js';\n" }, { "path": "grpc/examples/ts/greeter/src/greeter_grpc.d.ts", "content": "// Generated GRPC code for FlatBuffers TS *** DO NOT EDIT ***\nimport * as flatbuffers from 'flatbuffers';\nimport { HelloReply as models_HelloReply } from './models/hello-reply';\nimport { HelloRequest as models_HelloRequest } from './models/hello-request';\n\nimport * as grpc from '@grpc/grpc-js';\n\ninterface IGreeterService extends grpc.ServiceDefinition {\n SayHello: IGreeterService_ISayHello;\n SayManyHellos: IGreeterService_ISayManyHellos;\n}\ninterface IGreeterService_ISayHello extends grpc.MethodDefinition {\n path: string; // /models.Greeter/SayHello\n requestStream: boolean; // false\n responseStream: boolean; // false\n requestSerialize: grpc.serialize;\n requestDeserialize: grpc.deserialize;\n responseSerialize: grpc.serialize;\n responseDeserialize: grpc.deserialize;\n}\n\ninterface IGreeterService_ISayManyHellos extends grpc.MethodDefinition {\n path: string; // /models.Greeter/SayManyHellos\n requestStream: boolean; // false\n responseStream: boolean; // true\n requestSerialize: grpc.serialize;\n requestDeserialize: grpc.deserialize;\n responseSerialize: grpc.serialize;\n responseDeserialize: grpc.deserialize;\n}\n\n\nexport const GreeterService: IGreeterService;\n\nexport interface IGreeterServer extends grpc.UntypedServiceImplementation {\n SayHello: grpc.handleUnaryCall;\n SayManyHellos: grpc.handleServerStreamingCall;\n}\n\nexport interface IGreeterClient {\n SayHello(request: models_HelloRequest, callback: (error: grpc.ServiceError | null, response: models_HelloReply) => void): grpc.ClientUnaryCall;\n SayHello(request: models_HelloRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: models_HelloReply) => void): grpc.ClientUnaryCall;\n SayHello(request: models_HelloRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: models_HelloReply) => void): grpc.ClientUnaryCall;\n SayManyHellos(request: models_HelloRequest, metadata: grpc.Metadata): grpc.ClientReadableStream;\n SayManyHellos(request: models_HelloRequest, options: Partial): grpc.ClientReadableStream;\n}\n\nexport class GreeterClient extends grpc.Client implements IGreeterClient {\n constructor(address: string, credentials: grpc.ChannelCredentials, options?: object);\n public SayHello(request: models_HelloRequest, callback: (error: grpc.ServiceError | null, response: models_HelloReply) => void): grpc.ClientUnaryCall;\n public SayHello(request: models_HelloRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: models_HelloReply) => void): grpc.ClientUnaryCall;\n public SayHello(request: models_HelloRequest, metadata: grpc.Metadata, options: Partial, callback: (error: grpc.ServiceError | null, response: models_HelloReply) => void): grpc.ClientUnaryCall;\n public SayManyHellos(request: models_HelloRequest, metadata: grpc.Metadata): grpc.ClientReadableStream;\n public SayManyHellos(request: models_HelloRequest, options: Partial): grpc.ClientReadableStream;\n}\n\n" }, { "path": "grpc/examples/ts/greeter/src/greeter_grpc.js", "content": "// Generated GRPC code for FlatBuffers TS *** DO NOT EDIT ***\nimport * as flatbuffers from 'flatbuffers';\nimport { HelloReply as models_HelloReply } from './models/hello-reply';\nimport { HelloRequest as models_HelloRequest } from './models/hello-request';\n\nvar grpc = require('@grpc/grpc-js');\n\nfunction serialize_models_HelloReply(buffer_args) {\n if (!(buffer_args instanceof models_HelloReply)) {\n throw new Error('Expected argument of type HelloReply');\n }\n return Buffer.from(buffer_args.serialize());\n}\n\nfunction deserialize_models_HelloReply(buffer) {\n return models_HelloReply.getRootAsHelloReply(new flatbuffers.ByteBuffer(buffer))\n}\n\n\nfunction serialize_models_HelloRequest(buffer_args) {\n if (!(buffer_args instanceof models_HelloRequest)) {\n throw new Error('Expected argument of type HelloRequest');\n }\n return Buffer.from(buffer_args.serialize());\n}\n\nfunction deserialize_models_HelloRequest(buffer) {\n return models_HelloRequest.getRootAsHelloRequest(new flatbuffers.ByteBuffer(buffer))\n}\n\n\nvar GreeterService = exports.GreeterService = {\n SayHello: {\n path: '/models.Greeter/SayHello',\n requestStream: false,\n responseStream: false,\n requestType: flatbuffers.ByteBuffer,\n responseType: models_HelloReply,\n requestSerialize: serialize_models_HelloRequest,\n requestDeserialize: deserialize_models_HelloRequest,\n responseSerialize: serialize_models_HelloReply,\n responseDeserialize: deserialize_models_HelloReply,\n },\n SayManyHellos: {\n path: '/models.Greeter/SayManyHellos',\n requestStream: false,\n responseStream: true,\n requestType: flatbuffers.ByteBuffer,\n responseType: models_HelloReply,\n requestSerialize: serialize_models_HelloRequest,\n requestDeserialize: deserialize_models_HelloRequest,\n responseSerialize: serialize_models_HelloReply,\n responseDeserialize: deserialize_models_HelloReply,\n },\n};\nexports.GreeterClient = grpc.makeGenericClientConstructor(GreeterService);\n" }, { "path": "grpc/examples/ts/greeter/src/models/hello-reply.ts", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\n\n\nexport class HelloReply {\n bb: flatbuffers.ByteBuffer|null = null;\n bb_pos = 0;\n __init(i:number, bb:flatbuffers.ByteBuffer):HelloReply {\n this.bb_pos = i;\n this.bb = bb;\n return this;\n}\n\nstatic getRootAsHelloReply(bb:flatbuffers.ByteBuffer, obj?:HelloReply):HelloReply {\n return (obj || new HelloReply()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n}\n\nstatic getSizePrefixedRootAsHelloReply(bb:flatbuffers.ByteBuffer, obj?:HelloReply):HelloReply {\n bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n return (obj || new HelloReply()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n}\n\nmessage():string|null\nmessage(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null\nmessage(optionalEncoding?:any):string|Uint8Array|null {\n const offset = this.bb!.__offset(this.bb_pos, 4);\n return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n}\n\nstatic startHelloReply(builder:flatbuffers.Builder) {\n builder.startObject(1);\n}\n\nstatic addMessage(builder:flatbuffers.Builder, messageOffset:flatbuffers.Offset) {\n builder.addFieldOffset(0, messageOffset, 0);\n}\n\nstatic endHelloReply(builder:flatbuffers.Builder):flatbuffers.Offset {\n const offset = builder.endObject();\n return offset;\n}\n\nstatic createHelloReply(builder:flatbuffers.Builder, messageOffset:flatbuffers.Offset):flatbuffers.Offset {\n HelloReply.startHelloReply(builder);\n HelloReply.addMessage(builder, messageOffset);\n return HelloReply.endHelloReply(builder);\n}\n\nserialize():Uint8Array {\n return this.bb!.bytes();\n}\n\nstatic deserialize(buffer: Uint8Array):HelloReply {\n return HelloReply.getRootAsHelloReply(new flatbuffers.ByteBuffer(buffer))\n}\n}\n" }, { "path": "grpc/examples/ts/greeter/src/models/hello-request.ts", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nimport * as flatbuffers from 'flatbuffers';\n\n\n\nexport class HelloRequest {\n bb: flatbuffers.ByteBuffer|null = null;\n bb_pos = 0;\n __init(i:number, bb:flatbuffers.ByteBuffer):HelloRequest {\n this.bb_pos = i;\n this.bb = bb;\n return this;\n}\n\nstatic getRootAsHelloRequest(bb:flatbuffers.ByteBuffer, obj?:HelloRequest):HelloRequest {\n return (obj || new HelloRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n}\n\nstatic getSizePrefixedRootAsHelloRequest(bb:flatbuffers.ByteBuffer, obj?:HelloRequest):HelloRequest {\n bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);\n return (obj || new HelloRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n}\n\nname():string|null\nname(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null\nname(optionalEncoding?:any):string|Uint8Array|null {\n const offset = this.bb!.__offset(this.bb_pos, 4);\n return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n}\n\nstatic startHelloRequest(builder:flatbuffers.Builder) {\n builder.startObject(1);\n}\n\nstatic addName(builder:flatbuffers.Builder, nameOffset:flatbuffers.Offset) {\n builder.addFieldOffset(0, nameOffset, 0);\n}\n\nstatic endHelloRequest(builder:flatbuffers.Builder):flatbuffers.Offset {\n const offset = builder.endObject();\n return offset;\n}\n\nstatic createHelloRequest(builder:flatbuffers.Builder, nameOffset:flatbuffers.Offset):flatbuffers.Offset {\n HelloRequest.startHelloRequest(builder);\n HelloRequest.addName(builder, nameOffset);\n return HelloRequest.endHelloRequest(builder);\n}\n\nserialize():Uint8Array {\n return this.bb!.bytes();\n}\n\nstatic deserialize(buffer: Uint8Array):HelloRequest {\n return HelloRequest.getRootAsHelloRequest(new flatbuffers.ByteBuffer(buffer))\n}\n}\n" }, { "path": "grpc/examples/ts/greeter/src/models.ts", "content": "// automatically generated by the FlatBuffers compiler, do not modify\n\n/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */\n\nexport { HelloReply } from './models/hello-reply.js';\nexport { HelloRequest } from './models/hello-request.js';\n" }, { "path": "grpc/examples/ts/greeter/src/server.ts", "content": "import * as grpc from '@grpc/grpc-js';\nimport * as flatbuffers from 'flatbuffers';\nimport {GreeterService, IGreeterServer} from './greeter_grpc';\nimport {HelloReply} from './models/hello-reply';\nimport {HelloRequest} from './models/hello-request';\n\nconst greeter: IGreeterServer = {\n SayHello(\n call: grpc.ServerUnaryCall,\n callback: grpc.sendUnaryData,\n ): void {\n console.log(`SayHello ${call.request.name()}`);\n const builder = new flatbuffers.Builder();\n const offset = builder.createString(`welcome ${call.request.name()}`);\n const root = HelloReply.createHelloReply(builder, offset);\n builder.finish(root);\n callback(\n null,\n HelloReply.getRootAsHelloReply(\n new flatbuffers.ByteBuffer(builder.asUint8Array()),\n ),\n );\n },\n async SayManyHellos(\n call: grpc.ServerWritableStream,\n ): Promise {\n const name = call.request.name();\n console.log(`${call.request.name()} saying hi in different langagues`);\n ['Hi', 'Hallo', 'Ciao'].forEach((element) => {\n const builder = new flatbuffers.Builder();\n const offset = builder.createString(`${element} ${name}`);\n const root = HelloReply.createHelloReply(builder, offset);\n builder.finish(root);\n call.write(\n HelloReply.getRootAsHelloReply(\n new flatbuffers.ByteBuffer(builder.asUint8Array()),\n ),\n );\n });\n call.end();\n },\n};\n\nfunction serve(): void {\n const PORT = 3000;\n const server = new grpc.Server();\n server.addService(GreeterService, greeter);\n console.log(`Listening on ${PORT}`);\n server.bindAsync(\n `localhost:${PORT}`,\n grpc.ServerCredentials.createInsecure(),\n (err: Error | null, port: number) => {\n if (err) {\n console.error(`Server error: ${err.message}`);\n } else {\n console.log(`Server bound on port: ${port}`);\n server.start();\n }\n },\n );\n}\n\nserve();\n" }, { "path": "grpc/examples/ts/greeter/tsconfig.json", "content": "{\n \"compilerOptions\": {\n \"target\": \"es5\",\n \"module\": \"commonjs\",\n \"outDir\": \"./dist\",\n \"allowJs\": true,\n \"sourceMap\": true,\n \"strict\": true,\n \"noImplicitAny\": false,\n \"strictNullChecks\": false,\n \"esModuleInterop\": true,\n \"baseUrl\": \"./\",\n \"typeRoots\": [\"node_modules/@types\"],\n \"skipLibCheck\": true, \n \"forceConsistentCasingInFileNames\": true\n }\n }" }, { "path": "grpc/flatbuffers-java-grpc/pom.xml", "content": "\n\n 4.0.0\n \n com.google.flatbuffers\n flatbuffers-parent\n 2.0.3\n \n flatbuffers-java-grpc\n ${project.artifactId}\n bundle\n \n Utilities supporting generated code for GRPC\n \n \n \n Wouter van Oortmerssen\n \n \n Yuri Finkelstein\n https://github.com/yfinkelstein\n \n \n \n 1.67.1\n \n \n \n com.google.flatbuffers\n flatbuffers-java\n ${project.parent.version}\n \n \n io.grpc\n grpc-core\n ${gRPC.version}\n \n \n\n\n" }, { "path": "grpc/flatbuffers-java-grpc/src/main/java/com/google/flatbuffers/grpc/FlatbuffersUtils.java", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage com.google.flatbuffers.grpc;\n\nimport com.google.flatbuffers.Table;\nimport io.grpc.Drainable;\nimport io.grpc.KnownLength;\nimport io.grpc.MethodDescriptor;\nimport java.io.ByteArrayInputStream;\nimport java.io.IOException;\nimport java.io.InputStream;\nimport java.io.OutputStream;\nimport java.nio.ByteBuffer;\nimport javax.annotation.Nullable;\n\npublic class FlatbuffersUtils {\n public abstract static class FBExtactor {\n T extract(InputStream stream) throws IOException {\n if (stream instanceof KnownLength) {\n int size = stream.available();\n ByteBuffer buffer = ByteBuffer.allocate(size);\n stream.read(buffer.array());\n return extract(buffer);\n } else\n throw new RuntimeException(\n \"The class \"\n + stream.getClass().getCanonicalName()\n + \" does not extend from KnownLength \");\n }\n\n public abstract T extract(ByteBuffer buffer);\n }\n\n static class FBInputStream extends InputStream implements Drainable, KnownLength {\n private final ByteBuffer buffer;\n private final int size;\n @Nullable private ByteArrayInputStream inputStream;\n\n FBInputStream(ByteBuffer buffer) {\n this.buffer = buffer;\n this.size = buffer.remaining();\n }\n\n private void makeStreamIfNotAlready() {\n if (inputStream == null)\n inputStream = new ByteArrayInputStream(buffer.array(), buffer.position(), size);\n }\n\n @Override\n public int drainTo(OutputStream target) throws IOException {\n target.write(buffer.array(), buffer.position(), size);\n return size;\n }\n\n @Override\n public int read() throws IOException {\n makeStreamIfNotAlready();\n return inputStream.read();\n }\n\n @Override\n public int read(byte[] b, int off, int len) throws IOException {\n makeStreamIfNotAlready();\n if (inputStream == null) {\n if (len >= size) {\n System.arraycopy(buffer.array(), buffer.position(), b, off, size);\n return size;\n } else {\n makeStreamIfNotAlready();\n return inputStream.read(b, off, len);\n }\n } else return inputStream.read(b, off, len);\n }\n\n @Override\n public int available() throws IOException {\n return inputStream == null ? size : inputStream.available();\n }\n }\n\n public static MethodDescriptor.Marshaller marshaller(\n final Class clazz, final FBExtactor extractor) {\n return new MethodDescriptor.ReflectableMarshaller() {\n @Override\n public Class getMessageClass() {\n return clazz;\n }\n\n @Override\n public InputStream stream(T value) {\n return new FBInputStream(value.getByteBuffer());\n }\n\n @Override\n public T parse(InputStream stream) {\n try {\n return extractor.extract(stream);\n } catch (IOException e) {\n throw new RuntimeException(e);\n }\n }\n };\n }\n}\n" }, { "path": "grpc/pom.xml", "content": "\n 4.0.0\n com.google.flatbuffers\n flatbuffers-parent\n pom\n 2.0.3\n flatbuffers-parent\n parent pom for flatbuffers java artifacts\n \n https://github.com/google/flatbuffers\n scm:git:${scm.url}.git\n UTF-8\n \n\n \n \n The Apache Software License, Version 2.0\n http://www.apache.org/licenses/LICENSE-2.0.txt\n repo\n \n \n\n \n GitHub\n https://github.com/google/flatbuffers/issues\n \n\n \n \n Wouter van Oortmerssen\n \n \n\n ${scm.url}\n\n \n ${scm.connection}\n ${scm.connection}\n ${scm.url}\n HEAD\n \n\n \n \n ossrh\n https://oss.sonatype.org/content/repositories/snapshots\n \n \n\n \n \n junit\n junit\n 4.13.1\n test\n \n\n \n \n \n \n \n kr.motd.maven\n os-maven-plugin\n 1.5.0.Final\n \n \n \n \n \n maven-compiler-plugin\n 3.6.1\n \n \n maven-jar-plugin\n 3.0.2\n \n \n maven-source-plugin\n 3.0.1\n \n \n maven-surefire-plugin\n 2.19.1\n \n \n maven-javadoc-plugin\n 2.10.4\n \n \n org.codehaus.mojo\n build-helper-maven-plugin\n 1.12\n \n \n maven-dependency-plugin\n 2.8\n \n \n maven-deploy-plugin\n 2.7\n \n \n maven-gpg-plugin\n 1.5\n \n \n maven-release-plugin\n 2.5.3\n \n\n \n org.codehaus.mojo\n exec-maven-plugin\n 1.5.0\n \n \n \n\n \n \n maven-compiler-plugin\n \n 1.6\n 1.6\n \n \n \n maven-surefire-plugin\n \n \n **/*Test.java\n \n \n \n \n maven-source-plugin\n \n \n attach-sources\n \n jar\n \n \n \n \n \n maven-javadoc-plugin\n \n \n attach-javadocs\n \n jar\n \n \n \n \n \n org.apache.felix\n maven-bundle-plugin\n 3.0.1\n true\n \n \n org.sonatype.plugins\n nexus-staging-maven-plugin\n 1.6.7\n true\n \n ossrh\n https://oss.sonatype.org/\n true\n \n \n \n maven-gpg-plugin\n \n \n sign-artifacts\n verify\n \n sign\n \n \n \n --pinentry-mode\n loopback\n \n \n \n \n \n \n maven-release-plugin\n \n true\n false\n release\n deploy\n \n \n \n \n\n \n\n flatbuffers-java-grpc\n \n\n\n" }, { "path": "grpc/samples/greeter/client.cpp", "content": "#include \n\n#include \n#include \n#include \n\n#include \"greeter.grpc.fb.h\"\n#include \"greeter_generated.h\"\n\nclass GreeterClient {\n public:\n GreeterClient(std::shared_ptr channel)\n : stub_(Greeter::NewStub(channel)) {}\n\n std::string SayHello(const std::string& name) {\n flatbuffers::grpc::MessageBuilder mb;\n auto name_offset = mb.CreateString(name);\n auto request_offset = CreateHelloRequest(mb, name_offset);\n mb.Finish(request_offset);\n auto request_msg = mb.ReleaseMessage();\n\n flatbuffers::grpc::Message response_msg;\n\n grpc::ClientContext context;\n\n auto status = stub_->SayHello(&context, request_msg, &response_msg);\n if (status.ok()) {\n const HelloReply* response = response_msg.GetRoot();\n return response->message()->str();\n } else {\n std::cerr << status.error_code() << \": \" << status.error_message()\n << std::endl;\n return \"RPC failed\";\n }\n }\n\n void SayManyHellos(const std::string& name, int num_greetings,\n std::function callback) {\n flatbuffers::grpc::MessageBuilder mb;\n auto name_offset = mb.CreateString(name);\n auto request_offset =\n CreateManyHellosRequest(mb, name_offset, num_greetings);\n mb.Finish(request_offset);\n auto request_msg = mb.ReleaseMessage();\n\n flatbuffers::grpc::Message response_msg;\n\n grpc::ClientContext context;\n\n auto stream = stub_->SayManyHellos(&context, request_msg);\n while (stream->Read(&response_msg)) {\n const HelloReply* response = response_msg.GetRoot();\n callback(response->message()->str());\n }\n auto status = stream->Finish();\n if (!status.ok()) {\n std::cerr << status.error_code() << \": \" << status.error_message()\n << std::endl;\n callback(\"RPC failed\");\n }\n }\n\n private:\n std::unique_ptr stub_;\n};\n\nint main(int argc, char** argv) {\n std::string server_address(\"localhost:50051\");\n\n auto channel =\n grpc::CreateChannel(server_address, grpc::InsecureChannelCredentials());\n GreeterClient greeter(channel);\n\n std::string name(\"world\");\n\n std::string message = greeter.SayHello(name);\n std::cerr << \"Greeter received: \" << message << std::endl;\n\n int num_greetings = 10;\n greeter.SayManyHellos(name, num_greetings, [](const std::string& message) {\n std::cerr << \"Greeter received: \" << message << std::endl;\n });\n\n return 0;\n}\n" }, { "path": "grpc/samples/greeter/greeter.fbs", "content": "table HelloReply {\n message:string;\n}\n\ntable HelloRequest {\n name:string;\n}\n\ntable ManyHellosRequest {\n name:string;\n num_greetings:int;\n}\n\nrpc_service Greeter {\n SayHello(HelloRequest):HelloReply;\n SayManyHellos(ManyHellosRequest):HelloReply (streaming: \"server\");\n}\n" }, { "path": "grpc/samples/greeter/server.cpp", "content": "#include \n\n#include \n#include \n#include \n\n#include \"greeter.grpc.fb.h\"\n#include \"greeter_generated.h\"\n\nclass GreeterServiceImpl final : public Greeter::Service {\n virtual grpc::Status SayHello(\n grpc::ServerContext* context,\n const flatbuffers::grpc::Message* request_msg,\n flatbuffers::grpc::Message* response_msg) override {\n flatbuffers::grpc::MessageBuilder mb_;\n\n // We call GetRoot to \"parse\" the message. Verification is already\n // performed by default. See the notes below for more details.\n const HelloRequest* request = request_msg->GetRoot();\n\n // Fields are retrieved as usual with FlatBuffers\n const std::string& name = request->name()->str();\n\n // `flatbuffers::grpc::MessageBuilder` is a `FlatBufferBuilder` with a\n // special allocator for efficient gRPC buffer transfer, but otherwise\n // usage is the same as usual.\n auto msg_offset = mb_.CreateString(\"Hello, \" + name);\n auto hello_offset = CreateHelloReply(mb_, msg_offset);\n mb_.Finish(hello_offset);\n\n // The `ReleaseMessage()` function detaches the message from the\n // builder, so we can transfer the resopnse to gRPC while simultaneously\n // detaching that memory buffer from the builer.\n *response_msg = mb_.ReleaseMessage();\n assert(response_msg->Verify());\n\n // Return an OK status.\n return grpc::Status::OK;\n }\n\n virtual grpc::Status SayManyHellos(\n grpc::ServerContext* context,\n const flatbuffers::grpc::Message* request_msg,\n grpc::ServerWriter>* writer)\n override {\n // The streaming usage below is simply a combination of standard gRPC\n // streaming with the FlatBuffers usage shown above.\n const ManyHellosRequest* request = request_msg->GetRoot();\n const std::string& name = request->name()->str();\n int num_greetings = request->num_greetings();\n\n for (int i = 0; i < num_greetings; i++) {\n auto msg_offset = mb_.CreateString(\"Many hellos, \" + name);\n auto hello_offset = CreateHelloReply(mb_, msg_offset);\n mb_.Finish(hello_offset);\n writer->Write(mb_.ReleaseMessage());\n }\n\n return grpc::Status::OK;\n }\n\n flatbuffers::grpc::MessageBuilder mb_;\n};\n\nvoid RunServer() {\n std::string server_address(\"0.0.0.0:50051\");\n GreeterServiceImpl service;\n\n grpc::ServerBuilder builder;\n builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());\n builder.RegisterService(&service);\n std::unique_ptr server(builder.BuildAndStart());\n std::cerr << \"Server listening on \" << server_address << std::endl;\n\n server->Wait();\n}\n\nint main(int argc, const char* argv[]) {\n RunServer();\n return 0;\n}\n" }, { "path": "grpc/src/compiler/BUILD.bazel", "content": "load(\"@rules_cc//cc:defs.bzl\", \"cc_library\")\n\npackage(\n default_visibility = [\"//visibility:public\"],\n)\n\nfilegroup(\n name = \"distribution\",\n srcs = [\n \"BUILD.bazel\",\n ] + glob([\n \"*.cc\",\n \"*.h\",\n ]),\n)\n\nfilegroup(\n name = \"common_headers\",\n srcs = [\n \"schema_interface.h\",\n ],\n)\n\ncc_library(\n name = \"cpp_generator\",\n srcs = [\n \"cpp_generator.cc\",\n ],\n hdrs = [\n \"cpp_generator.h\",\n \":common_headers\",\n ],\n include_prefix = \"src/compiler\",\n strip_include_prefix = \"/grpc/src/compiler\",\n deps = [\n \"//:flatbuffers\",\n ],\n)\n\ncc_library(\n name = \"go_generator\",\n srcs = [\n \"go_generator.cc\",\n ],\n hdrs = [\n \"go_generator.h\",\n \":common_headers\",\n ],\n include_prefix = \"src/compiler\",\n strip_include_prefix = \"/grpc/src/compiler\",\n deps = [\n \"//:flatbuffers\",\n ],\n)\n\ncc_library(\n name = \"java_generator\",\n srcs = [\n \"java_generator.cc\",\n ],\n hdrs = [\n \"java_generator.h\",\n \":common_headers\",\n ],\n include_prefix = \"src/compiler\",\n strip_include_prefix = \"/grpc/src/compiler\",\n deps = [\n \"//:flatbuffers\",\n ],\n)\n\ncc_library(\n name = \"python_generator\",\n hdrs = [\n \"python_generator.h\",\n ],\n include_prefix = \"src/compiler\",\n strip_include_prefix = \"/grpc/src/compiler\",\n deps = [\n \":python_generator_private\",\n ],\n)\n\ncc_library(\n name = \"python_generator_private\",\n srcs = [\n \"python_generator.cc\",\n ],\n hdrs = [\n \"python_generator.h\",\n \":common_headers\",\n ],\n include_prefix = \"src/compiler\",\n strip_include_prefix = \"/grpc/src/compiler\",\n visibility = [\"//visibility:private\"],\n deps = [\n \"//:flatbuffers\",\n \"//include/codegen:namer\",\n \"//include/codegen:python\",\n ],\n)\n\ncc_library(\n name = \"swift_generator\",\n srcs = [\n \"swift_generator.cc\",\n ],\n hdrs = [\n \"swift_generator.h\",\n \":common_headers\",\n ],\n include_prefix = \"src/compiler\",\n strip_include_prefix = \"/grpc/src/compiler\",\n deps = [\n \"//:flatbuffers\",\n ],\n)\n\ncc_library(\n name = \"ts_generator\",\n srcs = [\n \"ts_generator.cc\",\n ],\n hdrs = [\n \"ts_generator.h\",\n \":common_headers\",\n ],\n include_prefix = \"src/compiler\",\n strip_include_prefix = \"/grpc/src/compiler\",\n deps = [\n \"//:flatbuffers\",\n ],\n)\n" }, { "path": "grpc/src/compiler/cpp_generator.cc", "content": "#include \"src/compiler/cpp_generator.h\"\n\n#include \n#include \n\n#include \"flatbuffers/util.h\"\n\nnamespace grpc_cpp_generator {\nnamespace {\n\ntemplate \nstatic grpc::string as_string(T x) {\n std::ostringstream out;\n out << x;\n return out.str();\n}\n\nstatic inline bool ClientOnlyStreaming(const grpc_generator::Method* method) {\n return method->ClientStreaming() && !method->ServerStreaming();\n}\n\nstatic inline bool ServerOnlyStreaming(const grpc_generator::Method* method) {\n return !method->ClientStreaming() && method->ServerStreaming();\n}\n\nstatic grpc::string FilenameIdentifier(const grpc::string& filename) {\n grpc::string result;\n for (unsigned i = 0; i < filename.size(); i++) {\n char c = filename[i];\n if (isalnum(c)) {\n result.push_back(c);\n } else {\n static char hex[] = \"0123456789abcdef\";\n result.push_back('_');\n result.push_back(hex[(c >> 4) & 0xf]);\n result.push_back(hex[c & 0xf]);\n }\n }\n return result;\n}\n\ntemplate \nstatic T* array_end(T (&array)[N]) {\n return array + N;\n}\n\nstatic void PrintIncludes(grpc_generator::Printer* printer,\n const std::vector& headers,\n const Parameters& params) {\n std::map vars;\n\n vars[\"l\"] = params.use_system_headers ? '<' : '\"';\n vars[\"r\"] = params.use_system_headers ? '>' : '\"';\n\n auto& s = params.grpc_search_path;\n if (!s.empty()) {\n vars[\"l\"] += s;\n if (s[s.size() - 1] != '/') {\n vars[\"l\"] += '/';\n }\n }\n\n for (auto i = headers.begin(); i != headers.end(); i++) {\n vars[\"h\"] = *i;\n printer->Print(vars, \"#include $l$$h$$r$\\n\");\n }\n if (params.generate_callback_api) {\n // Callback API headers (guarded later by feature macro in emitted code).\n static const char* cb_headers[] = {\n \"grpcpp/impl/codegen/callback_common.h\",\n \"grpcpp/impl/codegen/server_callback_handlers.h\",\n \"grpcpp/support/client_callback.h\"};\n for (auto& h : cb_headers) {\n vars[\"h\"] = h;\n printer->Print(vars, \"#include $l$$h$$r$\\n\");\n }\n }\n}\n\n} // namespace\n\ngrpc::string GetHeaderPrologue(grpc_generator::File* file,\n const Parameters& params) {\n grpc::string output;\n {\n // Scope the output stream so it closes and finalizes output to the string.\n auto printer = file->CreatePrinter(&output);\n std::map vars;\n\n vars[\"filename\"] = file->filename();\n vars[\"filename_identifier\"] = FilenameIdentifier(file->filename());\n vars[\"filename_base\"] = file->filename_without_ext();\n vars[\"message_header_ext\"] = params.message_header_extension;\n\n printer->Print(vars, \"// Generated by the gRPC C++ plugin.\\n\");\n printer->Print(vars,\n \"// If you make any local change, they will be lost.\\n\");\n printer->Print(vars, \"// source: $filename$\\n\");\n grpc::string leading_comments = file->GetLeadingComments(\"//\");\n if (!leading_comments.empty()) {\n printer->Print(vars, \"// Original file comments:\\n\");\n printer->Print(leading_comments.c_str());\n }\n printer->Print(vars, \"#ifndef GRPC_$filename_identifier$__INCLUDED\\n\");\n printer->Print(vars, \"#define GRPC_$filename_identifier$__INCLUDED\\n\");\n printer->Print(vars, \"\\n\");\n printer->Print(vars, \"#include \\\"$filename_base$$message_header_ext$\\\"\\n\");\n printer->Print(vars, file->additional_headers().c_str());\n printer->Print(vars, \"\\n\");\n }\n return output;\n}\n\ngrpc::string GetHeaderIncludes(grpc_generator::File* file,\n const Parameters& params) {\n grpc::string output;\n {\n // Scope the output stream so it closes and finalizes output to the string.\n auto printer = file->CreatePrinter(&output);\n std::map vars;\n\n static const char* headers_strs[] = {\n \"grpcpp/impl/codegen/async_stream.h\",\n \"grpcpp/impl/codegen/async_unary_call.h\",\n \"grpcpp/impl/codegen/method_handler.h\",\n \"grpcpp/impl/codegen/proto_utils.h\",\n \"grpcpp/impl/codegen/rpc_method.h\",\n \"grpcpp/impl/codegen/service_type.h\",\n \"grpcpp/impl/codegen/status.h\",\n \"grpcpp/impl/codegen/stub_options.h\",\n \"grpcpp/impl/codegen/sync_stream.h\"};\n std::vector headers(headers_strs, array_end(headers_strs));\n PrintIncludes(printer.get(), headers, params);\n printer->Print(vars, \"\\n\");\n printer->Print(vars, \"namespace grpc {\\n\");\n printer->Print(vars, \"class CompletionQueue;\\n\");\n printer->Print(vars, \"class Channel;\\n\");\n printer->Print(vars, \"class ServerCompletionQueue;\\n\");\n printer->Print(vars, \"class ServerContext;\\n\");\n printer->Print(vars, \"} // namespace grpc\\n\\n\");\n\n if (!file->package().empty()) {\n std::vector parts = file->package_parts();\n\n for (auto part = parts.begin(); part != parts.end(); part++) {\n vars[\"part\"] = *part;\n printer->Print(vars, \"namespace $part$ {\\n\");\n }\n printer->Print(vars, \"\\n\");\n }\n }\n return output;\n}\n\nnamespace {\n\nstatic void PrintHeaderClientMethodInterfaces(\n grpc_generator::Printer* printer, const grpc_generator::Method* method,\n std::map* vars, bool is_public) {\n (*vars)[\"Method\"] = method->name();\n (*vars)[\"Request\"] = method->input_type_name();\n (*vars)[\"Response\"] = method->output_type_name();\n\n struct {\n grpc::string prefix;\n grpc::string method_params; // extra arguments to method\n grpc::string raw_args; // extra arguments to raw version of method\n } async_prefixes[] = {{\"Async\", \", void* tag\", \", tag\"},\n {\"PrepareAsync\", \"\", \"\"}};\n\n if (is_public) {\n if (method->NoStreaming()) {\n printer->Print(\n *vars,\n \"virtual ::grpc::Status $Method$(::grpc::ClientContext* context, \"\n \"const $Request$& request, $Response$* response) = 0;\\n\");\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n printer->Print(\n *vars,\n \"std::unique_ptr< \"\n \"::grpc::ClientAsyncResponseReaderInterface< $Response$>> \"\n \"$AsyncPrefix$$Method$(::grpc::ClientContext* context, \"\n \"const $Request$& request, \"\n \"::grpc::CompletionQueue* cq) {\\n\");\n printer->Indent();\n printer->Print(\n *vars,\n \"return std::unique_ptr< \"\n \"::grpc::ClientAsyncResponseReaderInterface< $Response$>>(\"\n \"$AsyncPrefix$$Method$Raw(context, request, cq));\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n }\n } else if (ClientOnlyStreaming(method)) {\n printer->Print(\n *vars,\n \"std::unique_ptr< ::grpc::ClientWriterInterface< $Request$>>\"\n \" $Method$(\"\n \"::grpc::ClientContext* context, $Response$* response) {\\n\");\n printer->Indent();\n printer->Print(\n *vars,\n \"return std::unique_ptr< ::grpc::ClientWriterInterface< $Request$>>\"\n \"($Method$Raw(context, response));\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncMethodParams\"] = async_prefix.method_params;\n (*vars)[\"AsyncRawArgs\"] = async_prefix.raw_args;\n printer->Print(\n *vars,\n \"std::unique_ptr< ::grpc::ClientAsyncWriterInterface< $Request$>>\"\n \" $AsyncPrefix$$Method$(::grpc::ClientContext* context, \"\n \"$Response$* \"\n \"response, \"\n \"::grpc::CompletionQueue* cq$AsyncMethodParams$) {\\n\");\n printer->Indent();\n printer->Print(*vars,\n \"return std::unique_ptr< \"\n \"::grpc::ClientAsyncWriterInterface< $Request$>>(\"\n \"$AsyncPrefix$$Method$Raw(context, response, \"\n \"cq$AsyncRawArgs$));\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n }\n } else if (ServerOnlyStreaming(method)) {\n printer->Print(\n *vars,\n \"std::unique_ptr< ::grpc::ClientReaderInterface< $Response$>>\"\n \" $Method$(::grpc::ClientContext* context, const $Request$& request)\"\n \" {\\n\");\n printer->Indent();\n printer->Print(\n *vars,\n \"return std::unique_ptr< ::grpc::ClientReaderInterface< $Response$>>\"\n \"($Method$Raw(context, request));\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncMethodParams\"] = async_prefix.method_params;\n (*vars)[\"AsyncRawArgs\"] = async_prefix.raw_args;\n printer->Print(\n *vars,\n \"std::unique_ptr< ::grpc::ClientAsyncReaderInterface< $Response$>> \"\n \"$AsyncPrefix$$Method$(\"\n \"::grpc::ClientContext* context, const $Request$& request, \"\n \"::grpc::CompletionQueue* cq$AsyncMethodParams$) {\\n\");\n printer->Indent();\n printer->Print(\n *vars,\n \"return std::unique_ptr< \"\n \"::grpc::ClientAsyncReaderInterface< $Response$>>(\"\n \"$AsyncPrefix$$Method$Raw(context, request, cq$AsyncRawArgs$));\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n }\n } else if (method->BidiStreaming()) {\n printer->Print(*vars,\n \"std::unique_ptr< ::grpc::ClientReaderWriterInterface< \"\n \"$Request$, $Response$>> \"\n \"$Method$(::grpc::ClientContext* context) {\\n\");\n printer->Indent();\n printer->Print(\n *vars,\n \"return std::unique_ptr< \"\n \"::grpc::ClientReaderWriterInterface< $Request$, $Response$>>(\"\n \"$Method$Raw(context));\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncMethodParams\"] = async_prefix.method_params;\n (*vars)[\"AsyncRawArgs\"] = async_prefix.raw_args;\n printer->Print(\n *vars,\n \"std::unique_ptr< \"\n \"::grpc::ClientAsyncReaderWriterInterface< $Request$, $Response$>> \"\n \"$AsyncPrefix$$Method$(::grpc::ClientContext* context, \"\n \"::grpc::CompletionQueue* cq$AsyncMethodParams$) {\\n\");\n printer->Indent();\n printer->Print(\n *vars,\n \"return std::unique_ptr< \"\n \"::grpc::ClientAsyncReaderWriterInterface< $Request$, $Response$>>(\"\n \"$AsyncPrefix$$Method$Raw(context, cq$AsyncRawArgs$));\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n }\n }\n } else {\n if (method->NoStreaming()) {\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n printer->Print(\n *vars,\n \"virtual ::grpc::ClientAsyncResponseReaderInterface< $Response$>* \"\n \"$AsyncPrefix$$Method$Raw(::grpc::ClientContext* context, \"\n \"const $Request$& request, \"\n \"::grpc::CompletionQueue* cq) = 0;\\n\");\n }\n } else if (ClientOnlyStreaming(method)) {\n printer->Print(\n *vars,\n \"virtual ::grpc::ClientWriterInterface< $Request$>*\"\n \" $Method$Raw(\"\n \"::grpc::ClientContext* context, $Response$* response) = 0;\\n\");\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncMethodParams\"] = async_prefix.method_params;\n printer->Print(\n *vars,\n \"virtual ::grpc::ClientAsyncWriterInterface< $Request$>*\"\n \" $AsyncPrefix$$Method$Raw(::grpc::ClientContext* context, \"\n \"$Response$* response, \"\n \"::grpc::CompletionQueue* cq$AsyncMethodParams$) = 0;\\n\");\n }\n } else if (ServerOnlyStreaming(method)) {\n printer->Print(\n *vars,\n \"virtual ::grpc::ClientReaderInterface< $Response$>* \"\n \"$Method$Raw(\"\n \"::grpc::ClientContext* context, const $Request$& request) = 0;\\n\");\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncMethodParams\"] = async_prefix.method_params;\n printer->Print(\n *vars,\n \"virtual ::grpc::ClientAsyncReaderInterface< $Response$>* \"\n \"$AsyncPrefix$$Method$Raw(\"\n \"::grpc::ClientContext* context, const $Request$& request, \"\n \"::grpc::CompletionQueue* cq$AsyncMethodParams$) = 0;\\n\");\n }\n } else if (method->BidiStreaming()) {\n printer->Print(*vars,\n \"virtual ::grpc::ClientReaderWriterInterface< $Request$, \"\n \"$Response$>* \"\n \"$Method$Raw(::grpc::ClientContext* context) = 0;\\n\");\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncMethodParams\"] = async_prefix.method_params;\n printer->Print(\n *vars,\n \"virtual ::grpc::ClientAsyncReaderWriterInterface< \"\n \"$Request$, $Response$>* \"\n \"$AsyncPrefix$$Method$Raw(::grpc::ClientContext* context, \"\n \"::grpc::CompletionQueue* cq$AsyncMethodParams$) = 0;\\n\");\n }\n }\n }\n}\n\nstatic void PrintHeaderClientMethod(grpc_generator::Printer* printer,\n const grpc_generator::Method* method,\n std::map* vars,\n bool is_public) {\n (*vars)[\"Method\"] = method->name();\n (*vars)[\"Request\"] = method->input_type_name();\n (*vars)[\"Response\"] = method->output_type_name();\n struct {\n grpc::string prefix;\n grpc::string method_params; // extra arguments to method\n grpc::string raw_args; // extra arguments to raw version of method\n } async_prefixes[] = {{\"Async\", \", void* tag\", \", tag\"},\n {\"PrepareAsync\", \"\", \"\"}};\n\n if (is_public) {\n if (method->NoStreaming()) {\n printer->Print(\n *vars,\n \"::grpc::Status $Method$(::grpc::ClientContext* context, \"\n \"const $Request$& request, $Response$* response) override;\\n\");\n if ((*vars)[\"generate_callback_api\"] == \"1\") {\n // Native gRPC callback unary wrappers (function callback & reactor\n // variants).\n printer->Print(*vars,\n \"// Callback unary (function form). Request/response \"\n \"must outlive callback.\\n\");\n printer->Print(*vars,\n \"void async_$Method$(::grpc::ClientContext* context, \"\n \"const $Request$& request, $Response$* response, \"\n \"std::function on_done);\\n\");\n printer->Print(*vars, \"// Callback unary (reactor form).\\n\");\n printer->Print(*vars,\n \"void async_$Method$(::grpc::ClientContext* context, \"\n \"const $Request$& request, $Response$* response, \"\n \"::grpc::ClientUnaryReactor* reactor);\\n\");\n }\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n printer->Print(\n *vars,\n \"std::unique_ptr< ::grpc::ClientAsyncResponseReader< $Response$>> \"\n \"$AsyncPrefix$$Method$(::grpc::ClientContext* context, \"\n \"const $Request$& request, \"\n \"::grpc::CompletionQueue* cq) {\\n\");\n printer->Indent();\n printer->Print(*vars,\n \"return std::unique_ptr< \"\n \"::grpc::ClientAsyncResponseReader< $Response$>>(\"\n \"$AsyncPrefix$$Method$Raw(context, request, cq));\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n }\n } else if (ClientOnlyStreaming(method)) {\n printer->Print(\n *vars,\n \"std::unique_ptr< ::grpc::ClientWriter< $Request$>>\"\n \" $Method$(\"\n \"::grpc::ClientContext* context, $Response$* response) {\\n\");\n printer->Indent();\n printer->Print(*vars,\n \"return std::unique_ptr< ::grpc::ClientWriter< $Request$>>\"\n \"($Method$Raw(context, response));\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n if ((*vars)[\"generate_callback_api\"] == \"1\") {\n printer->Print(*vars, \"// Client streaming callback reactor entry.\\n\");\n printer->Print(\n *vars,\n \"void async_$Method$(::grpc::ClientContext* context, $Response$* \"\n \"response, ::grpc::ClientWriteReactor< $Request$ >* reactor);\\n\");\n }\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncMethodParams\"] = async_prefix.method_params;\n (*vars)[\"AsyncRawArgs\"] = async_prefix.raw_args;\n printer->Print(*vars,\n \"std::unique_ptr< ::grpc::ClientAsyncWriter< $Request$>>\"\n \" $AsyncPrefix$$Method$(::grpc::ClientContext* context, \"\n \"$Response$* response, \"\n \"::grpc::CompletionQueue* cq$AsyncMethodParams$) {\\n\");\n printer->Indent();\n printer->Print(\n *vars,\n \"return std::unique_ptr< ::grpc::ClientAsyncWriter< $Request$>>(\"\n \"$AsyncPrefix$$Method$Raw(context, response, \"\n \"cq$AsyncRawArgs$));\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n }\n } else if (ServerOnlyStreaming(method)) {\n printer->Print(\n *vars,\n \"std::unique_ptr< ::grpc::ClientReader< $Response$>>\"\n \" $Method$(::grpc::ClientContext* context, const $Request$& request)\"\n \" {\\n\");\n printer->Indent();\n printer->Print(\n *vars,\n \"return std::unique_ptr< ::grpc::ClientReader< $Response$>>\"\n \"($Method$Raw(context, request));\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n if ((*vars)[\"generate_callback_api\"] == \"1\") {\n printer->Print(*vars, \"// Server streaming callback reactor entry.\\n\");\n printer->Print(*vars,\n \"void async_$Method$(::grpc::ClientContext* context, \"\n \"const $Request$& request, ::grpc::ClientReadReactor< \"\n \"$Response$ >* reactor);\\n\");\n }\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncMethodParams\"] = async_prefix.method_params;\n (*vars)[\"AsyncRawArgs\"] = async_prefix.raw_args;\n printer->Print(\n *vars,\n \"std::unique_ptr< ::grpc::ClientAsyncReader< $Response$>> \"\n \"$AsyncPrefix$$Method$(\"\n \"::grpc::ClientContext* context, const $Request$& request, \"\n \"::grpc::CompletionQueue* cq$AsyncMethodParams$) {\\n\");\n printer->Indent();\n printer->Print(\n *vars,\n \"return std::unique_ptr< ::grpc::ClientAsyncReader< $Response$>>(\"\n \"$AsyncPrefix$$Method$Raw(context, request, cq$AsyncRawArgs$));\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n }\n } else if (method->BidiStreaming()) {\n printer->Print(\n *vars,\n \"std::unique_ptr< ::grpc::ClientReaderWriter< $Request$, $Response$>>\"\n \" $Method$(::grpc::ClientContext* context) {\\n\");\n printer->Indent();\n printer->Print(*vars,\n \"return std::unique_ptr< \"\n \"::grpc::ClientReaderWriter< $Request$, $Response$>>(\"\n \"$Method$Raw(context));\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n if ((*vars)[\"generate_callback_api\"] == \"1\") {\n printer->Print(*vars,\n \"// Bidirectional streaming callback reactor entry.\\n\");\n printer->Print(\n *vars,\n \"void async_$Method$(::grpc::ClientContext* context, \"\n \"::grpc::ClientBidiReactor< $Request$, $Response$ >* reactor);\\n\");\n }\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncMethodParams\"] = async_prefix.method_params;\n (*vars)[\"AsyncRawArgs\"] = async_prefix.raw_args;\n printer->Print(*vars,\n \"std::unique_ptr< ::grpc::ClientAsyncReaderWriter< \"\n \"$Request$, $Response$>> \"\n \"$AsyncPrefix$$Method$(::grpc::ClientContext* context, \"\n \"::grpc::CompletionQueue* cq$AsyncMethodParams$) {\\n\");\n printer->Indent();\n printer->Print(\n *vars,\n \"return std::unique_ptr< \"\n \"::grpc::ClientAsyncReaderWriter< $Request$, $Response$>>(\"\n \"$AsyncPrefix$$Method$Raw(context, cq$AsyncRawArgs$));\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n }\n }\n } else {\n if (method->NoStreaming()) {\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n printer->Print(\n *vars,\n \"::grpc::ClientAsyncResponseReader< $Response$>* \"\n \"$AsyncPrefix$$Method$Raw(::grpc::ClientContext* context, \"\n \"const $Request$& request, \"\n \"::grpc::CompletionQueue* cq) override;\\n\");\n }\n if ((*vars)[\"generate_callback_api\"] == \"1\") {\n // Native callback unary forms declared earlier (no private sync helper\n // needed).\n }\n } else if (ClientOnlyStreaming(method)) {\n printer->Print(*vars,\n \"::grpc::ClientWriter< $Request$>* $Method$Raw(\"\n \"::grpc::ClientContext* context, $Response$* response) \"\n \"override;\\n\");\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncMethodParams\"] = async_prefix.method_params;\n (*vars)[\"AsyncRawArgs\"] = async_prefix.raw_args;\n printer->Print(\n *vars,\n \"::grpc::ClientAsyncWriter< $Request$>* $AsyncPrefix$$Method$Raw(\"\n \"::grpc::ClientContext* context, $Response$* response, \"\n \"::grpc::CompletionQueue* cq$AsyncMethodParams$) override;\\n\");\n }\n } else if (ServerOnlyStreaming(method)) {\n printer->Print(*vars,\n \"::grpc::ClientReader< $Response$>* $Method$Raw(\"\n \"::grpc::ClientContext* context, const $Request$& request)\"\n \" override;\\n\");\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncMethodParams\"] = async_prefix.method_params;\n (*vars)[\"AsyncRawArgs\"] = async_prefix.raw_args;\n printer->Print(\n *vars,\n \"::grpc::ClientAsyncReader< $Response$>* $AsyncPrefix$$Method$Raw(\"\n \"::grpc::ClientContext* context, const $Request$& request, \"\n \"::grpc::CompletionQueue* cq$AsyncMethodParams$) override;\\n\");\n }\n } else if (method->BidiStreaming()) {\n printer->Print(*vars,\n \"::grpc::ClientReaderWriter< $Request$, $Response$>* \"\n \"$Method$Raw(::grpc::ClientContext* context) override;\\n\");\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncMethodParams\"] = async_prefix.method_params;\n (*vars)[\"AsyncRawArgs\"] = async_prefix.raw_args;\n printer->Print(\n *vars,\n \"::grpc::ClientAsyncReaderWriter< $Request$, $Response$>* \"\n \"$AsyncPrefix$$Method$Raw(::grpc::ClientContext* context, \"\n \"::grpc::CompletionQueue* cq$AsyncMethodParams$) override;\\n\");\n }\n }\n }\n}\n\nstatic void PrintHeaderClientMethodData(\n grpc_generator::Printer* printer, const grpc_generator::Method* method,\n std::map* vars) {\n (*vars)[\"Method\"] = method->name();\n printer->Print(*vars,\n \"const ::grpc::internal::RpcMethod rpcmethod_$Method$_;\\n\");\n}\n\nstatic void PrintHeaderServerMethodSync(\n grpc_generator::Printer* printer, const grpc_generator::Method* method,\n std::map* vars) {\n (*vars)[\"Method\"] = method->name();\n (*vars)[\"Request\"] = method->input_type_name();\n (*vars)[\"Response\"] = method->output_type_name();\n printer->Print(method->GetLeadingComments(\"//\").c_str());\n if (method->NoStreaming()) {\n printer->Print(*vars,\n \"virtual ::grpc::Status $Method$(\"\n \"::grpc::ServerContext* context, const $Request$* request, \"\n \"$Response$* response);\\n\");\n } else if (ClientOnlyStreaming(method)) {\n printer->Print(*vars,\n \"virtual ::grpc::Status $Method$(\"\n \"::grpc::ServerContext* context, \"\n \"::grpc::ServerReader< $Request$>* reader, \"\n \"$Response$* response);\\n\");\n } else if (ServerOnlyStreaming(method)) {\n printer->Print(*vars,\n \"virtual ::grpc::Status $Method$(\"\n \"::grpc::ServerContext* context, const $Request$* request, \"\n \"::grpc::ServerWriter< $Response$>* writer);\\n\");\n } else if (method->BidiStreaming()) {\n printer->Print(\n *vars,\n \"virtual ::grpc::Status $Method$(\"\n \"::grpc::ServerContext* context, \"\n \"::grpc::ServerReaderWriter< $Response$, $Request$>* stream);\"\n \"\\n\");\n }\n printer->Print(method->GetTrailingComments(\"//\").c_str());\n}\n\nstatic void PrintHeaderServerMethodAsync(\n grpc_generator::Printer* printer, const grpc_generator::Method* method,\n std::map* vars) {\n (*vars)[\"Method\"] = method->name();\n (*vars)[\"Request\"] = method->input_type_name();\n (*vars)[\"Response\"] = method->output_type_name();\n printer->Print(*vars, \"template \\n\");\n printer->Print(*vars,\n \"class WithAsyncMethod_$Method$ : public BaseClass {\\n\");\n printer->Print(\n \" private:\\n\"\n \" void BaseClassMustBeDerivedFromService(const Service */*service*/) \"\n \"{}\\n\");\n printer->Print(\" public:\\n\");\n printer->Indent();\n printer->Print(*vars,\n \"WithAsyncMethod_$Method$() {\\n\"\n \" ::grpc::Service::MarkMethodAsync($Idx$);\\n\"\n \"}\\n\");\n printer->Print(*vars,\n \"~WithAsyncMethod_$Method$() override {\\n\"\n \" BaseClassMustBeDerivedFromService(this);\\n\"\n \"}\\n\");\n if (method->NoStreaming()) {\n printer->Print(\n *vars,\n \"// disable synchronous version of this method\\n\"\n \"::grpc::Status $Method$(\"\n \"::grpc::ServerContext* /*context*/, const $Request$* /*request*/, \"\n \"$Response$* /*response*/) final override {\\n\"\n \" abort();\\n\"\n \" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \\\"\\\");\\n\"\n \"}\\n\");\n printer->Print(\n *vars,\n \"void Request$Method$(\"\n \"::grpc::ServerContext* context, $Request$* request, \"\n \"::grpc::ServerAsyncResponseWriter< $Response$>* response, \"\n \"::grpc::CompletionQueue* new_call_cq, \"\n \"::grpc::ServerCompletionQueue* notification_cq, void *tag) {\\n\");\n printer->Print(*vars,\n \" ::grpc::Service::RequestAsyncUnary($Idx$, context, \"\n \"request, response, new_call_cq, notification_cq, tag);\\n\");\n printer->Print(\"}\\n\");\n } else if (ClientOnlyStreaming(method)) {\n printer->Print(\n *vars,\n \"// disable synchronous version of this method\\n\"\n \"::grpc::Status $Method$(\"\n \"::grpc::ServerContext* /*context*/, \"\n \"::grpc::ServerReader< $Request$>* /*reader*/, \"\n \"$Response$* /*response*/) final override {\\n\"\n \" abort();\\n\"\n \" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \\\"\\\");\\n\"\n \"}\\n\");\n printer->Print(\n *vars,\n \"void Request$Method$(\"\n \"::grpc::ServerContext* context, \"\n \"::grpc::ServerAsyncReader< $Response$, $Request$>* reader, \"\n \"::grpc::CompletionQueue* new_call_cq, \"\n \"::grpc::ServerCompletionQueue* notification_cq, void *tag) {\\n\");\n printer->Print(*vars,\n \" ::grpc::Service::RequestAsyncClientStreaming($Idx$, \"\n \"context, reader, new_call_cq, notification_cq, tag);\\n\");\n printer->Print(\"}\\n\");\n } else if (ServerOnlyStreaming(method)) {\n printer->Print(\n *vars,\n \"// disable synchronous version of this method\\n\"\n \"::grpc::Status $Method$(\"\n \"::grpc::ServerContext* /*context*/, const $Request$* /*request*/, \"\n \"::grpc::ServerWriter< $Response$>* /*writer*/) final override \"\n \"{\\n\"\n \" abort();\\n\"\n \" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \\\"\\\");\\n\"\n \"}\\n\");\n printer->Print(\n *vars,\n \"void Request$Method$(\"\n \"::grpc::ServerContext* context, $Request$* request, \"\n \"::grpc::ServerAsyncWriter< $Response$>* writer, \"\n \"::grpc::CompletionQueue* new_call_cq, \"\n \"::grpc::ServerCompletionQueue* notification_cq, void *tag) {\\n\");\n printer->Print(\n *vars,\n \" ::grpc::Service::RequestAsyncServerStreaming($Idx$, \"\n \"context, request, writer, new_call_cq, notification_cq, tag);\\n\");\n printer->Print(\"}\\n\");\n } else if (method->BidiStreaming()) {\n printer->Print(\n *vars,\n \"// disable synchronous version of this method\\n\"\n \"::grpc::Status $Method$(\"\n \"::grpc::ServerContext* /*context*/, \"\n \"::grpc::ServerReaderWriter< $Response$, $Request$>* /*stream*/) \"\n \"final override {\\n\"\n \" abort();\\n\"\n \" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \\\"\\\");\\n\"\n \"}\\n\");\n printer->Print(\n *vars,\n \"void Request$Method$(\"\n \"::grpc::ServerContext* context, \"\n \"::grpc::ServerAsyncReaderWriter< $Response$, $Request$>* stream, \"\n \"::grpc::CompletionQueue* new_call_cq, \"\n \"::grpc::ServerCompletionQueue* notification_cq, void *tag) {\\n\");\n printer->Print(*vars,\n \" ::grpc::Service::RequestAsyncBidiStreaming($Idx$, \"\n \"context, stream, new_call_cq, notification_cq, tag);\\n\");\n printer->Print(\"}\\n\");\n }\n printer->Outdent();\n printer->Print(*vars, \"};\\n\");\n}\n\nstatic void PrintHeaderServerMethodStreamedUnary(\n grpc_generator::Printer* printer, const grpc_generator::Method* method,\n std::map* vars) {\n (*vars)[\"Method\"] = method->name();\n (*vars)[\"Request\"] = method->input_type_name();\n (*vars)[\"Response\"] = method->output_type_name();\n if (method->NoStreaming()) {\n printer->Print(*vars, \"template \\n\");\n printer->Print(*vars,\n \"class WithStreamedUnaryMethod_$Method$ : \"\n \"public BaseClass {\\n\");\n printer->Print(\n \" private:\\n\"\n \" void BaseClassMustBeDerivedFromService(const Service */*service*/) \"\n \"{}\\n\");\n printer->Print(\" public:\\n\");\n printer->Indent();\n printer->Print(*vars,\n \"WithStreamedUnaryMethod_$Method$() {\\n\"\n \" ::grpc::Service::MarkMethodStreamed($Idx$,\\n\"\n \" new ::grpc::internal::StreamedUnaryHandler< $Request$, \"\n \"$Response$>(std::bind\"\n \"(&WithStreamedUnaryMethod_$Method$::\"\n \"Streamed$Method$, this, std::placeholders::_1, \"\n \"std::placeholders::_2)));\\n\"\n \"}\\n\");\n printer->Print(*vars,\n \"~WithStreamedUnaryMethod_$Method$() override {\\n\"\n \" BaseClassMustBeDerivedFromService(this);\\n\"\n \"}\\n\");\n printer->Print(\n *vars,\n \"// disable regular version of this method\\n\"\n \"::grpc::Status $Method$(\"\n \"::grpc::ServerContext* /*context*/, const $Request$* /*request*/, \"\n \"$Response$* /*response*/) final override {\\n\"\n \" abort();\\n\"\n \" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \\\"\\\");\\n\"\n \"}\\n\");\n printer->Print(*vars,\n \"// replace default version of method with streamed unary\\n\"\n \"virtual ::grpc::Status Streamed$Method$(\"\n \"::grpc::ServerContext* context, \"\n \"::grpc::ServerUnaryStreamer< \"\n \"$Request$,$Response$>* server_unary_streamer)\"\n \" = 0;\\n\");\n printer->Outdent();\n printer->Print(*vars, \"};\\n\");\n }\n}\n\nstatic void PrintHeaderServerMethodSplitStreaming(\n grpc_generator::Printer* printer, const grpc_generator::Method* method,\n std::map* vars) {\n (*vars)[\"Method\"] = method->name();\n (*vars)[\"Request\"] = method->input_type_name();\n (*vars)[\"Response\"] = method->output_type_name();\n if (ServerOnlyStreaming(method)) {\n printer->Print(*vars, \"template \\n\");\n printer->Print(*vars,\n \"class WithSplitStreamingMethod_$Method$ : \"\n \"public BaseClass {\\n\");\n printer->Print(\n \" private:\\n\"\n \" void BaseClassMustBeDerivedFromService(const Service */*service*/) \"\n \"{ }\\n\");\n printer->Print(\" public:\\n\");\n printer->Indent();\n printer->Print(\n *vars,\n \"WithSplitStreamingMethod_$Method$() {\\n\"\n \" ::grpc::Service::MarkMethodStreamed($Idx$,\\n\"\n \" new ::grpc::internal::SplitServerStreamingHandler< $Request$, \"\n \"$Response$>(std::bind\"\n \"(&WithSplitStreamingMethod_$Method$::\"\n \"Streamed$Method$, this, std::placeholders::_1, \"\n \"std::placeholders::_2)));\\n\"\n \"}\\n\");\n printer->Print(*vars,\n \"~WithSplitStreamingMethod_$Method$() override {\\n\"\n \" BaseClassMustBeDerivedFromService(this);\\n\"\n \"}\\n\");\n printer->Print(\n *vars,\n \"// disable regular version of this method\\n\"\n \"::grpc::Status $Method$(\"\n \"::grpc::ServerContext* /*context*/, const $Request$* /*request*/, \"\n \"::grpc::ServerWriter< $Response$>* /*writer*/) final override \"\n \"{\\n\"\n \" abort();\\n\"\n \" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \\\"\\\");\\n\"\n \"}\\n\");\n printer->Print(*vars,\n \"// replace default version of method with split streamed\\n\"\n \"virtual ::grpc::Status Streamed$Method$(\"\n \"::grpc::ServerContext* context, \"\n \"::grpc::ServerSplitStreamer< \"\n \"$Request$,$Response$>* server_split_streamer)\"\n \" = 0;\\n\");\n printer->Outdent();\n printer->Print(*vars, \"};\\n\");\n }\n}\n\nstatic void PrintHeaderServerMethodGeneric(\n grpc_generator::Printer* printer, const grpc_generator::Method* method,\n std::map* vars) {\n (*vars)[\"Method\"] = method->name();\n (*vars)[\"Request\"] = method->input_type_name();\n (*vars)[\"Response\"] = method->output_type_name();\n printer->Print(*vars, \"template \\n\");\n printer->Print(*vars,\n \"class WithGenericMethod_$Method$ : public BaseClass {\\n\");\n printer->Print(\n \" private:\\n\"\n \" void BaseClassMustBeDerivedFromService(const Service */*service*/) \"\n \"{}\\n\");\n printer->Print(\" public:\\n\");\n printer->Indent();\n printer->Print(*vars,\n \"WithGenericMethod_$Method$() {\\n\"\n \" ::grpc::Service::MarkMethodGeneric($Idx$);\\n\"\n \"}\\n\");\n printer->Print(*vars,\n \"~WithGenericMethod_$Method$() override {\\n\"\n \" BaseClassMustBeDerivedFromService(this);\\n\"\n \"}\\n\");\n if (method->NoStreaming()) {\n printer->Print(\n *vars,\n \"// disable synchronous version of this method\\n\"\n \"::grpc::Status $Method$(\"\n \"::grpc::ServerContext* /*context*/, const $Request$* /*request*/, \"\n \"$Response$* /*response*/) final override {\\n\"\n \" abort();\\n\"\n \" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \\\"\\\");\\n\"\n \"}\\n\");\n } else if (ClientOnlyStreaming(method)) {\n printer->Print(\n *vars,\n \"// disable synchronous version of this method\\n\"\n \"::grpc::Status $Method$(\"\n \"::grpc::ServerContext* /*context*/, \"\n \"::grpc::ServerReader< $Request$>* /*reader*/, \"\n \"$Response$* /*response*/) final override {\\n\"\n \" abort();\\n\"\n \" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \\\"\\\");\\n\"\n \"}\\n\");\n } else if (ServerOnlyStreaming(method)) {\n printer->Print(\n *vars,\n \"// disable synchronous version of this method\\n\"\n \"::grpc::Status $Method$(\"\n \"::grpc::ServerContext* /*context*/, const $Request$* /*request*/, \"\n \"::grpc::ServerWriter< $Response$>* /*writer*/) final override \"\n \"{\\n\"\n \" abort();\\n\"\n \" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \\\"\\\");\\n\"\n \"}\\n\");\n } else if (method->BidiStreaming()) {\n printer->Print(\n *vars,\n \"// disable synchronous version of this method\\n\"\n \"::grpc::Status $Method$(\"\n \"::grpc::ServerContext* /*context*/, \"\n \"::grpc::ServerReaderWriter< $Response$, $Request$>* /*stream*/) \"\n \"final override {\\n\"\n \" abort();\\n\"\n \" return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \\\"\\\");\\n\"\n \"}\\n\");\n }\n printer->Outdent();\n printer->Print(*vars, \"};\\n\");\n}\n\nstatic void PrintHeaderService(grpc_generator::Printer* printer,\n const grpc_generator::Service* service,\n std::map* vars) {\n (*vars)[\"Service\"] = service->name();\n\n printer->Print(service->GetLeadingComments(\"//\").c_str());\n printer->Print(*vars,\n \"class $Service$ final {\\n\"\n \" public:\\n\");\n printer->Indent();\n\n // Service metadata\n printer->Print(*vars,\n \"static constexpr char const* service_full_name() {\\n\"\n \" return \\\"$Package$$Service$\\\";\\n\"\n \"}\\n\");\n\n // Client side\n printer->Print(\n \"class StubInterface {\\n\"\n \" public:\\n\");\n printer->Indent();\n printer->Print(\"virtual ~StubInterface() {}\\n\");\n for (int i = 0; i < service->method_count(); ++i) {\n printer->Print(service->method(i)->GetLeadingComments(\"//\").c_str());\n PrintHeaderClientMethodInterfaces(printer, service->method(i).get(), vars,\n true);\n printer->Print(service->method(i)->GetTrailingComments(\"//\").c_str());\n }\n printer->Outdent();\n printer->Print(\"private:\\n\");\n printer->Indent();\n for (int i = 0; i < service->method_count(); ++i) {\n PrintHeaderClientMethodInterfaces(printer, service->method(i).get(), vars,\n false);\n }\n printer->Outdent();\n // Forward declaration of nested CallbackService if callback API enabled.\n if ((*vars)[\"generate_callback_api\"] == \"1\") {\n printer->Print(\"class CallbackService;\\n\");\n }\n printer->Print(\"};\\n\");\n printer->Print(\n \"class Stub final : public StubInterface\"\n \" {\\n public:\\n\");\n printer->Indent();\n printer->Print(\n \"Stub(const std::shared_ptr< ::grpc::ChannelInterface>& \"\n \"channel);\\n\");\n for (int i = 0; i < service->method_count(); ++i) {\n PrintHeaderClientMethod(printer, service->method(i).get(), vars, true);\n }\n printer->Outdent();\n printer->Print(\"\\n private:\\n\");\n printer->Indent();\n printer->Print(\"std::shared_ptr< ::grpc::ChannelInterface> channel_;\\n\");\n for (int i = 0; i < service->method_count(); ++i) {\n PrintHeaderClientMethod(printer, service->method(i).get(), vars, false);\n }\n for (int i = 0; i < service->method_count(); ++i) {\n PrintHeaderClientMethodData(printer, service->method(i).get(), vars);\n }\n printer->Outdent();\n printer->Print(\"};\\n\");\n printer->Print(\n \"static std::unique_ptr NewStub(const std::shared_ptr< \"\n \"::grpc::ChannelInterface>& channel, \"\n \"const ::grpc::StubOptions& options = ::grpc::StubOptions());\\n\");\n\n printer->Print(\"\\n\");\n\n // Server side - base\n printer->Print(\n \"class Service : public ::grpc::Service {\\n\"\n \" public:\\n\");\n printer->Indent();\n printer->Print(\"Service();\\n\");\n printer->Print(\"virtual ~Service();\\n\");\n for (int i = 0; i < service->method_count(); ++i) {\n PrintHeaderServerMethodSync(printer, service->method(i).get(), vars);\n }\n printer->Outdent();\n printer->Print(\"};\\n\");\n\n // Server side - Asynchronous\n for (int i = 0; i < service->method_count(); ++i) {\n (*vars)[\"Idx\"] = as_string(i);\n PrintHeaderServerMethodAsync(printer, service->method(i).get(), vars);\n }\n\n printer->Print(\"typedef \");\n\n for (int i = 0; i < service->method_count(); ++i) {\n (*vars)[\"method_name\"] = service->method(i).get()->name();\n printer->Print(*vars, \"WithAsyncMethod_$method_name$<\");\n }\n printer->Print(\"Service\");\n for (int i = 0; i < service->method_count(); ++i) {\n printer->Print(\" >\");\n }\n printer->Print(\" AsyncService;\\n\");\n\n // Server side - Generic\n for (int i = 0; i < service->method_count(); ++i) {\n (*vars)[\"Idx\"] = as_string(i);\n PrintHeaderServerMethodGeneric(printer, service->method(i).get(), vars);\n }\n\n // Server side - Streamed Unary\n for (int i = 0; i < service->method_count(); ++i) {\n (*vars)[\"Idx\"] = as_string(i);\n PrintHeaderServerMethodStreamedUnary(printer, service->method(i).get(),\n vars);\n }\n\n printer->Print(\"typedef \");\n for (int i = 0; i < service->method_count(); ++i) {\n (*vars)[\"method_name\"] = service->method(i).get()->name();\n if (service->method(i)->NoStreaming()) {\n printer->Print(*vars, \"WithStreamedUnaryMethod_$method_name$<\");\n }\n }\n printer->Print(\"Service\");\n for (int i = 0; i < service->method_count(); ++i) {\n if (service->method(i)->NoStreaming()) {\n printer->Print(\" >\");\n }\n }\n printer->Print(\" StreamedUnaryService;\\n\");\n\n // Server side - controlled server-side streaming\n for (int i = 0; i < service->method_count(); ++i) {\n (*vars)[\"Idx\"] = as_string(i);\n PrintHeaderServerMethodSplitStreaming(printer, service->method(i).get(),\n vars);\n }\n\n printer->Print(\"typedef \");\n for (int i = 0; i < service->method_count(); ++i) {\n (*vars)[\"method_name\"] = service->method(i).get()->name();\n auto method = service->method(i);\n if (ServerOnlyStreaming(method.get())) {\n printer->Print(*vars, \"WithSplitStreamingMethod_$method_name$<\");\n }\n }\n printer->Print(\"Service\");\n for (int i = 0; i < service->method_count(); ++i) {\n auto method = service->method(i);\n if (ServerOnlyStreaming(method.get())) {\n printer->Print(\" >\");\n }\n }\n printer->Print(\" SplitStreamedService;\\n\");\n\n // Server side - typedef for controlled both unary and server-side streaming\n printer->Print(\"typedef \");\n for (int i = 0; i < service->method_count(); ++i) {\n (*vars)[\"method_name\"] = service->method(i).get()->name();\n auto method = service->method(i);\n if (ServerOnlyStreaming(method.get())) {\n printer->Print(*vars, \"WithSplitStreamingMethod_$method_name$<\");\n }\n if (service->method(i)->NoStreaming()) {\n printer->Print(*vars, \"WithStreamedUnaryMethod_$method_name$<\");\n }\n }\n printer->Print(\"Service\");\n for (int i = 0; i < service->method_count(); ++i) {\n auto method = service->method(i);\n if (service->method(i)->NoStreaming() ||\n ServerOnlyStreaming(method.get())) {\n printer->Print(\" >\");\n }\n }\n printer->Print(\" StreamedService;\\n\");\n\n printer->Outdent();\n printer->Print(\"};\\n\");\n printer->Print(service->GetTrailingComments(\"//\").c_str());\n\n // Optional CallbackService (modern async API)\n if ((*vars)[\"generate_callback_api\"] == \"1\") {\n (*vars)[\"Service\"] = service->name();\n printer->Print(\"\\n#if defined(GRPC_CALLBACK_API_NONEXPERIMENTAL)\\n\");\n printer->Print(*vars,\n \"class $Service$::CallbackService : public ::grpc::Service \"\n \"{\\n public:\\n CallbackService();\\n virtual \"\n \"~CallbackService();\\n\");\n printer->Indent();\n for (int i = 0; i < service->method_count(); ++i) {\n auto m = service->method(i);\n (*vars)[\"Method\"] = m->name();\n (*vars)[\"Request\"] = m->input_type_name();\n (*vars)[\"Response\"] = m->output_type_name();\n if (m->NoStreaming()) {\n printer->Print(*vars,\n \"virtual ::grpc::ServerUnaryReactor* \"\n \"$Method$(::grpc::CallbackServerContext* context, const \"\n \"$Request$* request, $Response$* response);\\n\");\n } else if (ClientOnlyStreaming(m.get())) {\n printer->Print(*vars,\n \"virtual ::grpc::ServerReadReactor<$Request$>* \"\n \"$Method$(::grpc::CallbackServerContext* context, \"\n \"$Response$* response);\\n\");\n } else if (ServerOnlyStreaming(m.get())) {\n printer->Print(*vars,\n \"virtual ::grpc::ServerWriteReactor<$Response$>* \"\n \"$Method$(::grpc::CallbackServerContext* context, const \"\n \"$Request$* request);\\n\");\n } else if (m->BidiStreaming()) {\n printer->Print(\n *vars,\n \"virtual ::grpc::ServerBidiReactor<$Request$, $Response$>* \"\n \"$Method$(::grpc::CallbackServerContext* context);\\n\");\n }\n }\n printer->Outdent();\n printer->Print(\n \"};\\n#else\\n// Callback API requested but not available in this gRPC \"\n \"version.\\n#endif // GRPC_CALLBACK_API_NONEXPERIMENTAL\\n\");\n }\n}\n\n} // namespace\n\ngrpc::string GetHeaderServices(grpc_generator::File* file,\n const Parameters& params) {\n grpc::string output;\n {\n // Scope the output stream so it closes and finalizes output to the string.\n auto printer = file->CreatePrinter(&output);\n std::map vars;\n // Package string is empty or ends with a dot. It is used to fully qualify\n // method names.\n vars[\"Package\"] = file->package();\n if (!file->package().empty()) {\n vars[\"Package\"].append(\".\");\n }\n\n if (!params.services_namespace.empty()) {\n vars[\"services_namespace\"] = params.services_namespace;\n printer->Print(vars, \"\\nnamespace $services_namespace$ {\\n\\n\");\n }\n\n for (int i = 0; i < file->service_count(); ++i) {\n vars[\"generate_callback_api\"] = params.generate_callback_api ? \"1\" : \"0\";\n PrintHeaderService(printer.get(), file->service(i).get(), &vars);\n printer->Print(\"\\n\");\n }\n if (params.generate_callback_api) {\n printer->Print(\"// FlatBuffers: Callback API code generated.\\n\");\n printer->Print(\"#define FLATBUFFERS_GENERATED_GRPC_CALLBACK_API 1\\n\\n\");\n }\n\n if (!params.services_namespace.empty()) {\n printer->Print(vars, \"} // namespace $services_namespace$\\n\\n\");\n }\n }\n return output;\n}\n\ngrpc::string GetHeaderEpilogue(grpc_generator::File* file,\n const Parameters& /*params*/) {\n grpc::string output;\n {\n // Scope the output stream so it closes and finalizes output to the string.\n auto printer = file->CreatePrinter(&output);\n std::map vars;\n\n vars[\"filename\"] = file->filename();\n vars[\"filename_identifier\"] = FilenameIdentifier(file->filename());\n\n if (!file->package().empty()) {\n std::vector parts = file->package_parts();\n\n for (auto part = parts.rbegin(); part != parts.rend(); part++) {\n vars[\"part\"] = *part;\n printer->Print(vars, \"} // namespace $part$\\n\");\n }\n printer->Print(vars, \"\\n\");\n }\n\n printer->Print(vars, \"\\n\");\n printer->Print(vars, \"#endif // GRPC_$filename_identifier$__INCLUDED\\n\");\n\n printer->Print(file->GetTrailingComments(\"//\").c_str());\n }\n return output;\n}\n\ngrpc::string GetSourcePrologue(grpc_generator::File* file,\n const Parameters& params) {\n grpc::string output;\n {\n // Scope the output stream so it closes and finalizes output to the string.\n auto printer = file->CreatePrinter(&output);\n std::map vars;\n\n vars[\"filename\"] = file->filename();\n vars[\"filename_base\"] = file->filename_without_ext();\n vars[\"message_header_ext\"] = params.message_header_extension;\n vars[\"service_header_ext\"] = params.service_header_extension;\n\n printer->Print(vars, \"// Generated by the gRPC C++ plugin.\\n\");\n printer->Print(vars,\n \"// FlatBuffers modified generator: native gRPC callback \"\n \"client API enabled when --grpc-callback-api.\\n\");\n printer->Print(vars, \"// source: $filename$\\n\\n\");\n\n printer->Print(vars, \"#include \\\"$filename_base$$message_header_ext$\\\"\\n\");\n printer->Print(vars, \"#include \\\"$filename_base$$service_header_ext$\\\"\\n\");\n printer->Print(vars, \"\\n\");\n }\n return output;\n}\n\ngrpc::string GetSourceIncludes(grpc_generator::File* file,\n const Parameters& params) {\n grpc::string output;\n {\n // Scope the output stream so it closes and finalizes output to the string.\n auto printer = file->CreatePrinter(&output);\n std::map vars;\n\n static const char* headers_strs[] = {\n \"grpcpp/impl/codegen/async_stream.h\",\n \"grpcpp/impl/codegen/async_unary_call.h\",\n \"grpcpp/impl/codegen/channel_interface.h\",\n \"grpcpp/impl/codegen/client_unary_call.h\",\n \"grpcpp/impl/codegen/method_handler.h\",\n \"grpcpp/impl/codegen/rpc_service_method.h\",\n \"grpcpp/impl/codegen/service_type.h\",\n \"grpcpp/impl/codegen/sync_stream.h\"};\n std::vector headers(headers_strs, array_end(headers_strs));\n PrintIncludes(printer.get(), headers, params);\n\n if (!file->package().empty()) {\n std::vector parts = file->package_parts();\n\n for (auto part = parts.begin(); part != parts.end(); part++) {\n vars[\"part\"] = *part;\n printer->Print(vars, \"namespace $part$ {\\n\");\n }\n }\n\n printer->Print(vars, \"\\n\");\n }\n return output;\n}\n\nnamespace {\n\nstatic void PrintSourceClientMethod(\n grpc_generator::Printer* printer, const grpc_generator::Method* method,\n std::map* vars) {\n (*vars)[\"Method\"] = method->name();\n (*vars)[\"Request\"] = method->input_type_name();\n (*vars)[\"Response\"] = method->output_type_name();\n struct {\n grpc::string prefix;\n grpc::string start; // bool literal expressed as string\n grpc::string method_params; // extra arguments to method\n grpc::string create_args; // extra arguments to creator\n } async_prefixes[] = {{\"Async\", \"true\", \", void* tag\", \", tag\"},\n {\"PrepareAsync\", \"false\", \"\", \", nullptr\"}};\n if (method->NoStreaming()) {\n printer->Print(*vars,\n \"::grpc::Status $ns$$Service$::Stub::$Method$(\"\n \"::grpc::ClientContext* context, \"\n \"const $Request$& request, $Response$* response) {\\n\");\n printer->Print(*vars,\n \" return ::grpc::internal::BlockingUnaryCall\"\n \"(channel_.get(), rpcmethod_$Method$_, \"\n \"context, request, response);\\n}\\n\\n\");\n if ((*vars)[\"generate_callback_api\"] == \"1\") {\n printer->Print(\n *vars,\n \"void $ns$$Service$::Stub::async_$Method$(::grpc::ClientContext* \"\n \"context, const $Request$& request, $Response$* response, \"\n \"std::function on_done) {\\n\");\n printer->Print(*vars,\n \" ::grpc::internal::CallbackUnaryCall(channel_.get(), \"\n \"rpcmethod_$Method$_, context, &request, response, \"\n \"std::move(on_done));\\n}\\n\\n\");\n printer->Print(\n *vars,\n \"void $ns$$Service$::Stub::async_$Method$(::grpc::ClientContext* \"\n \"context, const $Request$& request, $Response$* response, \"\n \"::grpc::ClientUnaryReactor* reactor) {\\n\");\n printer->Print(\n *vars,\n \" \"\n \"::grpc::internal::ClientCallbackUnaryFactory::Create(channel_.get(),\"\n \" rpcmethod_$Method$_, context, &request, response, \"\n \"reactor);\\n}\\n\\n\");\n }\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncStart\"] = async_prefix.start;\n printer->Print(*vars,\n \"::grpc::ClientAsyncResponseReader< $Response$>* \"\n \"$ns$$Service$::Stub::$AsyncPrefix$$Method$Raw(::grpc::\"\n \"ClientContext* context, \"\n \"const $Request$& request, \"\n \"::grpc::CompletionQueue* cq) {\\n\");\n printer->Print(\n *vars,\n \" return \"\n \"::grpc::internal::ClientAsyncResponseReaderFactory< $Response$>\"\n \"::Create(channel_.get(), cq, \"\n \"rpcmethod_$Method$_, \"\n \"context, request, $AsyncStart$);\\n\"\n \"}\\n\\n\");\n }\n } else if (ClientOnlyStreaming(method)) {\n printer->Print(*vars,\n \"::grpc::ClientWriter< $Request$>* \"\n \"$ns$$Service$::Stub::$Method$Raw(\"\n \"::grpc::ClientContext* context, $Response$* response) {\\n\");\n printer->Print(\n *vars,\n \" return ::grpc::internal::ClientWriterFactory< $Request$>::Create(\"\n \"channel_.get(), \"\n \"rpcmethod_$Method$_, \"\n \"context, response);\\n\"\n \"}\\n\\n\");\n if ((*vars)[\"generate_callback_api\"] == \"1\") {\n printer->Print(\n *vars,\n \"void $ns$$Service$::Stub::async_$Method$(::grpc::ClientContext* \"\n \"context, $Response$* response, ::grpc::ClientWriteReactor< \"\n \"$Request$ >* reactor) {\\n\");\n printer->Print(*vars,\n \" ::grpc::internal::ClientCallbackWriterFactory< \"\n \"$Request$ >::Create(channel_.get(), rpcmethod_$Method$_, \"\n \"context, response, reactor);\\n}\\n\\n\");\n }\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncStart\"] = async_prefix.start;\n (*vars)[\"AsyncMethodParams\"] = async_prefix.method_params;\n (*vars)[\"AsyncCreateArgs\"] = async_prefix.create_args;\n printer->Print(*vars,\n \"::grpc::ClientAsyncWriter< $Request$>* \"\n \"$ns$$Service$::Stub::$AsyncPrefix$$Method$Raw(\"\n \"::grpc::ClientContext* context, $Response$* response, \"\n \"::grpc::CompletionQueue* cq$AsyncMethodParams$) {\\n\");\n printer->Print(\n *vars,\n \" return ::grpc::internal::ClientAsyncWriterFactory< $Request$>\"\n \"::Create(channel_.get(), cq, \"\n \"rpcmethod_$Method$_, \"\n \"context, response, $AsyncStart$$AsyncCreateArgs$);\\n\"\n \"}\\n\\n\");\n }\n } else if (ServerOnlyStreaming(method)) {\n printer->Print(\n *vars,\n \"::grpc::ClientReader< $Response$>* \"\n \"$ns$$Service$::Stub::$Method$Raw(\"\n \"::grpc::ClientContext* context, const $Request$& request) {\\n\");\n printer->Print(\n *vars,\n \" return ::grpc::internal::ClientReaderFactory< $Response$>::Create(\"\n \"channel_.get(), \"\n \"rpcmethod_$Method$_, \"\n \"context, request);\\n\"\n \"}\\n\\n\");\n if ((*vars)[\"generate_callback_api\"] == \"1\") {\n printer->Print(\n *vars,\n \"void $ns$$Service$::Stub::async_$Method$(::grpc::ClientContext* \"\n \"context, const $Request$& request, ::grpc::ClientReadReactor< \"\n \"$Response$ >* reactor) {\\n\");\n printer->Print(\n *vars,\n \" ::grpc::internal::ClientCallbackReaderFactory< \"\n \"$Response$ >::Create(channel_.get(), \"\n \"rpcmethod_$Method$_, context, &request, reactor);\\n}\\n\\n\");\n }\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncStart\"] = async_prefix.start;\n (*vars)[\"AsyncMethodParams\"] = async_prefix.method_params;\n (*vars)[\"AsyncCreateArgs\"] = async_prefix.create_args;\n printer->Print(\n *vars,\n \"::grpc::ClientAsyncReader< $Response$>* \"\n \"$ns$$Service$::Stub::$AsyncPrefix$$Method$Raw(\"\n \"::grpc::ClientContext* context, const $Request$& request, \"\n \"::grpc::CompletionQueue* cq$AsyncMethodParams$) {\\n\");\n printer->Print(\n *vars,\n \" return ::grpc::internal::ClientAsyncReaderFactory< $Response$>\"\n \"::Create(channel_.get(), cq, \"\n \"rpcmethod_$Method$_, \"\n \"context, request, $AsyncStart$$AsyncCreateArgs$);\\n\"\n \"}\\n\\n\");\n }\n } else if (method->BidiStreaming()) {\n printer->Print(\n *vars,\n \"::grpc::ClientReaderWriter< $Request$, $Response$>* \"\n \"$ns$$Service$::Stub::$Method$Raw(::grpc::ClientContext* context) {\\n\");\n printer->Print(*vars,\n \" return ::grpc::internal::ClientReaderWriterFactory< \"\n \"$Request$, $Response$>::Create(\"\n \"channel_.get(), \"\n \"rpcmethod_$Method$_, \"\n \"context);\\n\"\n \"}\\n\\n\");\n if ((*vars)[\"generate_callback_api\"] == \"1\") {\n printer->Print(\n *vars,\n \"void $ns$$Service$::Stub::async_$Method$(::grpc::ClientContext* \"\n \"context, ::grpc::ClientBidiReactor< $Request$, $Response$ >* \"\n \"reactor) {\\n\");\n printer->Print(*vars,\n \" ::grpc::internal::ClientCallbackReaderWriterFactory< \"\n \"$Request$, $Response$ >::Create(channel_.get(), \"\n \"rpcmethod_$Method$_, context, reactor);\\n}\\n\\n\");\n }\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncStart\"] = async_prefix.start;\n (*vars)[\"AsyncMethodParams\"] = async_prefix.method_params;\n (*vars)[\"AsyncCreateArgs\"] = async_prefix.create_args;\n printer->Print(*vars,\n \"::grpc::ClientAsyncReaderWriter< $Request$, $Response$>* \"\n \"$ns$$Service$::Stub::$AsyncPrefix$$Method$Raw(::grpc::\"\n \"ClientContext* context, \"\n \"::grpc::CompletionQueue* cq$AsyncMethodParams$) {\\n\");\n printer->Print(*vars,\n \" return \"\n \"::grpc::internal::ClientAsyncReaderWriterFactory< \"\n \"$Request$, $Response$>::Create(\"\n \"channel_.get(), cq, \"\n \"rpcmethod_$Method$_, \"\n \"context, $AsyncStart$$AsyncCreateArgs$);\\n\"\n \"}\\n\\n\");\n }\n }\n}\n\nstatic void PrintSourceServerMethod(\n grpc_generator::Printer* printer, const grpc_generator::Method* method,\n std::map* vars) {\n (*vars)[\"Method\"] = method->name();\n (*vars)[\"Request\"] = method->input_type_name();\n (*vars)[\"Response\"] = method->output_type_name();\n if (method->NoStreaming()) {\n printer->Print(\n *vars,\n \"::grpc::Status $ns$$Service$::Service::$Method$(\"\n \"::grpc::ServerContext* /*context*/, \"\n \"const $Request$* /*request*/, $Response$* /*response*/) {\\n\");\n printer->Print(\n \" return ::grpc::Status(\"\n \"::grpc::StatusCode::UNIMPLEMENTED, \\\"\\\");\\n\");\n printer->Print(\"}\\n\\n\");\n } else if (ClientOnlyStreaming(method)) {\n printer->Print(*vars,\n \"::grpc::Status $ns$$Service$::Service::$Method$(\"\n \"::grpc::ServerContext* /*context*/, \"\n \"::grpc::ServerReader< $Request$>* /*reader*/, \"\n \"$Response$* /*response*/) {\\n\");\n printer->Print(\n \" return ::grpc::Status(\"\n \"::grpc::StatusCode::UNIMPLEMENTED, \\\"\\\");\\n\");\n printer->Print(\"}\\n\\n\");\n } else if (ServerOnlyStreaming(method)) {\n printer->Print(*vars,\n \"::grpc::Status $ns$$Service$::Service::$Method$(\"\n \"::grpc::ServerContext* /*context*/, \"\n \"const $Request$* /*request*/, \"\n \"::grpc::ServerWriter< $Response$>* /*writer*/) {\\n\");\n printer->Print(\n \" return ::grpc::Status(\"\n \"::grpc::StatusCode::UNIMPLEMENTED, \\\"\\\");\\n\");\n printer->Print(\"}\\n\\n\");\n } else if (method->BidiStreaming()) {\n printer->Print(*vars,\n \"::grpc::Status $ns$$Service$::Service::$Method$(\"\n \"::grpc::ServerContext* /*context*/, \"\n \"::grpc::ServerReaderWriter< $Response$, $Request$>* \"\n \"/*stream*/) {\\n\");\n printer->Print(\n \" return ::grpc::Status(\"\n \"::grpc::StatusCode::UNIMPLEMENTED, \\\"\\\");\\n\");\n printer->Print(\"}\\n\\n\");\n }\n}\n\nstatic void PrintSourceService(grpc_generator::Printer* printer,\n const grpc_generator::Service* service,\n std::map* vars) {\n (*vars)[\"Service\"] = service->name();\n\n if (service->method_count() > 0) {\n printer->Print(*vars,\n \"static const char* $prefix$$Service$_method_names[] = {\\n\");\n for (int i = 0; i < service->method_count(); ++i) {\n (*vars)[\"Method\"] = service->method(i).get()->name();\n printer->Print(*vars, \" \\\"/$Package$$Service$/$Method$\\\",\\n\");\n }\n printer->Print(*vars, \"};\\n\\n\");\n }\n\n printer->Print(*vars,\n \"std::unique_ptr< $ns$$Service$::Stub> $ns$$Service$::NewStub(\"\n \"const std::shared_ptr< ::grpc::ChannelInterface>& channel, \"\n \"const ::grpc::StubOptions& /*options*/) {\\n\"\n \" std::unique_ptr< $ns$$Service$::Stub> stub(new \"\n \"$ns$$Service$::Stub(channel));\\n\"\n \" return stub;\\n\"\n \"}\\n\\n\");\n printer->Print(*vars,\n \"$ns$$Service$::Stub::Stub(const std::shared_ptr< \"\n \"::grpc::ChannelInterface>& channel)\\n\");\n printer->Indent();\n printer->Print(\": channel_(channel)\");\n for (int i = 0; i < service->method_count(); ++i) {\n auto method = service->method(i);\n (*vars)[\"Method\"] = method->name();\n (*vars)[\"Idx\"] = as_string(i);\n if (method->NoStreaming()) {\n (*vars)[\"StreamingType\"] = \"NORMAL_RPC\";\n // NOTE: There is no reason to consider streamed-unary as a separate\n // category here since this part is setting up the client-side stub\n // and this appears as a NORMAL_RPC from the client-side.\n } else if (ClientOnlyStreaming(method.get())) {\n (*vars)[\"StreamingType\"] = \"CLIENT_STREAMING\";\n } else if (ServerOnlyStreaming(method.get())) {\n (*vars)[\"StreamingType\"] = \"SERVER_STREAMING\";\n } else {\n (*vars)[\"StreamingType\"] = \"BIDI_STREAMING\";\n }\n printer->Print(*vars,\n \", rpcmethod_$Method$_(\"\n \"$prefix$$Service$_method_names[$Idx$], \"\n \"::grpc::internal::RpcMethod::$StreamingType$, \"\n \"channel\"\n \")\\n\");\n }\n printer->Print(\"{}\\n\\n\");\n printer->Outdent();\n\n for (int i = 0; i < service->method_count(); ++i) {\n (*vars)[\"Idx\"] = as_string(i);\n PrintSourceClientMethod(printer, service->method(i).get(), vars);\n }\n\n printer->Print(*vars, \"$ns$$Service$::Service::Service() {\\n\");\n printer->Indent();\n for (int i = 0; i < service->method_count(); ++i) {\n auto method = service->method(i);\n (*vars)[\"Idx\"] = as_string(i);\n (*vars)[\"Method\"] = method->name();\n (*vars)[\"Request\"] = method->input_type_name();\n (*vars)[\"Response\"] = method->output_type_name();\n if (method->NoStreaming()) {\n printer->Print(\n *vars,\n \"AddMethod(new ::grpc::internal::RpcServiceMethod(\\n\"\n \" $prefix$$Service$_method_names[$Idx$],\\n\"\n \" ::grpc::internal::RpcMethod::NORMAL_RPC,\\n\"\n \" new ::grpc::internal::RpcMethodHandler< $ns$$Service$::Service, \"\n \"$Request$, \"\n \"$Response$>(\\n\"\n \" std::mem_fn(&$ns$$Service$::Service::$Method$), this)));\\n\");\n } else if (ClientOnlyStreaming(method.get())) {\n printer->Print(\n *vars,\n \"AddMethod(new ::grpc::internal::RpcServiceMethod(\\n\"\n \" $prefix$$Service$_method_names[$Idx$],\\n\"\n \" ::grpc::internal::RpcMethod::CLIENT_STREAMING,\\n\"\n \" new ::grpc::internal::ClientStreamingHandler< \"\n \"$ns$$Service$::Service, $Request$, $Response$>(\\n\"\n \" std::mem_fn(&$ns$$Service$::Service::$Method$), this)));\\n\");\n } else if (ServerOnlyStreaming(method.get())) {\n printer->Print(\n *vars,\n \"AddMethod(new ::grpc::internal::RpcServiceMethod(\\n\"\n \" $prefix$$Service$_method_names[$Idx$],\\n\"\n \" ::grpc::internal::RpcMethod::SERVER_STREAMING,\\n\"\n \" new ::grpc::internal::ServerStreamingHandler< \"\n \"$ns$$Service$::Service, $Request$, $Response$>(\\n\"\n \" std::mem_fn(&$ns$$Service$::Service::$Method$), this)));\\n\");\n } else if (method->BidiStreaming()) {\n printer->Print(\n *vars,\n \"AddMethod(new ::grpc::internal::RpcServiceMethod(\\n\"\n \" $prefix$$Service$_method_names[$Idx$],\\n\"\n \" ::grpc::internal::RpcMethod::BIDI_STREAMING,\\n\"\n \" new ::grpc::internal::BidiStreamingHandler< \"\n \"$ns$$Service$::Service, $Request$, $Response$>(\\n\"\n \" std::mem_fn(&$ns$$Service$::Service::$Method$), this)));\\n\");\n }\n }\n printer->Outdent();\n printer->Print(*vars, \"}\\n\\n\");\n printer->Print(*vars,\n \"$ns$$Service$::Service::~Service() {\\n\"\n \"}\\n\\n\");\n for (int i = 0; i < service->method_count(); ++i) {\n (*vars)[\"Idx\"] = as_string(i);\n PrintSourceServerMethod(printer, service->method(i).get(), vars);\n }\n\n // CallbackService implementation (if enabled)\n if ((*vars)[\"generate_callback_api\"] == \"1\") {\n (*vars)[\"Service\"] = service->name();\n printer->Print(\"#if defined(GRPC_CALLBACK_API_NONEXPERIMENTAL)\\n\");\n printer->Print(*vars,\n \"$ns$$Service$::CallbackService::CallbackService() {\\n\");\n printer->Indent();\n for (int i = 0; i < service->method_count(); ++i) {\n auto method = service->method(i);\n (*vars)[\"Idx\"] = as_string(i);\n (*vars)[\"Method\"] = method->name();\n (*vars)[\"Request\"] = method->input_type_name();\n (*vars)[\"Response\"] = method->output_type_name();\n if (method->NoStreaming()) {\n printer->Print(\n *vars,\n \"AddMethod(new ::grpc::internal::RpcServiceMethod(\\n\"\n \" $prefix$$Service$_method_names[$Idx$],\\n\"\n \" ::grpc::internal::RpcMethod::NORMAL_RPC,\\n\"\n \" new ::grpc::internal::CallbackUnaryHandler<$Request$, \"\n \"$Response$>(\\n\"\n \" [this](::grpc::CallbackServerContext* ctx, const $Request$* \"\n \"req, $Response$* resp) {\\n\"\n \" return this->$Method$(ctx, req, resp);\\n\"\n \" })));\\n\");\n } else if (ClientOnlyStreaming(method.get())) {\n printer->Print(*vars,\n \"AddMethod(new ::grpc::internal::RpcServiceMethod(\\n\"\n \" $prefix$$Service$_method_names[$Idx$],\\n\"\n \" ::grpc::internal::RpcMethod::CLIENT_STREAMING,\\n\"\n \" new \"\n \"::grpc::internal::CallbackClientStreamingHandler<$\"\n \"Request$, $Response$>(\\n\"\n \" [this](::grpc::CallbackServerContext* ctx, \"\n \"$Response$* resp) {\\n\"\n \" return this->$Method$(ctx, resp);\\n\"\n \" })));\\n\");\n } else if (ServerOnlyStreaming(method.get())) {\n printer->Print(*vars,\n \"AddMethod(new ::grpc::internal::RpcServiceMethod(\\n\"\n \" $prefix$$Service$_method_names[$Idx$],\\n\"\n \" ::grpc::internal::RpcMethod::SERVER_STREAMING,\\n\"\n \" new \"\n \"::grpc::internal::CallbackServerStreamingHandler<$\"\n \"Request$, $Response$>(\\n\"\n \" [this](::grpc::CallbackServerContext* ctx, const \"\n \"$Request$* req) {\\n\"\n \" return this->$Method$(ctx, req);\\n\"\n \" })));\\n\");\n } else if (method->BidiStreaming()) {\n printer->Print(\n *vars,\n \"AddMethod(new ::grpc::internal::RpcServiceMethod(\\n\"\n \" $prefix$$Service$_method_names[$Idx$],\\n\"\n \" ::grpc::internal::RpcMethod::BIDI_STREAMING,\\n\"\n \" new ::grpc::internal::CallbackBidiHandler<$Request$, \"\n \"$Response$>(\\n\"\n \" [this](::grpc::CallbackServerContext* ctx) {\\n\"\n \" return this->$Method$(ctx);\\n\"\n \" })));\\n\");\n }\n }\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n printer->Print(*vars,\n \"$ns$$Service$::CallbackService::~CallbackService() {}\\n\\n\");\n // Default method bodies returning UNIMPLEMENTED reactors.\n for (int i = 0; i < service->method_count(); ++i) {\n auto method = service->method(i);\n (*vars)[\"Method\"] = method->name();\n (*vars)[\"Request\"] = method->input_type_name();\n (*vars)[\"Response\"] = method->output_type_name();\n if (method->NoStreaming()) {\n printer->Print(*vars,\n \"::grpc::ServerUnaryReactor* \"\n \"$ns$$Service$::CallbackService::$Method$(::grpc::\"\n \"CallbackServerContext* /*context*/, const $Request$* \"\n \"/*request*/, $Response$* /*response*/) {\\n\"\n \" return nullptr; // user must override\\n\"\n \"}\\n\\n\");\n } else if (ClientOnlyStreaming(method.get())) {\n printer->Print(\n *vars,\n \"::grpc::ServerReadReactor<$Request$>* \"\n \"$ns$$Service$::CallbackService::$Method$(::grpc::\"\n \"CallbackServerContext* /*context*/, $Response$* /*response*/) {\\n\"\n \" return nullptr; // user must override\\n\"\n \"}\\n\\n\");\n } else if (ServerOnlyStreaming(method.get())) {\n printer->Print(*vars,\n \"::grpc::ServerWriteReactor<$Response$>* \"\n \"$ns$$Service$::CallbackService::$Method$(::grpc::\"\n \"CallbackServerContext* /*context*/, const $Request$* \"\n \"/*request*/) {\\n\"\n \" return nullptr; // user must override\\n\"\n \"}\\n\\n\");\n } else if (method->BidiStreaming()) {\n printer->Print(*vars,\n \"::grpc::ServerBidiReactor<$Request$, $Response$>* \"\n \"$ns$$Service$::CallbackService::$Method$(::grpc::\"\n \"CallbackServerContext* /*context*/) {\\n\"\n \" return nullptr; // user must override\\n\"\n \"}\\n\\n\");\n }\n }\n printer->Print(\"#endif // GRPC_CALLBACK_API_NONEXPERIMENTAL\\n\");\n }\n}\n\n} // namespace\n\ngrpc::string GetSourceServices(grpc_generator::File* file,\n const Parameters& params) {\n grpc::string output;\n {\n // Scope the output stream so it closes and finalizes output to the string.\n auto printer = file->CreatePrinter(&output);\n std::map vars;\n // Package string is empty or ends with a dot. It is used to fully qualify\n // method names.\n vars[\"Package\"] = file->package();\n if (!file->package().empty()) {\n vars[\"Package\"].append(\".\");\n }\n if (!params.services_namespace.empty()) {\n vars[\"ns\"] = params.services_namespace + \"::\";\n vars[\"prefix\"] = params.services_namespace;\n } else {\n vars[\"ns\"] = \"\";\n vars[\"prefix\"] = \"\";\n }\n\n for (int i = 0; i < file->service_count(); ++i) {\n vars[\"generate_callback_api\"] = params.generate_callback_api ? \"1\" : \"0\";\n PrintSourceService(printer.get(), file->service(i).get(), &vars);\n printer->Print(\"\\n\");\n }\n }\n return output;\n}\n\ngrpc::string GetSourceEpilogue(grpc_generator::File* file,\n const Parameters& /*params*/) {\n grpc::string temp;\n\n if (!file->package().empty()) {\n std::vector parts = file->package_parts();\n\n for (auto part = parts.begin(); part != parts.end(); part++) {\n temp.append(\"} // namespace \");\n temp.append(*part);\n temp.append(\"\\n\");\n }\n temp.append(\"\\n\");\n }\n\n return temp;\n}\n\ngrpc::string GetMockPrologue(grpc_generator::File* file,\n const Parameters& params) {\n grpc::string output;\n {\n // Scope the output stream so it closes and finalizes output to the string.\n auto printer = file->CreatePrinter(&output);\n std::map vars;\n\n vars[\"filename\"] = file->filename();\n vars[\"filename_base\"] = file->filename_without_ext();\n vars[\"message_header_ext\"] = params.message_header_extension;\n vars[\"service_header_ext\"] = params.service_header_extension;\n\n printer->Print(vars, \"// Generated by the gRPC C++ plugin.\\n\");\n printer->Print(vars,\n \"// If you make any local change, they will be lost.\\n\");\n printer->Print(vars, \"// source: $filename$\\n\\n\");\n\n printer->Print(vars, \"#include \\\"$filename_base$$message_header_ext$\\\"\\n\");\n printer->Print(vars, \"#include \\\"$filename_base$$service_header_ext$\\\"\\n\");\n printer->Print(vars, file->additional_headers().c_str());\n printer->Print(vars, \"\\n\");\n }\n return output;\n}\n\n// TODO(mmukhi): Add client-stream and completion-queue headers.\ngrpc::string GetMockIncludes(grpc_generator::File* file,\n const Parameters& params) {\n grpc::string output;\n {\n // Scope the output stream so it closes and finalizes output to the string.\n auto printer = file->CreatePrinter(&output);\n std::map vars;\n\n static const char* headers_strs[] = {\n \"grpcpp/impl/codegen/async_stream.h\",\n \"grpcpp/impl/codegen/sync_stream.h\",\n \"gmock/gmock.h\",\n };\n std::vector headers(headers_strs, array_end(headers_strs));\n PrintIncludes(printer.get(), headers, params);\n\n if (!file->package().empty()) {\n std::vector parts = file->package_parts();\n\n for (auto part = parts.begin(); part != parts.end(); part++) {\n vars[\"part\"] = *part;\n printer->Print(vars, \"namespace $part$ {\\n\");\n }\n }\n\n printer->Print(vars, \"\\n\");\n }\n return output;\n}\n\nnamespace {\n\nstatic void PrintMockClientMethods(grpc_generator::Printer* printer,\n const grpc_generator::Method* method,\n std::map* vars) {\n (*vars)[\"Method\"] = method->name();\n (*vars)[\"Request\"] = method->input_type_name();\n (*vars)[\"Response\"] = method->output_type_name();\n\n struct {\n grpc::string prefix;\n grpc::string method_params; // extra arguments to method\n int extra_method_param_count;\n } async_prefixes[] = {{\"Async\", \", void* tag\", 1}, {\"PrepareAsync\", \"\", 0}};\n\n if (method->NoStreaming()) {\n printer->Print(\n *vars,\n \"MOCK_METHOD3($Method$, ::grpc::Status(::grpc::ClientContext* context, \"\n \"const $Request$& request, $Response$* response));\\n\");\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n printer->Print(\n *vars,\n \"MOCK_METHOD3($AsyncPrefix$$Method$Raw, \"\n \"::grpc::ClientAsyncResponseReaderInterface< $Response$>*\"\n \"(::grpc::ClientContext* context, const $Request$& request, \"\n \"::grpc::CompletionQueue* cq));\\n\");\n }\n } else if (ClientOnlyStreaming(method)) {\n printer->Print(\n *vars,\n \"MOCK_METHOD2($Method$Raw, \"\n \"::grpc::ClientWriterInterface< $Request$>*\"\n \"(::grpc::ClientContext* context, $Response$* response));\\n\");\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncMethodParams\"] = async_prefix.method_params;\n (*vars)[\"MockArgs\"] =\n flatbuffers::NumToString(3 + async_prefix.extra_method_param_count);\n printer->Print(*vars,\n \"MOCK_METHOD$MockArgs$($AsyncPrefix$$Method$Raw, \"\n \"::grpc::ClientAsyncWriterInterface< $Request$>*\"\n \"(::grpc::ClientContext* context, $Response$* response, \"\n \"::grpc::CompletionQueue* cq$AsyncMethodParams$));\\n\");\n }\n } else if (ServerOnlyStreaming(method)) {\n printer->Print(\n *vars,\n \"MOCK_METHOD2($Method$Raw, \"\n \"::grpc::ClientReaderInterface< $Response$>*\"\n \"(::grpc::ClientContext* context, const $Request$& request));\\n\");\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncMethodParams\"] = async_prefix.method_params;\n (*vars)[\"MockArgs\"] =\n flatbuffers::NumToString(3 + async_prefix.extra_method_param_count);\n printer->Print(\n *vars,\n \"MOCK_METHOD$MockArgs$($AsyncPrefix$$Method$Raw, \"\n \"::grpc::ClientAsyncReaderInterface< $Response$>*\"\n \"(::grpc::ClientContext* context, const $Request$& request, \"\n \"::grpc::CompletionQueue* cq$AsyncMethodParams$));\\n\");\n }\n } else if (method->BidiStreaming()) {\n printer->Print(\n *vars,\n \"MOCK_METHOD1($Method$Raw, \"\n \"::grpc::ClientReaderWriterInterface< $Request$, $Response$>*\"\n \"(::grpc::ClientContext* context));\\n\");\n for (size_t i = 0; i < sizeof(async_prefixes) / sizeof(async_prefixes[0]);\n i++) {\n auto& async_prefix = async_prefixes[i];\n (*vars)[\"AsyncPrefix\"] = async_prefix.prefix;\n (*vars)[\"AsyncMethodParams\"] = async_prefix.method_params;\n (*vars)[\"MockArgs\"] =\n flatbuffers::NumToString(2 + async_prefix.extra_method_param_count);\n printer->Print(\n *vars,\n \"MOCK_METHOD$MockArgs$($AsyncPrefix$$Method$Raw, \"\n \"::grpc::ClientAsyncReaderWriterInterface<$Request$, $Response$>*\"\n \"(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq\"\n \"$AsyncMethodParams$));\\n\");\n }\n }\n}\n\nstatic void PrintMockService(grpc_generator::Printer* printer,\n const grpc_generator::Service* service,\n std::map* vars) {\n (*vars)[\"Service\"] = service->name();\n\n printer->Print(*vars,\n \"class Mock$Service$Stub : public $Service$::StubInterface {\\n\"\n \" public:\\n\");\n printer->Indent();\n for (int i = 0; i < service->method_count(); ++i) {\n PrintMockClientMethods(printer, service->method(i).get(), vars);\n }\n printer->Outdent();\n printer->Print(\"};\\n\");\n}\n\n} // namespace\n\ngrpc::string GetMockServices(grpc_generator::File* file,\n const Parameters& params) {\n grpc::string output;\n {\n // Scope the output stream so it closes and finalizes output to the string.\n auto printer = file->CreatePrinter(&output);\n std::map vars;\n // Package string is empty or ends with a dot. It is used to fully qualify\n // method names.\n vars[\"Package\"] = file->package();\n if (!file->package().empty()) {\n vars[\"Package\"].append(\".\");\n }\n\n if (!params.services_namespace.empty()) {\n vars[\"services_namespace\"] = params.services_namespace;\n printer->Print(vars, \"\\nnamespace $services_namespace$ {\\n\\n\");\n }\n\n for (int i = 0; i < file->service_count(); i++) {\n PrintMockService(printer.get(), file->service(i).get(), &vars);\n printer->Print(\"\\n\");\n }\n\n if (!params.services_namespace.empty()) {\n printer->Print(vars, \"} // namespace $services_namespace$\\n\\n\");\n }\n }\n return output;\n}\n\ngrpc::string GetMockEpilogue(grpc_generator::File* file,\n const Parameters& /*params*/) {\n grpc::string temp;\n\n if (!file->package().empty()) {\n std::vector parts = file->package_parts();\n\n for (auto part = parts.begin(); part != parts.end(); part++) {\n temp.append(\"} // namespace \");\n temp.append(*part);\n temp.append(\"\\n\");\n }\n temp.append(\"\\n\");\n }\n\n return temp;\n}\n\n} // namespace grpc_cpp_generator\n" }, { "path": "grpc/src/compiler/cpp_generator.h", "content": "#ifndef GRPC_INTERNAL_COMPILER_CPP_GENERATOR_H\n#define GRPC_INTERNAL_COMPILER_CPP_GENERATOR_H\n\n// cpp_generator.h/.cc do not directly depend on GRPC/ProtoBuf, such that they\n// can be used to generate code for other serialization systems, such as\n// FlatBuffers.\n\n#include \n#include \n\n#include \"src/compiler/schema_interface.h\"\n\n#ifndef GRPC_CUSTOM_STRING\n#include \n#define GRPC_CUSTOM_STRING std::string\n#endif\n\nnamespace grpc {\n\ntypedef GRPC_CUSTOM_STRING string;\n\n} // namespace grpc\n\nnamespace grpc_cpp_generator {\n\n// Contains all the parameters that are parsed from the command line.\nstruct Parameters {\n // Puts the service into a namespace\n grpc::string services_namespace;\n // Use system includes (<>) or local includes (\"\")\n bool use_system_headers;\n // Prefix to any grpc include\n grpc::string grpc_search_path;\n // Generate GMOCK code to facilitate unit testing.\n bool generate_mock_code;\n // By default, use \"_generated.h\"\n std::string message_header_extension;\n // Default: \".grpc.fb.h\"\n std::string service_header_extension;\n // Generate modern callback-based async API service code (CallbackService)\n bool generate_callback_api = false;\n};\n\n// Return the prologue of the generated header file.\ngrpc::string GetHeaderPrologue(grpc_generator::File* file,\n const Parameters& params);\n\n// Return the includes needed for generated header file.\ngrpc::string GetHeaderIncludes(grpc_generator::File* file,\n const Parameters& params);\n\n// Return the includes needed for generated source file.\ngrpc::string GetSourceIncludes(grpc_generator::File* file,\n const Parameters& params);\n\n// Return the epilogue of the generated header file.\ngrpc::string GetHeaderEpilogue(grpc_generator::File* file,\n const Parameters& params);\n\n// Return the prologue of the generated source file.\ngrpc::string GetSourcePrologue(grpc_generator::File* file,\n const Parameters& params);\n\n// Return the services for generated header file.\ngrpc::string GetHeaderServices(grpc_generator::File* file,\n const Parameters& params);\n\n// Return the services for generated source file.\ngrpc::string GetSourceServices(grpc_generator::File* file,\n const Parameters& params);\n\n// Return the epilogue of the generated source file.\ngrpc::string GetSourceEpilogue(grpc_generator::File* file,\n const Parameters& params);\n\n// Return the prologue of the generated mock file.\ngrpc::string GetMockPrologue(grpc_generator::File* file,\n const Parameters& params);\n\n// Return the includes needed for generated mock file.\ngrpc::string GetMockIncludes(grpc_generator::File* file,\n const Parameters& params);\n\n// Return the services for generated mock file.\ngrpc::string GetMockServices(grpc_generator::File* file,\n const Parameters& params);\n\n// Return the epilogue of generated mock file.\ngrpc::string GetMockEpilogue(grpc_generator::File* file,\n const Parameters& params);\n\n// Return the prologue of the generated mock file.\ngrpc::string GetMockPrologue(grpc_generator::File* file,\n const Parameters& params);\n\n// Return the includes needed for generated mock file.\ngrpc::string GetMockIncludes(grpc_generator::File* file,\n const Parameters& params);\n\n// Return the services for generated mock file.\ngrpc::string GetMockServices(grpc_generator::File* file,\n const Parameters& params);\n\n// Return the epilogue of generated mock file.\ngrpc::string GetMockEpilogue(grpc_generator::File* file,\n const Parameters& params);\n\n} // namespace grpc_cpp_generator\n\n#endif // GRPC_INTERNAL_COMPILER_CPP_GENERATOR_H\n" }, { "path": "grpc/src/compiler/go_generator.cc", "content": "#include \"src/compiler/go_generator.h\"\n\n#include \n#include \n#include \n\ntemplate \ngrpc::string as_string(T x) {\n std::ostringstream out;\n out << x;\n return out.str();\n}\n\ninline bool ClientOnlyStreaming(const grpc_generator::Method* method) {\n return method->ClientStreaming() && !method->ServerStreaming();\n}\n\ninline bool ServerOnlyStreaming(const grpc_generator::Method* method) {\n return !method->ClientStreaming() && method->ServerStreaming();\n}\n\nnamespace grpc_go_generator {\nnamespace {\n\n// Returns string with first letter to lowerCase\nstatic grpc::string unexportName(grpc::string s) {\n if (s.empty()) return s;\n s[0] = static_cast(std::tolower(s[0]));\n return s;\n}\n\n// Returns string with first letter to uppercase\nstatic grpc::string exportName(grpc::string s) {\n if (s.empty()) return s;\n s[0] = static_cast(std::toupper(s[0]));\n return s;\n}\n\nstatic void GenerateError(grpc_generator::Printer* printer,\n std::map vars,\n const bool multiple_return = true) {\n printer->Print(vars, \"if $Error_Check$ {\\n\");\n printer->Indent();\n vars[\"Return\"] = multiple_return ? \"nil, err\" : \"err\";\n printer->Print(vars, \"return $Return$\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n}\n\n// Generates imports for the service\nstatic void GenerateImports(grpc_generator::File* file,\n grpc_generator::Printer* printer,\n std::map vars) {\n vars[\"filename\"] = file->filename();\n printer->Print(\"//Generated by gRPC Go plugin\\n\");\n printer->Print(\"//If you make any local changes, they will be lost\\n\");\n printer->Print(vars, \"//source: $filename$\\n\\n\");\n printer->Print(vars, \"package $Package$\\n\\n\");\n printer->Print(\"import (\\n\");\n printer->Indent();\n printer->Print(vars, \"$context$ \\\"context\\\"\\n\");\n printer->Print(\"flatbuffers \\\"github.com/google/flatbuffers/go\\\"\\n\");\n printer->Print(vars, \"$grpc$ \\\"google.golang.org/grpc\\\"\\n\");\n printer->Print(\"\\\"google.golang.org/grpc/codes\\\"\\n\");\n printer->Print(\"\\\"google.golang.org/grpc/status\\\"\\n\");\n printer->Outdent();\n printer->Print(\")\\n\\n\");\n}\n\n// Generates Server method signature source\nstatic void GenerateServerMethodSignature(\n const grpc_generator::Method* method, grpc_generator::Printer* printer,\n std::map vars) {\n vars[\"Method\"] = exportName(method->name());\n vars[\"Request\"] = method->get_input_type_name();\n vars[\"Response\"] = (vars[\"CustomMethodIO\"] == \"\")\n ? method->get_output_type_name()\n : vars[\"CustomMethodIO\"];\n if (method->NoStreaming()) {\n printer->Print(\n vars,\n \"$Method$($context$.Context, *$Request$) (*$Response$, error)$Ending$\");\n } else if (ServerOnlyStreaming(method)) {\n printer->Print(\n vars, \"$Method$(*$Request$, $Service$_$Method$Server) error$Ending$\");\n } else {\n printer->Print(vars, \"$Method$($Service$_$Method$Server) error$Ending$\");\n }\n}\n\nstatic void GenerateServerMethod(const grpc_generator::Method* method,\n grpc_generator::Printer* printer,\n std::map vars) {\n vars[\"Method\"] = exportName(method->name());\n vars[\"Request\"] = method->get_input_type_name();\n vars[\"Response\"] = (vars[\"CustomMethodIO\"] == \"\")\n ? method->get_output_type_name()\n : vars[\"CustomMethodIO\"];\n vars[\"FullMethodName\"] =\n \"/\" + vars[\"ServicePrefix\"] + vars[\"Service\"] + \"/\" + vars[\"Method\"];\n vars[\"Handler\"] = \"_\" + vars[\"Service\"] + \"_\" + vars[\"Method\"] + \"_Handler\";\n if (method->NoStreaming()) {\n printer->Print(\n vars,\n \"func $Handler$(srv interface{}, ctx $context$.Context,\\n\\tdec \"\n \"func(interface{}) error, interceptor $grpc$.UnaryServerInterceptor) \"\n \"(interface{}, error) {\\n\");\n printer->Indent();\n printer->Print(vars, \"in := new($Request$)\\n\");\n vars[\"Error_Check\"] = \"err := dec(in); err != nil\";\n GenerateError(printer, vars);\n printer->Print(\"if interceptor == nil {\\n\");\n printer->Indent();\n printer->Print(vars, \"return srv.($Service$Server).$Method$(ctx, in)\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n printer->Print(vars, \"info := &$grpc$.UnaryServerInfo{\\n\");\n printer->Indent();\n printer->Print(\"Server: srv,\\n\");\n printer->Print(vars, \"FullMethod: \\\"$FullMethodName$\\\",\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n printer->Outdent();\n printer->Print(\"\\n\");\n printer->Indent();\n printer->Print(vars,\n \"handler := func(ctx $context$.Context, req interface{}) \"\n \"(interface{}, error) {\\n\");\n printer->Indent();\n printer->Print(\n vars, \"return srv.($Service$Server).$Method$(ctx, req.(*$Request$))\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n printer->Print(\"return interceptor(ctx, in, info, handler)\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n return;\n }\n vars[\"StreamType\"] = vars[\"ServiceUnexported\"] + vars[\"Method\"] + \"Server\";\n printer->Print(\n vars,\n \"func $Handler$(srv interface{}, stream $grpc$.ServerStream) error {\\n\");\n printer->Indent();\n if (ServerOnlyStreaming(method)) {\n printer->Print(vars, \"m := new($Request$)\\n\");\n vars[\"Error_Check\"] = \"err := stream.RecvMsg(m); err != nil\";\n GenerateError(printer, vars, false);\n printer->Print(\n vars,\n \"return srv.($Service$Server).$Method$(m, &$StreamType${stream})\\n\");\n } else {\n printer->Print(\n vars, \"return srv.($Service$Server).$Method$(&$StreamType${stream})\\n\");\n }\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n\n bool genSend = method->BidiStreaming() || ServerOnlyStreaming(method);\n bool genRecv = method->BidiStreaming() || ClientOnlyStreaming(method);\n bool genSendAndClose = ClientOnlyStreaming(method);\n\n printer->Print(vars, \"type $Service$_$Method$Server interface {\\n\");\n printer->Indent();\n if (genSend) {\n printer->Print(vars, \"Send(*$Response$) error\\n\");\n }\n if (genRecv) {\n printer->Print(vars, \"Recv() (*$Request$, error)\\n\");\n }\n if (genSendAndClose) {\n printer->Print(vars, \"SendAndClose(*$Response$) error\\n\");\n }\n printer->Print(vars, \"$grpc$.ServerStream\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n\n printer->Print(vars, \"type $StreamType$ struct {\\n\");\n printer->Indent();\n printer->Print(vars, \"$grpc$.ServerStream\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n\n if (genSend) {\n printer->Print(vars,\n \"func (x *$StreamType$) Send(m *$Response$) error {\\n\");\n printer->Indent();\n printer->Print(\"return x.ServerStream.SendMsg(m)\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n }\n if (genRecv) {\n printer->Print(vars,\n \"func (x *$StreamType$) Recv() (*$Request$, error) {\\n\");\n printer->Indent();\n printer->Print(vars, \"m := new($Request$)\\n\");\n vars[\"Error_Check\"] = \"err := x.ServerStream.RecvMsg(m); err != nil\";\n GenerateError(printer, vars);\n printer->Print(\"return m, nil\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n }\n if (genSendAndClose) {\n printer->Print(\n vars, \"func (x *$StreamType$) SendAndClose(m *$Response$) error {\\n\");\n printer->Indent();\n printer->Print(\"return x.ServerStream.SendMsg(m)\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n }\n}\n\n// Generates Client method signature source\nstatic void GenerateClientMethodSignature(\n const grpc_generator::Method* method, grpc_generator::Printer* printer,\n std::map vars) {\n vars[\"Method\"] = exportName(method->name());\n vars[\"Request\"] =\n \", in *\" + ((vars[\"CustomMethodIO\"] == \"\") ? method->get_input_type_name()\n : vars[\"CustomMethodIO\"]);\n if (ClientOnlyStreaming(method) || method->BidiStreaming()) {\n vars[\"Request\"] = \"\";\n }\n vars[\"Response\"] = \"*\" + method->get_output_type_name();\n if (ClientOnlyStreaming(method) || method->BidiStreaming() ||\n ServerOnlyStreaming(method)) {\n vars[\"Response\"] = vars[\"Service\"] + \"_\" + vars[\"Method\"] + \"Client\";\n }\n printer->Print(vars,\n \"$Method$(ctx $context$.Context$Request$,\\n\\topts \"\n \"...$grpc$.CallOption) ($Response$, error)$Ending$\");\n}\n\n// Generates Client method source\nstatic void GenerateClientMethod(const grpc_generator::Method* method,\n grpc_generator::Printer* printer,\n std::map vars) {\n printer->Print(vars, \"func (c *$ServiceUnexported$Client) \");\n vars[\"Ending\"] = \" {\\n\";\n GenerateClientMethodSignature(method, printer, vars);\n printer->Indent();\n vars[\"Method\"] = exportName(method->name());\n vars[\"Request\"] = (vars[\"CustomMethodIO\"] == \"\")\n ? method->get_input_type_name()\n : vars[\"CustomMethodIO\"];\n vars[\"Response\"] = method->get_output_type_name();\n vars[\"FullMethodName\"] =\n \"/\" + vars[\"ServicePrefix\"] + vars[\"Service\"] + \"/\" + vars[\"Method\"];\n if (method->NoStreaming()) {\n printer->Print(vars, \"out := new($Response$)\\n\");\n printer->Print(\n vars,\n \"err := c.cc.Invoke(ctx, \\\"$FullMethodName$\\\", in, out, opts...)\\n\");\n vars[\"Error_Check\"] = \"err != nil\";\n GenerateError(printer, vars);\n printer->Print(\"return out, nil\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n return;\n }\n vars[\"StreamType\"] = vars[\"ServiceUnexported\"] + vars[\"Method\"] + \"Client\";\n printer->Print(vars,\n \"stream, err := c.cc.NewStream(ctx, &$MethodDesc$, \"\n \"\\\"$FullMethodName$\\\", opts...)\\n\");\n vars[\"Error_Check\"] = \"err != nil\";\n GenerateError(printer, vars);\n\n printer->Print(vars, \"x := &$StreamType${stream}\\n\");\n if (ServerOnlyStreaming(method)) {\n vars[\"Error_Check\"] = \"err := x.ClientStream.SendMsg(in); err != nil\";\n GenerateError(printer, vars);\n vars[\"Error_Check\"] = \"err := x.ClientStream.CloseSend(); err != nil\";\n GenerateError(printer, vars);\n }\n printer->Print(\"return x, nil\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n\n bool genSend = method->BidiStreaming() || ClientOnlyStreaming(method);\n bool genRecv = method->BidiStreaming() || ServerOnlyStreaming(method);\n bool genCloseAndRecv = ClientOnlyStreaming(method);\n\n // Stream interface\n printer->Print(vars, \"type $Service$_$Method$Client interface {\\n\");\n printer->Indent();\n if (genSend) {\n printer->Print(vars, \"Send(*$Request$) error\\n\");\n }\n if (genRecv) {\n printer->Print(vars, \"Recv() (*$Response$, error)\\n\");\n }\n if (genCloseAndRecv) {\n printer->Print(vars, \"CloseAndRecv() (*$Response$, error)\\n\");\n }\n printer->Print(vars, \"$grpc$.ClientStream\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n\n // Stream Client\n printer->Print(vars, \"type $StreamType$ struct {\\n\");\n printer->Indent();\n printer->Print(vars, \"$grpc$.ClientStream\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n\n if (genSend) {\n printer->Print(vars, \"func (x *$StreamType$) Send(m *$Request$) error {\\n\");\n printer->Indent();\n printer->Print(\"return x.ClientStream.SendMsg(m)\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n }\n\n if (genRecv) {\n printer->Print(vars,\n \"func (x *$StreamType$) Recv() (*$Response$, error) {\\n\");\n printer->Indent();\n printer->Print(vars, \"m := new($Response$)\\n\");\n vars[\"Error_Check\"] = \"err := x.ClientStream.RecvMsg(m); err != nil\";\n GenerateError(printer, vars);\n printer->Print(\"return m, nil\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n }\n\n if (genCloseAndRecv) {\n printer->Print(\n vars, \"func (x *$StreamType$) CloseAndRecv() (*$Response$, error) {\\n\");\n printer->Indent();\n vars[\"Error_Check\"] = \"err := x.ClientStream.CloseSend(); err != nil\";\n GenerateError(printer, vars);\n printer->Print(vars, \"m := new($Response$)\\n\");\n vars[\"Error_Check\"] = \"err := x.ClientStream.RecvMsg(m); err != nil\";\n GenerateError(printer, vars);\n printer->Print(\"return m, nil\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n }\n}\n\n// Generates client API for the service\nvoid GenerateService(const grpc_generator::Service* service,\n grpc_generator::Printer* printer,\n std::map vars) {\n vars[\"Service\"] = exportName(service->name());\n // Client Interface\n printer->Print(vars, \"// Client API for $Service$ service\\n\");\n printer->Print(vars, \"type $Service$Client interface {\\n\");\n printer->Indent();\n vars[\"Ending\"] = \"\\n\";\n for (int i = 0; i < service->method_count(); i++) {\n GenerateClientMethodSignature(service->method(i).get(), printer, vars);\n }\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n\n // Client structure\n vars[\"ServiceUnexported\"] = unexportName(vars[\"Service\"]);\n printer->Print(vars, \"type $ServiceUnexported$Client struct {\\n\");\n printer->Indent();\n printer->Print(vars, \"cc $grpc$.ClientConnInterface\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n\n // NewClient\n printer->Print(vars,\n \"func New$Service$Client(cc $grpc$.ClientConnInterface) \"\n \"$Service$Client {\\n\");\n printer->Indent();\n printer->Print(vars, \"return &$ServiceUnexported$Client{cc}\");\n printer->Outdent();\n printer->Print(\"\\n}\\n\\n\");\n\n int unary_methods = 0, streaming_methods = 0;\n vars[\"ServiceDesc\"] = \"_\" + vars[\"Service\"] + \"_serviceDesc\";\n for (int i = 0; i < service->method_count(); i++) {\n auto method = service->method(i);\n if (method->NoStreaming()) {\n vars[\"MethodDesc\"] =\n vars[\"ServiceDesc\"] + \".Method[\" + as_string(unary_methods) + \"]\";\n unary_methods++;\n } else {\n vars[\"MethodDesc\"] = vars[\"ServiceDesc\"] + \".Streams[\" +\n as_string(streaming_methods) + \"]\";\n streaming_methods++;\n }\n GenerateClientMethod(method.get(), printer, vars);\n }\n\n // Server Interface\n printer->Print(vars, \"// Server API for $Service$ service\\n\");\n printer->Print(vars, \"type $Service$Server interface {\\n\");\n printer->Indent();\n vars[\"Ending\"] = \"\\n\";\n for (int i = 0; i < service->method_count(); i++) {\n GenerateServerMethodSignature(service->method(i).get(), printer, vars);\n }\n printer->Print(vars, \"mustEmbedUnimplemented$Service$Server()\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n\n printer->Print(vars, \"type Unimplemented$Service$Server struct {\\n\");\n printer->Print(\"}\\n\\n\");\n\n vars[\"Ending\"] = \" {\\n\";\n for (int i = 0; i < service->method_count(); i++) {\n auto method = service->method(i);\n vars[\"Method\"] = exportName(method->name());\n vars[\"Nil\"] = method->NoStreaming() ? \"nil, \" : \"\";\n printer->Print(vars, \"func (Unimplemented$Service$Server) \");\n GenerateServerMethodSignature(method.get(), printer, vars);\n printer->Indent();\n printer->Print(vars,\n \"return $Nil$status.Errorf(codes.Unimplemented, \\\"method \"\n \"$Method$ not implemented\\\")\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n printer->Print(\"\\n\");\n }\n\n printer->Print(vars,\n \"func (Unimplemented$Service$Server) \"\n \"mustEmbedUnimplemented$Service$Server() {}\");\n printer->Print(\"\\n\\n\");\n\n printer->Print(vars, \"type Unsafe$Service$Server interface {\\n\");\n printer->Indent();\n printer->Print(vars, \"mustEmbedUnimplemented$Service$Server()\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n // Server registration.\n printer->Print(vars,\n \"func Register$Service$Server(s $grpc$.ServiceRegistrar, srv \"\n \"$Service$Server) {\\n\");\n printer->Indent();\n printer->Print(vars, \"s.RegisterService(&$ServiceDesc$, srv)\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\\n\");\n\n for (int i = 0; i < service->method_count(); i++) {\n GenerateServerMethod(service->method(i).get(), printer, vars);\n }\n\n // Service Descriptor\n printer->Print(vars, \"var $ServiceDesc$ = $grpc$.ServiceDesc{\\n\");\n printer->Indent();\n printer->Print(vars, \"ServiceName: \\\"$ServicePrefix$$Service$\\\",\\n\");\n printer->Print(vars, \"HandlerType: (*$Service$Server)(nil),\\n\");\n printer->Print(vars, \"Methods: []$grpc$.MethodDesc{\\n\");\n printer->Indent();\n for (int i = 0; i < service->method_count(); i++) {\n auto method = service->method(i);\n vars[\"Method\"] = exportName(method->name());\n vars[\"Handler\"] = \"_\" + vars[\"Service\"] + \"_\" + vars[\"Method\"] + \"_Handler\";\n if (method->NoStreaming()) {\n printer->Print(\"{\\n\");\n printer->Indent();\n printer->Print(vars, \"MethodName: \\\"$Method$\\\",\\n\");\n printer->Print(vars, \"Handler: $Handler$,\\n\");\n printer->Outdent();\n printer->Print(\"},\\n\");\n }\n }\n printer->Outdent();\n printer->Print(\"},\\n\");\n printer->Print(vars, \"Streams: []$grpc$.StreamDesc{\\n\");\n printer->Indent();\n for (int i = 0; i < service->method_count(); i++) {\n auto method = service->method(i);\n vars[\"Method\"] = exportName(method->name());\n vars[\"Handler\"] = \"_\" + vars[\"Service\"] + \"_\" + vars[\"Method\"] + \"_Handler\";\n if (!method->NoStreaming()) {\n printer->Print(\"{\\n\");\n printer->Indent();\n printer->Print(vars, \"StreamName: \\\"$Method$\\\",\\n\");\n printer->Print(vars, \"Handler: $Handler$,\\n\");\n if (ClientOnlyStreaming(method.get())) {\n printer->Print(\"ClientStreams: true,\\n\");\n } else if (ServerOnlyStreaming(method.get())) {\n printer->Print(\"ServerStreams: true,\\n\");\n } else {\n printer->Print(\"ServerStreams: true,\\n\");\n printer->Print(\"ClientStreams: true,\\n\");\n }\n printer->Outdent();\n printer->Print(\"},\\n\");\n }\n }\n printer->Outdent();\n printer->Print(\"},\\n\");\n printer->Outdent();\n printer->Print(\"}\\n\");\n}\n} // namespace\n\n// Returns source for the service\ngrpc::string GenerateServiceSource(grpc_generator::File* file,\n const grpc_generator::Service* service,\n grpc_go_generator::Parameters* parameters) {\n grpc::string out;\n auto p = file->CreatePrinter(&out, '\\t');\n p->SetIndentationSize(1);\n auto printer = p.get();\n std::map vars;\n vars[\"Package\"] = parameters->package_name;\n vars[\"ServicePrefix\"] = parameters->service_prefix;\n if (!parameters->service_prefix.empty()) vars[\"ServicePrefix\"].append(\".\");\n vars[\"grpc\"] = \"grpc\";\n vars[\"context\"] = \"context\";\n GenerateImports(file, printer, vars);\n if (parameters->custom_method_io_type != \"\") {\n vars[\"CustomMethodIO\"] = parameters->custom_method_io_type;\n }\n GenerateService(service, printer, vars);\n return out;\n}\n} // Namespace grpc_go_generator\n" }, { "path": "grpc/src/compiler/go_generator.h", "content": "#ifndef GRPC_INTERNAL_COMPILER_GO_GENERATOR_H\n#define GRPC_INTERNAL_COMPILER_GO_GENERATOR_H\n\n// go generator is used to generate GRPC code for serialization system, such as\n// flatbuffers\n#include \n#include \n\n#include \"src/compiler/schema_interface.h\"\n\nnamespace grpc_go_generator {\n\nstruct Parameters {\n // Defines the custom parameter types for methods\n // eg: flatbuffers uses flatbuffers.Builder as input for the client and output\n // for the server\n grpc::string custom_method_io_type;\n\n // Package name for the service\n grpc::string package_name;\n\n // Prefix for RPC Calls\n grpc::string service_prefix;\n};\n\n// Return the source of the generated service file.\ngrpc::string GenerateServiceSource(grpc_generator::File* file,\n const grpc_generator::Service* service,\n grpc_go_generator::Parameters* parameters);\n\n} // namespace grpc_go_generator\n\n#endif // GRPC_INTERNAL_COMPILER_GO_GENERATOR_H\n" }, { "path": "grpc/src/compiler/java_generator.cc", "content": "/*\n * Copyright 2016 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"src/compiler/java_generator.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"flatbuffers/util.h\"\n#define to_string flatbuffers::NumToString\n\n// Stringify helpers used solely to cast GRPC_VERSION\n#ifndef STR\n#define STR(s) #s\n#endif\n\n#ifndef XSTR\n#define XSTR(s) STR(s)\n#endif\n\ntypedef grpc_generator::Printer Printer;\ntypedef std::map VARS;\ntypedef grpc_generator::Service ServiceDescriptor;\ntypedef grpc_generator::CommentHolder\n DescriptorType; // base class of all 'descriptors'\ntypedef grpc_generator::Method MethodDescriptor;\n\nnamespace grpc_java_generator {\ntypedef std::string string;\nnamespace {\n// Generates imports for the service\nstatic void GenerateImports(grpc_generator::File* file,\n grpc_generator::Printer* printer, VARS& vars) {\n vars[\"filename\"] = file->filename();\n printer->Print(vars,\n \"//Generated by flatc compiler (version $flatc_version$)\\n\");\n printer->Print(\"//If you make any local changes, they will be lost\\n\");\n printer->Print(vars, \"//source: $filename$.fbs\\n\\n\");\n printer->Print(vars, \"package $Package$;\\n\\n\");\n vars[\"Package\"] = vars[\"Package\"] + \".\";\n if (!file->additional_headers().empty()) {\n printer->Print(file->additional_headers().c_str());\n printer->Print(\"\\n\\n\");\n }\n}\n\n// Adjust a method name prefix identifier to follow the JavaBean spec:\n// - decapitalize the first letter\n// - remove embedded underscores & capitalize the following letter\nstatic string MixedLower(const string& word) {\n string w;\n w += static_cast(tolower(word[0]));\n bool after_underscore = false;\n for (size_t i = 1; i < word.length(); ++i) {\n if (word[i] == '_') {\n after_underscore = true;\n } else {\n w += after_underscore ? static_cast(toupper(word[i]))\n : word[i];\n after_underscore = false;\n }\n }\n return w;\n}\n\n// Converts to the identifier to the ALL_UPPER_CASE format.\n// - An underscore is inserted where a lower case letter is followed by an\n// upper case letter.\n// - All letters are converted to upper case\nstatic string ToAllUpperCase(const string& word) {\n string w;\n for (size_t i = 0; i < word.length(); ++i) {\n w += static_cast(toupper(word[i]));\n if ((i < word.length() - 1) && islower(word[i]) && isupper(word[i + 1])) {\n w += '_';\n }\n }\n return w;\n}\n\nstatic inline string LowerMethodName(const MethodDescriptor* method) {\n return MixedLower(method->name());\n}\n\nstatic inline string MethodPropertiesFieldName(const MethodDescriptor* method) {\n return \"METHOD_\" + ToAllUpperCase(method->name());\n}\n\nstatic inline string MethodPropertiesGetterName(\n const MethodDescriptor* method) {\n return MixedLower(\"get_\" + method->name() + \"_method\");\n}\n\nstatic inline string MethodIdFieldName(const MethodDescriptor* method) {\n return \"METHODID_\" + ToAllUpperCase(method->name());\n}\n\nstatic inline string JavaClassName(VARS& vars, const string& name) {\n // string name = google::protobuf::compiler::java::ClassName(desc);\n return vars[\"Package\"] + name;\n}\n\nstatic inline string ServiceClassName(const string& service_name) {\n return service_name + \"Grpc\";\n}\n\n// TODO(nmittler): Remove once protobuf includes javadoc methods in\n// distribution.\ntemplate \nstatic void GrpcSplitStringToIteratorUsing(const string& full,\n const char* delim, ITR& result) {\n // Optimize the common case where delim is a single character.\n if (delim[0] != '\\0' && delim[1] == '\\0') {\n char c = delim[0];\n const char* p = full.data();\n const char* end = p + full.size();\n while (p != end) {\n if (*p == c) {\n ++p;\n } else {\n const char* start = p;\n while (++p != end && *p != c);\n *result++ = string(start, p - start);\n }\n }\n return;\n }\n\n string::size_type begin_index, end_index;\n begin_index = full.find_first_not_of(delim);\n while (begin_index != string::npos) {\n end_index = full.find_first_of(delim, begin_index);\n if (end_index == string::npos) {\n *result++ = full.substr(begin_index);\n return;\n }\n *result++ = full.substr(begin_index, (end_index - begin_index));\n begin_index = full.find_first_not_of(delim, end_index);\n }\n}\n\nstatic void GrpcSplitStringUsing(const string& full, const char* delim,\n std::vector* result) {\n std::back_insert_iterator> it(*result);\n GrpcSplitStringToIteratorUsing(full, delim, it);\n}\n\nstatic std::vector GrpcSplit(const string& full, const char* delim) {\n std::vector result;\n GrpcSplitStringUsing(full, delim, &result);\n return result;\n}\n\n// TODO(nmittler): Remove once protobuf includes javadoc methods in\n// distribution.\nstatic string GrpcEscapeJavadoc(const string& input) {\n string result;\n result.reserve(input.size() * 2);\n\n char prev = '*';\n\n for (string::size_type i = 0; i < input.size(); i++) {\n char c = input[i];\n switch (c) {\n case '*':\n // Avoid \"/*\".\n if (prev == '/') {\n result.append(\"*\");\n } else {\n result.push_back(c);\n }\n break;\n case '/':\n // Avoid \"*/\".\n if (prev == '*') {\n result.append(\"/\");\n } else {\n result.push_back(c);\n }\n break;\n case '@':\n // '@' starts javadoc tags including the @deprecated tag, which will\n // cause a compile-time error if inserted before a declaration that\n // does not have a corresponding @Deprecated annotation.\n result.append(\"@\");\n break;\n case '<':\n // Avoid interpretation as HTML.\n result.append(\"<\");\n break;\n case '>':\n // Avoid interpretation as HTML.\n result.append(\">\");\n break;\n case '&':\n // Avoid interpretation as HTML.\n result.append(\"&\");\n break;\n case '\\\\':\n // Java interprets Unicode escape sequences anywhere!\n result.append(\"\\");\n break;\n default:\n result.push_back(c);\n break;\n }\n\n prev = c;\n }\n\n return result;\n}\n\nstatic std::vector GrpcGetDocLines(const string& comments) {\n if (!comments.empty()) {\n // TODO(kenton): Ideally we should parse the comment text as Markdown and\n // write it back as HTML, but this requires a Markdown parser. For now\n // we just use 
 to get fixed-width text formatting.\n\n    // If the comment itself contains block comment start or end markers,\n    // HTML-escape them so that they don't accidentally close the doc comment.\n    string escapedComments = GrpcEscapeJavadoc(comments);\n\n    std::vector lines = GrpcSplit(escapedComments, \"\\n\");\n    while (!lines.empty() && lines.back().empty()) {\n      lines.pop_back();\n    }\n    return lines;\n  }\n  return std::vector();\n}\n\nstatic std::vector GrpcGetDocLinesForDescriptor(\n    const DescriptorType* descriptor) {\n  return descriptor->GetAllComments();\n  // return GrpcGetDocLines(descriptor->GetLeadingComments(\"///\"));\n}\n\nstatic void GrpcWriteDocCommentBody(Printer* printer, VARS& vars,\n                                    const std::vector& lines,\n                                    bool surroundWithPreTag) {\n  if (!lines.empty()) {\n    if (surroundWithPreTag) {\n      printer->Print(\" * 
\\n\");\n    }\n\n    for (size_t i = 0; i < lines.size(); i++) {\n      // Most lines should start with a space.  Watch out for lines that start\n      // with a /, since putting that right after the leading asterisk will\n      // close the comment.\n      vars[\"line\"] = lines[i];\n      if (!lines[i].empty() && lines[i][0] == '/') {\n        printer->Print(vars, \" * $line$\\n\");\n      } else {\n        printer->Print(vars, \" *$line$\\n\");\n      }\n    }\n\n    if (surroundWithPreTag) {\n      printer->Print(\" * 
\\n\");\n    }\n  }\n}\n\nstatic void GrpcWriteDocComment(Printer* printer, VARS& vars,\n                                const string& comments) {\n  printer->Print(\"/**\\n\");\n  std::vector lines = GrpcGetDocLines(comments);\n  GrpcWriteDocCommentBody(printer, vars, lines, false);\n  printer->Print(\" */\\n\");\n}\n\nstatic void GrpcWriteServiceDocComment(Printer* printer, VARS& vars,\n                                       const ServiceDescriptor* service) {\n  printer->Print(\"/**\\n\");\n  std::vector lines = GrpcGetDocLinesForDescriptor(service);\n  GrpcWriteDocCommentBody(printer, vars, lines, true);\n  printer->Print(\" */\\n\");\n}\n\nstatic void GrpcWriteMethodDocComment(Printer* printer, VARS& vars,\n                                      const MethodDescriptor* method) {\n  printer->Print(\"/**\\n\");\n  std::vector lines = GrpcGetDocLinesForDescriptor(method);\n  GrpcWriteDocCommentBody(printer, vars, lines, true);\n  printer->Print(\" */\\n\");\n}\n\n// outputs static singleton extractor for type stored in \"extr_type\" and\n// \"extr_type_name\" vars\nstatic void PrintTypeExtractor(Printer* p, VARS& vars) {\n  p->Print(vars,\n           \"private static volatile FlatbuffersUtils.FBExtactor<$extr_type$> \"\n           \"extractorOf$extr_type_name$;\\n\"\n           \"private static FlatbuffersUtils.FBExtactor<$extr_type$> \"\n           \"getExtractorOf$extr_type_name$() {\\n\"\n           \"    if (extractorOf$extr_type_name$ != null) return \"\n           \"extractorOf$extr_type_name$;\\n\"\n           \"    synchronized ($service_class_name$.class) {\\n\"\n           \"        if (extractorOf$extr_type_name$ != null) return \"\n           \"extractorOf$extr_type_name$;\\n\"\n           \"        extractorOf$extr_type_name$ = new \"\n           \"FlatbuffersUtils.FBExtactor<$extr_type$>() {\\n\"\n           \"            public $extr_type$ extract (ByteBuffer buffer) {\\n\"\n           \"                return \"\n           \"$extr_type$.getRootAs$extr_type_name$(buffer);\\n\"\n           \"            }\\n\"\n           \"        };\\n\"\n           \"        return extractorOf$extr_type_name$;\\n\"\n           \"    }\\n\"\n           \"}\\n\\n\");\n}\nstatic void PrintMethodFields(Printer* p, VARS& vars,\n                              const ServiceDescriptor* service) {\n  p->Print(\"// Static method descriptors that strictly reflect the proto.\\n\");\n  vars[\"service_name\"] = service->name();\n\n  // set of names of rpc input- and output- types that were already encountered.\n  // this is needed to avoid duplicating type extractor since it's possible that\n  // the same type is used as an input or output type of more than a single RPC\n  // method\n  std::set encounteredTypes;\n\n  for (int i = 0; i < service->method_count(); ++i) {\n    auto method = service->method(i);\n    vars[\"arg_in_id\"] = to_string(2L * i);  // trying to make msvc 10 happy\n    vars[\"arg_out_id\"] = to_string(2L * i + 1);\n    vars[\"method_name\"] = method->name();\n    vars[\"input_type_name\"] = method->get_input_type_name();\n    vars[\"output_type_name\"] = method->get_output_type_name();\n    vars[\"input_type\"] = JavaClassName(vars, method->get_input_type_name());\n    vars[\"output_type\"] = JavaClassName(vars, method->get_output_type_name());\n    vars[\"method_field_name\"] = MethodPropertiesFieldName(method.get());\n    vars[\"method_new_field_name\"] = MethodPropertiesGetterName(method.get());\n    vars[\"method_method_name\"] = MethodPropertiesGetterName(method.get());\n    bool client_streaming =\n        method->ClientStreaming() || method->BidiStreaming();\n    bool server_streaming =\n        method->ServerStreaming() || method->BidiStreaming();\n    if (client_streaming) {\n      if (server_streaming) {\n        vars[\"method_type\"] = \"BIDI_STREAMING\";\n      } else {\n        vars[\"method_type\"] = \"CLIENT_STREAMING\";\n      }\n    } else {\n      if (server_streaming) {\n        vars[\"method_type\"] = \"SERVER_STREAMING\";\n      } else {\n        vars[\"method_type\"] = \"UNARY\";\n      }\n    }\n\n    p->Print(\n        vars,\n        \"@$ExperimentalApi$(\\\"https://github.com/grpc/grpc-java/issues/\"\n        \"1901\\\")\\n\"\n        \"@$Deprecated$ // Use {@link #$method_method_name$()} instead. \\n\"\n        \"public static final $MethodDescriptor$<$input_type$,\\n\"\n        \"    $output_type$> $method_field_name$ = $method_method_name$();\\n\"\n        \"\\n\"\n        \"private static volatile $MethodDescriptor$<$input_type$,\\n\"\n        \"    $output_type$> $method_new_field_name$;\\n\"\n        \"\\n\");\n\n    if (encounteredTypes.insert(vars[\"input_type_name\"]).second) {\n      vars[\"extr_type\"] = vars[\"input_type\"];\n      vars[\"extr_type_name\"] = vars[\"input_type_name\"];\n      PrintTypeExtractor(p, vars);\n    }\n\n    if (encounteredTypes.insert(vars[\"output_type_name\"]).second) {\n      vars[\"extr_type\"] = vars[\"output_type\"];\n      vars[\"extr_type_name\"] = vars[\"output_type_name\"];\n      PrintTypeExtractor(p, vars);\n    }\n\n    p->Print(\n        vars,\n        \"@$ExperimentalApi$(\\\"https://github.com/grpc/grpc-java/issues/\"\n        \"1901\\\")\\n\"\n        \"public static $MethodDescriptor$<$input_type$,\\n\"\n        \"    $output_type$> $method_method_name$() {\\n\"\n        \"  $MethodDescriptor$<$input_type$, $output_type$> \"\n        \"$method_new_field_name$;\\n\"\n        \"  if (($method_new_field_name$ = \"\n        \"$service_class_name$.$method_new_field_name$) == null) {\\n\"\n        \"    synchronized ($service_class_name$.class) {\\n\"\n        \"      if (($method_new_field_name$ = \"\n        \"$service_class_name$.$method_new_field_name$) == null) {\\n\"\n        \"        $service_class_name$.$method_new_field_name$ = \"\n        \"$method_new_field_name$ = \\n\"\n        \"            $MethodDescriptor$.<$input_type$, \"\n        \"$output_type$>newBuilder()\\n\"\n        \"            .setType($MethodType$.$method_type$)\\n\"\n        \"            .setFullMethodName(generateFullMethodName(\\n\"\n        \"                \\\"$Package$$service_name$\\\", \\\"$method_name$\\\"))\\n\"\n        \"            .setSampledToLocalTracing(true)\\n\"\n        \"            .setRequestMarshaller(FlatbuffersUtils.marshaller(\\n\"\n        \"                $input_type$.class, \"\n        \"getExtractorOf$input_type_name$()))\\n\"\n        \"            .setResponseMarshaller(FlatbuffersUtils.marshaller(\\n\"\n        \"                $output_type$.class, \"\n        \"getExtractorOf$output_type_name$()))\\n\");\n\n    //            vars[\"proto_method_descriptor_supplier\"] = service->name() +\n    //            \"MethodDescriptorSupplier\";\n    p->Print(vars, \"                .setSchemaDescriptor(null)\\n\");\n    //\"                .setSchemaDescriptor(new\n    //$proto_method_descriptor_supplier$(\\\"$method_name$\\\"))\\n\");\n\n    p->Print(vars, \"                .build();\\n\");\n    p->Print(vars,\n             \"        }\\n\"\n             \"      }\\n\"\n             \"   }\\n\"\n             \"   return $method_new_field_name$;\\n\"\n             \"}\\n\");\n\n    p->Print(\"\\n\");\n  }\n}\nenum StubType {\n  ASYNC_INTERFACE = 0,\n  BLOCKING_CLIENT_INTERFACE = 1,\n  FUTURE_CLIENT_INTERFACE = 2,\n  BLOCKING_SERVER_INTERFACE = 3,\n  ASYNC_CLIENT_IMPL = 4,\n  BLOCKING_CLIENT_IMPL = 5,\n  FUTURE_CLIENT_IMPL = 6,\n  ABSTRACT_CLASS = 7,\n};\n\nenum CallType { ASYNC_CALL = 0, BLOCKING_CALL = 1, FUTURE_CALL = 2 };\n\nstatic void PrintBindServiceMethodBody(Printer* p, VARS& vars,\n                                       const ServiceDescriptor* service);\n\n// Prints a client interface or implementation class, or a server interface.\nstatic void PrintStub(Printer* p, VARS& vars, const ServiceDescriptor* service,\n                      StubType type) {\n  const string service_name = service->name();\n  vars[\"service_name\"] = service_name;\n  vars[\"abstract_name\"] = service_name + \"ImplBase\";\n  string stub_name = service_name;\n  string client_name = service_name;\n  CallType call_type = ASYNC_CALL;\n  bool impl_base = false;\n  bool interface = false;\n  switch (type) {\n    case ABSTRACT_CLASS:\n      call_type = ASYNC_CALL;\n      impl_base = true;\n      break;\n    case ASYNC_CLIENT_IMPL:\n      call_type = ASYNC_CALL;\n      stub_name += \"Stub\";\n      break;\n    case BLOCKING_CLIENT_INTERFACE:\n      interface = true;\n      FLATBUFFERS_FALLTHROUGH();  // fall thru\n    case BLOCKING_CLIENT_IMPL:\n      call_type = BLOCKING_CALL;\n      stub_name += \"BlockingStub\";\n      client_name += \"BlockingClient\";\n      break;\n    case FUTURE_CLIENT_INTERFACE:\n      interface = true;\n      FLATBUFFERS_FALLTHROUGH();  // fall thru\n    case FUTURE_CLIENT_IMPL:\n      call_type = FUTURE_CALL;\n      stub_name += \"FutureStub\";\n      client_name += \"FutureClient\";\n      break;\n    case ASYNC_INTERFACE:\n      call_type = ASYNC_CALL;\n      interface = true;\n      break;\n    default:\n      GRPC_CODEGEN_FAIL << \"Cannot determine class name for StubType: \" << type;\n  }\n  vars[\"stub_name\"] = stub_name;\n  vars[\"client_name\"] = client_name;\n\n  // Class head\n  if (!interface) {\n    GrpcWriteServiceDocComment(p, vars, service);\n  }\n  if (impl_base) {\n    p->Print(vars,\n             \"public static abstract class $abstract_name$ implements \"\n             \"$BindableService$ {\\n\");\n  } else {\n    p->Print(vars,\n             \"public static final class $stub_name$ extends \"\n             \"$AbstractStub$<$stub_name$> {\\n\");\n  }\n  p->Indent();\n\n  // Constructor and build() method\n  if (!impl_base && !interface) {\n    p->Print(vars, \"private $stub_name$($Channel$ channel) {\\n\");\n    p->Indent();\n    p->Print(\"super(channel);\\n\");\n    p->Outdent();\n    p->Print(\"}\\n\\n\");\n    p->Print(vars,\n             \"private $stub_name$($Channel$ channel,\\n\"\n             \"    $CallOptions$ callOptions) {\\n\");\n    p->Indent();\n    p->Print(\"super(channel, callOptions);\\n\");\n    p->Outdent();\n    p->Print(\"}\\n\\n\");\n    p->Print(vars,\n             \"@$Override$\\n\"\n             \"protected $stub_name$ build($Channel$ channel,\\n\"\n             \"    $CallOptions$ callOptions) {\\n\");\n    p->Indent();\n    p->Print(vars, \"return new $stub_name$(channel, callOptions);\\n\");\n    p->Outdent();\n    p->Print(\"}\\n\");\n  }\n\n  // RPC methods\n  for (int i = 0; i < service->method_count(); ++i) {\n    auto method = service->method(i);\n    vars[\"input_type\"] = JavaClassName(vars, method->get_input_type_name());\n    vars[\"output_type\"] = JavaClassName(vars, method->get_output_type_name());\n    vars[\"lower_method_name\"] = LowerMethodName(&*method);\n    vars[\"method_method_name\"] = MethodPropertiesGetterName(&*method);\n    bool client_streaming =\n        method->ClientStreaming() || method->BidiStreaming();\n    bool server_streaming =\n        method->ServerStreaming() || method->BidiStreaming();\n\n    if (call_type == BLOCKING_CALL && client_streaming) {\n      // Blocking client interface with client streaming is not available\n      continue;\n    }\n\n    if (call_type == FUTURE_CALL && (client_streaming || server_streaming)) {\n      // Future interface doesn't support streaming.\n      continue;\n    }\n\n    // Method signature\n    p->Print(\"\\n\");\n    // TODO(nmittler): Replace with WriteMethodDocComment once included by the\n    // protobuf distro.\n    if (!interface) {\n      GrpcWriteMethodDocComment(p, vars, &*method);\n    }\n    p->Print(\"public \");\n    switch (call_type) {\n      case BLOCKING_CALL:\n        GRPC_CODEGEN_CHECK(!client_streaming)\n            << \"Blocking client interface with client streaming is unavailable\";\n        if (server_streaming) {\n          // Server streaming\n          p->Print(vars,\n                   \"$Iterator$<$output_type$> $lower_method_name$(\\n\"\n                   \"    $input_type$ request)\");\n        } else {\n          // Simple RPC\n          p->Print(vars,\n                   \"$output_type$ $lower_method_name$($input_type$ request)\");\n        }\n        break;\n      case ASYNC_CALL:\n        if (client_streaming) {\n          // Bidirectional streaming or client streaming\n          p->Print(vars,\n                   \"$StreamObserver$<$input_type$> $lower_method_name$(\\n\"\n                   \"    $StreamObserver$<$output_type$> responseObserver)\");\n        } else {\n          // Server streaming or simple RPC\n          p->Print(vars,\n                   \"void $lower_method_name$($input_type$ request,\\n\"\n                   \"    $StreamObserver$<$output_type$> responseObserver)\");\n        }\n        break;\n      case FUTURE_CALL:\n        GRPC_CODEGEN_CHECK(!client_streaming && !server_streaming)\n            << \"Future interface doesn't support streaming. \"\n            << \"client_streaming=\" << client_streaming << \", \"\n            << \"server_streaming=\" << server_streaming;\n        p->Print(vars,\n                 \"$ListenableFuture$<$output_type$> $lower_method_name$(\\n\"\n                 \"    $input_type$ request)\");\n        break;\n    }\n\n    if (interface) {\n      p->Print(\";\\n\");\n      continue;\n    }\n    // Method body.\n    p->Print(\" {\\n\");\n    p->Indent();\n    if (impl_base) {\n      switch (call_type) {\n          // NB: Skipping validation of service methods. If something is wrong,\n          // we wouldn't get to this point as compiler would return errors when\n          // generating service interface.\n        case ASYNC_CALL:\n          if (client_streaming) {\n            p->Print(vars,\n                     \"return \"\n                     \"asyncUnimplementedStreamingCall($method_method_name$(), \"\n                     \"responseObserver);\\n\");\n          } else {\n            p->Print(vars,\n                     \"asyncUnimplementedUnaryCall($method_method_name$(), \"\n                     \"responseObserver);\\n\");\n          }\n          break;\n        default:\n          break;\n      }\n    } else if (!interface) {\n      switch (call_type) {\n        case BLOCKING_CALL:\n          GRPC_CODEGEN_CHECK(!client_streaming)\n              << \"Blocking client streaming interface is not available\";\n          if (server_streaming) {\n            vars[\"calls_method\"] = \"blockingServerStreamingCall\";\n            vars[\"params\"] = \"request\";\n          } else {\n            vars[\"calls_method\"] = \"blockingUnaryCall\";\n            vars[\"params\"] = \"request\";\n          }\n          p->Print(vars,\n                   \"return $calls_method$(\\n\"\n                   \"    getChannel(), $method_method_name$(), \"\n                   \"getCallOptions(), $params$);\\n\");\n          break;\n        case ASYNC_CALL:\n          if (server_streaming) {\n            if (client_streaming) {\n              vars[\"calls_method\"] = \"asyncBidiStreamingCall\";\n              vars[\"params\"] = \"responseObserver\";\n            } else {\n              vars[\"calls_method\"] = \"asyncServerStreamingCall\";\n              vars[\"params\"] = \"request, responseObserver\";\n            }\n          } else {\n            if (client_streaming) {\n              vars[\"calls_method\"] = \"asyncClientStreamingCall\";\n              vars[\"params\"] = \"responseObserver\";\n            } else {\n              vars[\"calls_method\"] = \"asyncUnaryCall\";\n              vars[\"params\"] = \"request, responseObserver\";\n            }\n          }\n          vars[\"last_line_prefix\"] = client_streaming ? \"return \" : \"\";\n          p->Print(vars,\n                   \"$last_line_prefix$$calls_method$(\\n\"\n                   \"    getChannel().newCall($method_method_name$(), \"\n                   \"getCallOptions()), $params$);\\n\");\n          break;\n        case FUTURE_CALL:\n          GRPC_CODEGEN_CHECK(!client_streaming && !server_streaming)\n              << \"Future interface doesn't support streaming. \"\n              << \"client_streaming=\" << client_streaming << \", \"\n              << \"server_streaming=\" << server_streaming;\n          vars[\"calls_method\"] = \"futureUnaryCall\";\n          p->Print(vars,\n                   \"return $calls_method$(\\n\"\n                   \"    getChannel().newCall($method_method_name$(), \"\n                   \"getCallOptions()), request);\\n\");\n          break;\n      }\n    }\n    p->Outdent();\n    p->Print(\"}\\n\");\n  }\n\n  if (impl_base) {\n    p->Print(\"\\n\");\n    p->Print(\n        vars,\n        \"@$Override$ public final $ServerServiceDefinition$ bindService() {\\n\");\n    vars[\"instance\"] = \"this\";\n    PrintBindServiceMethodBody(p, vars, service);\n    p->Print(\"}\\n\");\n  }\n\n  p->Outdent();\n  p->Print(\"}\\n\\n\");\n}\n\nstatic bool CompareMethodClientStreaming(\n    const std::unique_ptr& method1,\n    const std::unique_ptr& method2) {\n  return method1->ClientStreaming() < method2->ClientStreaming();\n}\n\n// Place all method invocations into a single class to reduce memory footprint\n// on Android.\nstatic void PrintMethodHandlerClass(Printer* p, VARS& vars,\n                                    const ServiceDescriptor* service) {\n  // Sort method ids based on ClientStreaming() so switch tables are compact.\n  std::vector> sorted_methods(\n      service->method_count());\n  for (int i = 0; i < service->method_count(); ++i) {\n    sorted_methods[i] = service->method(i);\n  }\n  stable_sort(sorted_methods.begin(), sorted_methods.end(),\n              CompareMethodClientStreaming);\n  for (size_t i = 0; i < sorted_methods.size(); i++) {\n    auto& method = sorted_methods[i];\n    vars[\"method_id\"] = to_string(i);\n    vars[\"method_id_name\"] = MethodIdFieldName(&*method);\n    p->Print(vars,\n             \"private static final int $method_id_name$ = $method_id$;\\n\");\n  }\n  p->Print(\"\\n\");\n  vars[\"service_name\"] = service->name() + \"ImplBase\";\n  p->Print(vars,\n           \"private static final class MethodHandlers implements\\n\"\n           \"    io.grpc.stub.ServerCalls.UnaryMethod,\\n\"\n           \"    io.grpc.stub.ServerCalls.ServerStreamingMethod,\\n\"\n           \"    io.grpc.stub.ServerCalls.ClientStreamingMethod,\\n\"\n           \"    io.grpc.stub.ServerCalls.BidiStreamingMethod {\\n\"\n           \"  private final $service_name$ serviceImpl;\\n\"\n           \"  private final int methodId;\\n\"\n           \"\\n\"\n           \"  MethodHandlers($service_name$ serviceImpl, int methodId) {\\n\"\n           \"    this.serviceImpl = serviceImpl;\\n\"\n           \"    this.methodId = methodId;\\n\"\n           \"  }\\n\\n\");\n  p->Indent();\n  p->Print(vars,\n           \"@$Override$\\n\"\n           \"@java.lang.SuppressWarnings(\\\"unchecked\\\")\\n\"\n           \"public void invoke(Req request, $StreamObserver$ \"\n           \"responseObserver) {\\n\"\n           \"  switch (methodId) {\\n\");\n  p->Indent();\n  p->Indent();\n\n  for (int i = 0; i < service->method_count(); ++i) {\n    auto method = service->method(i);\n    if (method->ClientStreaming() || method->BidiStreaming()) {\n      continue;\n    }\n    vars[\"method_id_name\"] = MethodIdFieldName(&*method);\n    vars[\"lower_method_name\"] = LowerMethodName(&*method);\n    vars[\"input_type\"] = JavaClassName(vars, method->get_input_type_name());\n    vars[\"output_type\"] = JavaClassName(vars, method->get_output_type_name());\n    p->Print(vars,\n             \"case $method_id_name$:\\n\"\n             \"  serviceImpl.$lower_method_name$(($input_type$) request,\\n\"\n             \"      ($StreamObserver$<$output_type$>) responseObserver);\\n\"\n             \"  break;\\n\");\n  }\n  p->Print(\n      \"default:\\n\"\n      \"  throw new AssertionError();\\n\");\n\n  p->Outdent();\n  p->Outdent();\n  p->Print(\n      \"  }\\n\"\n      \"}\\n\\n\");\n\n  p->Print(vars,\n           \"@$Override$\\n\"\n           \"@java.lang.SuppressWarnings(\\\"unchecked\\\")\\n\"\n           \"public $StreamObserver$ invoke(\\n\"\n           \"    $StreamObserver$ responseObserver) {\\n\"\n           \"  switch (methodId) {\\n\");\n  p->Indent();\n  p->Indent();\n\n  for (int i = 0; i < service->method_count(); ++i) {\n    auto method = service->method(i);\n    if (!(method->ClientStreaming() || method->BidiStreaming())) {\n      continue;\n    }\n    vars[\"method_id_name\"] = MethodIdFieldName(&*method);\n    vars[\"lower_method_name\"] = LowerMethodName(&*method);\n    vars[\"input_type\"] = JavaClassName(vars, method->get_input_type_name());\n    vars[\"output_type\"] = JavaClassName(vars, method->get_output_type_name());\n    p->Print(\n        vars,\n        \"case $method_id_name$:\\n\"\n        \"  return ($StreamObserver$) serviceImpl.$lower_method_name$(\\n\"\n        \"      ($StreamObserver$<$output_type$>) responseObserver);\\n\");\n  }\n  p->Print(\n      \"default:\\n\"\n      \"  throw new AssertionError();\\n\");\n\n  p->Outdent();\n  p->Outdent();\n  p->Print(\n      \"  }\\n\"\n      \"}\\n\");\n\n  p->Outdent();\n  p->Print(\"}\\n\\n\");\n}\n\nstatic void PrintGetServiceDescriptorMethod(Printer* p, VARS& vars,\n                                            const ServiceDescriptor* service) {\n  vars[\"service_name\"] = service->name();\n  //        vars[\"proto_base_descriptor_supplier\"] = service->name() +\n  //        \"BaseDescriptorSupplier\"; vars[\"proto_file_descriptor_supplier\"] =\n  //        service->name() + \"FileDescriptorSupplier\";\n  //        vars[\"proto_method_descriptor_supplier\"] = service->name() +\n  //        \"MethodDescriptorSupplier\"; vars[\"proto_class_name\"] =\n  //        google::protobuf::compiler::java::ClassName(service->file());\n  //        p->Print(\n  //                 vars,\n  //                 \"private static abstract class\n  //                 $proto_base_descriptor_supplier$\\n\" \"    implements\n  //                 $ProtoFileDescriptorSupplier$,\n  //                 $ProtoServiceDescriptorSupplier$ {\\n\" \"\n  //                 $proto_base_descriptor_supplier$() {}\\n\"\n  //                 \"\\n\"\n  //                 \"  @$Override$\\n\"\n  //                 \"  public com.google.protobuf.Descriptors.FileDescriptor\n  //                 getFileDescriptor() {\\n\" \"    return\n  //                 $proto_class_name$.getDescriptor();\\n\" \"  }\\n\"\n  //                 \"\\n\"\n  //                 \"  @$Override$\\n\"\n  //                 \"  public com.google.protobuf.Descriptors.ServiceDescriptor\n  //                 getServiceDescriptor() {\\n\" \"    return\n  //                 getFileDescriptor().findServiceByName(\\\"$service_name$\\\");\\n\"\n  //                 \"  }\\n\"\n  //                 \"}\\n\"\n  //                 \"\\n\"\n  //                 \"private static final class\n  //                 $proto_file_descriptor_supplier$\\n\" \"    extends\n  //                 $proto_base_descriptor_supplier$ {\\n\" \"\n  //                 $proto_file_descriptor_supplier$() {}\\n\"\n  //                 \"}\\n\"\n  //                 \"\\n\"\n  //                 \"private static final class\n  //                 $proto_method_descriptor_supplier$\\n\" \"    extends\n  //                 $proto_base_descriptor_supplier$\\n\" \"    implements\n  //                 $ProtoMethodDescriptorSupplier$ {\\n\" \"  private final\n  //                 String methodName;\\n\"\n  //                 \"\\n\"\n  //                 \"  $proto_method_descriptor_supplier$(String methodName)\n  //                 {\\n\" \"    this.methodName = methodName;\\n\" \"  }\\n\"\n  //                 \"\\n\"\n  //                 \"  @$Override$\\n\"\n  //                 \"  public com.google.protobuf.Descriptors.MethodDescriptor\n  //                 getMethodDescriptor() {\\n\" \"    return\n  //                 getServiceDescriptor().findMethodByName(methodName);\\n\" \"\n  //                 }\\n\"\n  //                 \"}\\n\\n\");\n\n  p->Print(\n      vars,\n      \"private static volatile $ServiceDescriptor$ serviceDescriptor;\\n\\n\");\n\n  p->Print(vars,\n           \"public static $ServiceDescriptor$ getServiceDescriptor() {\\n\");\n  p->Indent();\n  p->Print(vars, \"$ServiceDescriptor$ result = serviceDescriptor;\\n\");\n  p->Print(\"if (result == null) {\\n\");\n  p->Indent();\n  p->Print(vars, \"synchronized ($service_class_name$.class) {\\n\");\n  p->Indent();\n  p->Print(\"result = serviceDescriptor;\\n\");\n  p->Print(\"if (result == null) {\\n\");\n  p->Indent();\n\n  p->Print(vars,\n           \"serviceDescriptor = result = \"\n           \"$ServiceDescriptor$.newBuilder(SERVICE_NAME)\");\n  p->Indent();\n  p->Indent();\n  p->Print(vars, \"\\n.setSchemaDescriptor(null)\");\n  for (int i = 0; i < service->method_count(); ++i) {\n    auto method = service->method(i);\n    vars[\"method_method_name\"] = MethodPropertiesGetterName(&*method);\n    p->Print(vars, \"\\n.addMethod($method_method_name$())\");\n  }\n  p->Print(\"\\n.build();\\n\");\n  p->Outdent();\n  p->Outdent();\n\n  p->Outdent();\n  p->Print(\"}\\n\");\n  p->Outdent();\n  p->Print(\"}\\n\");\n  p->Outdent();\n  p->Print(\"}\\n\");\n  p->Print(\"return result;\\n\");\n  p->Outdent();\n  p->Print(\"}\\n\");\n}\n\nstatic void PrintBindServiceMethodBody(Printer* p, VARS& vars,\n                                       const ServiceDescriptor* service) {\n  vars[\"service_name\"] = service->name();\n  p->Indent();\n  p->Print(vars,\n           \"return \"\n           \"$ServerServiceDefinition$.builder(getServiceDescriptor())\\n\");\n  p->Indent();\n  p->Indent();\n  for (int i = 0; i < service->method_count(); ++i) {\n    auto method = service->method(i);\n    vars[\"lower_method_name\"] = LowerMethodName(&*method);\n    vars[\"method_method_name\"] = MethodPropertiesGetterName(&*method);\n    vars[\"input_type\"] = JavaClassName(vars, method->get_input_type_name());\n    vars[\"output_type\"] = JavaClassName(vars, method->get_output_type_name());\n    vars[\"method_id_name\"] = MethodIdFieldName(&*method);\n    bool client_streaming =\n        method->ClientStreaming() || method->BidiStreaming();\n    bool server_streaming =\n        method->ServerStreaming() || method->BidiStreaming();\n    if (client_streaming) {\n      if (server_streaming) {\n        vars[\"calls_method\"] = \"asyncBidiStreamingCall\";\n      } else {\n        vars[\"calls_method\"] = \"asyncClientStreamingCall\";\n      }\n    } else {\n      if (server_streaming) {\n        vars[\"calls_method\"] = \"asyncServerStreamingCall\";\n      } else {\n        vars[\"calls_method\"] = \"asyncUnaryCall\";\n      }\n    }\n    p->Print(vars, \".addMethod(\\n\");\n    p->Indent();\n    p->Print(vars,\n             \"$method_method_name$(),\\n\"\n             \"$calls_method$(\\n\");\n    p->Indent();\n    p->Print(vars,\n             \"new MethodHandlers<\\n\"\n             \"  $input_type$,\\n\"\n             \"  $output_type$>(\\n\"\n             \"    $instance$, $method_id_name$)))\\n\");\n    p->Outdent();\n    p->Outdent();\n  }\n  p->Print(\".build();\\n\");\n  p->Outdent();\n  p->Outdent();\n  p->Outdent();\n}\n\nstatic void PrintService(Printer* p, VARS& vars,\n                         const ServiceDescriptor* service,\n                         bool disable_version) {\n  vars[\"service_name\"] = service->name();\n  vars[\"service_class_name\"] = ServiceClassName(service->name());\n  vars[\"grpc_version\"] = \"\";\n#ifdef GRPC_VERSION\n  if (!disable_version) {\n    vars[\"grpc_version\"] = \" (version \" XSTR(GRPC_VERSION) \")\";\n  }\n#else\n  (void)disable_version;\n#endif\n  // TODO(nmittler): Replace with WriteServiceDocComment once included by\n  // protobuf distro.\n  GrpcWriteServiceDocComment(p, vars, service);\n  p->Print(vars,\n           \"@$Generated$(\\n\"\n           \"    value = \\\"by gRPC proto compiler$grpc_version$\\\",\\n\"\n           \"    comments = \\\"Source: $file_name$.fbs\\\")\\n\"\n           \"public final class $service_class_name$ {\\n\\n\");\n  p->Indent();\n  p->Print(vars, \"private $service_class_name$() {}\\n\\n\");\n\n  p->Print(vars,\n           \"public static final String SERVICE_NAME = \"\n           \"\\\"$Package$$service_name$\\\";\\n\\n\");\n\n  PrintMethodFields(p, vars, service);\n\n  // TODO(nmittler): Replace with WriteDocComment once included by protobuf\n  // distro.\n  GrpcWriteDocComment(\n      p, vars,\n      \" Creates a new async stub that supports all call types for the service\");\n  p->Print(vars,\n           \"public static $service_name$Stub newStub($Channel$ channel) {\\n\");\n  p->Indent();\n  p->Print(vars, \"return new $service_name$Stub(channel);\\n\");\n  p->Outdent();\n  p->Print(\"}\\n\\n\");\n\n  // TODO(nmittler): Replace with WriteDocComment once included by protobuf\n  // distro.\n  GrpcWriteDocComment(\n      p, vars,\n      \" Creates a new blocking-style stub that supports unary and streaming \"\n      \"output calls on the service\");\n  p->Print(vars,\n           \"public static $service_name$BlockingStub newBlockingStub(\\n\"\n           \"    $Channel$ channel) {\\n\");\n  p->Indent();\n  p->Print(vars, \"return new $service_name$BlockingStub(channel);\\n\");\n  p->Outdent();\n  p->Print(\"}\\n\\n\");\n\n  // TODO(nmittler): Replace with WriteDocComment once included by protobuf\n  // distro.\n  GrpcWriteDocComment(\n      p, vars,\n      \" Creates a new ListenableFuture-style stub that supports unary calls \"\n      \"on the service\");\n  p->Print(vars,\n           \"public static $service_name$FutureStub newFutureStub(\\n\"\n           \"    $Channel$ channel) {\\n\");\n  p->Indent();\n  p->Print(vars, \"return new $service_name$FutureStub(channel);\\n\");\n  p->Outdent();\n  p->Print(\"}\\n\\n\");\n\n  PrintStub(p, vars, service, ABSTRACT_CLASS);\n  PrintStub(p, vars, service, ASYNC_CLIENT_IMPL);\n  PrintStub(p, vars, service, BLOCKING_CLIENT_IMPL);\n  PrintStub(p, vars, service, FUTURE_CLIENT_IMPL);\n\n  PrintMethodHandlerClass(p, vars, service);\n  PrintGetServiceDescriptorMethod(p, vars, service);\n  p->Outdent();\n  p->Print(\"}\\n\");\n}\n\nstatic void PrintStaticImports(Printer* p) {\n  p->Print(\n      \"import java.nio.ByteBuffer;\\n\"\n      \"import static \"\n      \"io.grpc.MethodDescriptor.generateFullMethodName;\\n\"\n      \"import static \"\n      \"io.grpc.stub.ClientCalls.asyncBidiStreamingCall;\\n\"\n      \"import static \"\n      \"io.grpc.stub.ClientCalls.asyncClientStreamingCall;\\n\"\n      \"import static \"\n      \"io.grpc.stub.ClientCalls.asyncServerStreamingCall;\\n\"\n      \"import static \"\n      \"io.grpc.stub.ClientCalls.asyncUnaryCall;\\n\"\n      \"import static \"\n      \"io.grpc.stub.ClientCalls.blockingServerStreamingCall;\\n\"\n      \"import static \"\n      \"io.grpc.stub.ClientCalls.blockingUnaryCall;\\n\"\n      \"import static \"\n      \"io.grpc.stub.ClientCalls.futureUnaryCall;\\n\"\n      \"import static \"\n      \"io.grpc.stub.ServerCalls.asyncBidiStreamingCall;\\n\"\n      \"import static \"\n      \"io.grpc.stub.ServerCalls.asyncClientStreamingCall;\\n\"\n      \"import static \"\n      \"io.grpc.stub.ServerCalls.asyncServerStreamingCall;\\n\"\n      \"import static \"\n      \"io.grpc.stub.ServerCalls.asyncUnaryCall;\\n\"\n      \"import static \"\n      \"io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;\\n\"\n      \"import static \"\n      \"io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;\\n\\n\");\n}\n\nstatic void GenerateService(const grpc_generator::Service* service,\n                            grpc_generator::Printer* printer, VARS& vars,\n                            bool disable_version) {\n  // All non-generated classes must be referred by fully qualified names to\n  // avoid collision with generated classes.\n  vars[\"String\"] = \"java.lang.String\";\n  vars[\"Deprecated\"] = \"java.lang.Deprecated\";\n  vars[\"Override\"] = \"java.lang.Override\";\n  vars[\"Channel\"] = \"io.grpc.Channel\";\n  vars[\"CallOptions\"] = \"io.grpc.CallOptions\";\n  vars[\"MethodType\"] = \"io.grpc.MethodDescriptor.MethodType\";\n  vars[\"ServerMethodDefinition\"] = \"io.grpc.ServerMethodDefinition\";\n  vars[\"BindableService\"] = \"io.grpc.BindableService\";\n  vars[\"ServerServiceDefinition\"] = \"io.grpc.ServerServiceDefinition\";\n  vars[\"ServiceDescriptor\"] = \"io.grpc.ServiceDescriptor\";\n  vars[\"ProtoFileDescriptorSupplier\"] =\n      \"io.grpc.protobuf.ProtoFileDescriptorSupplier\";\n  vars[\"ProtoServiceDescriptorSupplier\"] =\n      \"io.grpc.protobuf.ProtoServiceDescriptorSupplier\";\n  vars[\"ProtoMethodDescriptorSupplier\"] =\n      \"io.grpc.protobuf.ProtoMethodDescriptorSupplier\";\n  vars[\"AbstractStub\"] = \"io.grpc.stub.AbstractStub\";\n  vars[\"MethodDescriptor\"] = \"io.grpc.MethodDescriptor\";\n  vars[\"NanoUtils\"] = \"io.grpc.protobuf.nano.NanoUtils\";\n  vars[\"StreamObserver\"] = \"io.grpc.stub.StreamObserver\";\n  vars[\"Iterator\"] = \"java.util.Iterator\";\n  vars[\"Generated\"] = \"javax.annotation.Generated\";\n  vars[\"ListenableFuture\"] =\n      \"com.google.common.util.concurrent.ListenableFuture\";\n  vars[\"ExperimentalApi\"] = \"io.grpc.ExperimentalApi\";\n\n  PrintStaticImports(printer);\n\n  PrintService(printer, vars, service, disable_version);\n}\n}  // namespace\n\ngrpc::string GenerateServiceSource(\n    grpc_generator::File* file, const grpc_generator::Service* service,\n    grpc_java_generator::Parameters* parameters) {\n  grpc::string out;\n  auto printer = file->CreatePrinter(&out);\n  VARS vars;\n  vars[\"flatc_version\"] = grpc::string(\n      FLATBUFFERS_STRING(FLATBUFFERS_VERSION_MAJOR) \".\" FLATBUFFERS_STRING(\n          FLATBUFFERS_VERSION_MINOR) \".\" FLATBUFFERS_STRING(FLATBUFFERS_VERSION_REVISION));\n\n  vars[\"file_name\"] = file->filename();\n\n  if (!parameters->package_name.empty()) {\n    vars[\"Package\"] = parameters->package_name;  // ServiceJavaPackage(service);\n  }\n  GenerateImports(file, &*printer, vars);\n  GenerateService(service, &*printer, vars, false);\n  return out;\n}\n\n}  // namespace grpc_java_generator\n"
  },
  {
    "path": "grpc/src/compiler/java_generator.h",
    "content": "/*\n * Copyright 2016 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef NET_GRPC_COMPILER_JAVA_GENERATOR_H_\n#define NET_GRPC_COMPILER_JAVA_GENERATOR_H_\n\n#include   // for abort()\n\n#include \n#include \n#include \n\n#include \"src/compiler/schema_interface.h\"\n\nclass LogMessageVoidify {\n public:\n  LogMessageVoidify() {}\n  // This has to be an operator with a precedence lower than << but\n  // higher than ?:\n  void operator&(std::ostream&) {}\n};\n\nclass LogHelper {\n  std::ostream* os_;\n\n public:\n  LogHelper(std::ostream* os) : os_(os) {}\n#if defined(_MSC_VER)\n#pragma warning(push)\n#pragma warning(disable \\\n                : 4722)  // the flow of control terminates in a destructor\n  // (needed to compile ~LogHelper where destructor emits abort intentionally -\n  // inherited from grpc/java code generator).\n#endif\n  ~LogHelper() {\n    *os_ << std::endl;\n    ::abort();\n  }\n#if defined(_MSC_VER)\n#pragma warning(pop)\n#endif\n  std::ostream& get_os() const { return *os_; }\n};\n\n// Abort the program after logging the mesage if the given condition is not\n// true. Otherwise, do nothing.\n#define GRPC_CODEGEN_CHECK(x)                                            \\\n  (x) ? (void)0                                                          \\\n      : LogMessageVoidify() & LogHelper(&std::cerr).get_os()             \\\n                                  << \"CHECK FAILED: \" << __FILE__ << \":\" \\\n                                  << __LINE__ << \": \"\n\n// Abort the program after logging the mesage.\n#define GRPC_CODEGEN_FAIL GRPC_CODEGEN_CHECK(false)\n\nnamespace grpc_java_generator {\nstruct Parameters {\n  //        //Defines the custom parameter types for methods\n  //        //eg: flatbuffers uses flatbuffers.Builder as input for the client\n  //        and output for the server grpc::string custom_method_io_type;\n\n  // Package name for the service\n  grpc::string package_name;\n};\n\n// Return the source of the generated service file.\ngrpc::string GenerateServiceSource(grpc_generator::File* file,\n                                   const grpc_generator::Service* service,\n                                   grpc_java_generator::Parameters* parameters);\n\n}  // namespace grpc_java_generator\n\n#endif  // NET_GRPC_COMPILER_JAVA_GENERATOR_H_\n"
  },
  {
    "path": "grpc/src/compiler/python_generator.cc",
    "content": "/*\n *\n * Copyright 2015 gRPC authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n */\n\n#include \"src/compiler/python_generator.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"codegen/idl_namer.h\"\n#include \"codegen/namer.h\"\n#include \"codegen/python.h\"\n#include \"flatbuffers/idl.h\"\n#include \"flatbuffers/util.h\"\n\nnamespace flatbuffers {\nnamespace python {\nnamespace grpc {\nnamespace {\nbool ClientStreaming(const RPCCall* method) {\n  const Value* val = method->attributes.Lookup(\"streaming\");\n  return val != nullptr &&\n         (val->constant == \"client\" || val->constant == \"bidi\");\n}\n\nbool ServerStreaming(const RPCCall* method) {\n  const Value* val = method->attributes.Lookup(\"streaming\");\n  return val != nullptr &&\n         (val->constant == \"server\" || val->constant == \"bidi\");\n}\n\nvoid FormatImports(std::stringstream& ss, const Imports& imports) {\n  std::set modules;\n  std::map> names_by_module;\n  for (const Import& import : imports.imports) {\n    if (import.IsLocal()) continue;  // skip all local imports\n    if (import.name == \"\") {\n      modules.insert(import.module);\n    } else {\n      names_by_module[import.module].insert(import.name);\n    }\n  }\n\n  for (const std::string& module : modules) {\n    ss << \"import \" << module << '\\n';\n  }\n  ss << '\\n';\n  for (const auto& import : names_by_module) {\n    ss << \"from \" << import.first << \" import \";\n    size_t i = 0;\n    for (const std::string& name : import.second) {\n      if (i > 0) ss << \", \";\n      ss << name;\n      ++i;\n    }\n    ss << '\\n';\n  }\n  ss << \"\\n\\n\";\n}\n\nclass BaseGenerator {\n protected:\n  BaseGenerator(const Parser& parser, const Namer::Config& config,\n                const std::string& path, const Version& version)\n      : parser_{parser},\n        namer_{WithFlagOptions(config, parser.opts, path), Keywords(version)},\n        version_{version},\n        path_(path) {}\n\n protected:\n  std::string ModuleForFile(const std::string& file) const {\n    std::string module = parser_.opts.include_prefix + StripExtension(file) +\n                         parser_.opts.filename_suffix;\n    std::replace(module.begin(), module.end(), '/', '.');\n    return module;\n  }\n\n  template \n  std::string ModuleFor(const T* def) const {\n    if (parser_.opts.one_file) return ModuleForFile(def->file);\n    return namer_.NamespacedType(*def);\n  }\n\n  std::string NamespaceDir(const Parser& parser, const std::string& path,\n                           const Namespace& ns, const bool dasherize) {\n    EnsureDirExists(path);\n    if (parser.opts.one_file) return path;\n    std::string namespace_dir = path;  // Either empty or ends in separator.\n    auto& namespaces = ns.components;\n    for (auto it = namespaces.begin(); it != namespaces.end(); ++it) {\n      namespace_dir +=\n          !dasherize ? *it : ConvertCase(*it, Case::kDasher, Case::kUpperCamel);\n      namespace_dir += kPathSeparator;\n      EnsureDirExists(namespace_dir);\n    }\n    return namespace_dir;\n  }\n\n  std::string NamespaceDir(const Namespace& ns, const bool dasherize) {\n    return NamespaceDir(parser_, path_, ns, dasherize);\n  }\n\n  const Parser& parser_;\n  const IdlNamer namer_;\n  const Version version_;\n  const std::string& path_;\n};\n\nclass StubGenerator : public BaseGenerator {\n public:\n  StubGenerator(const Parser& parser, const std::string& path,\n                const Version& version)\n      : BaseGenerator(parser, kStubConfig, path, version) {}\n\n  bool Generate() {\n    Imports imports;\n    std::stringstream stub;\n    std::string ns_name{};\n    for (const ServiceDef* service : parser_.services_.vec) {\n      Generate(stub, service, &imports);\n      ns_name = NamespaceDir(*service->defined_namespace, false);\n    }\n\n    std::string sanitized_suffix{parser_.opts.grpc_filename_suffix};\n    std::replace(sanitized_suffix.begin(), sanitized_suffix.end(), '.', '_');\n    std::string filename =\n        ns_name + kPathSeparator +\n        StripPath(StripExtension(parser_.file_being_parsed_)) + \"_grpc\" +\n        sanitized_suffix + namer_.config_.filename_extension;\n\n    return SaveStub(filename, imports, stub.str());\n  }\n\n private:\n  bool SaveStub(const std::string& filename, const Imports& imports,\n                const std::string& content) {\n    std::stringstream ss;\n    ss << \"# Generated by the gRPC FlatBuffers compiler. DO NOT EDIT!\\n\"\n       << '\\n'\n       << \"from __future__ import annotations\\n\"\n       << '\\n';\n    FormatImports(ss, imports);\n    ss << content << '\\n';\n\n    EnsureDirExists(StripFileName(filename));\n    return parser_.opts.file_saver->SaveFile(filename.c_str(), ss.str(), false);\n  }\n\n  void Generate(std::stringstream& ss, const ServiceDef* service,\n                Imports* imports) {\n    imports->Import(\"grpc\");\n\n    ss << \"class \" << service->name << \"Stub(object):\\n\"\n       << \"  def __init__(self, channel: grpc.Channel) -> None: ...\\n\";\n\n    for (const RPCCall* method : service->calls.vec) {\n      std::string request = \"bytes\";\n      std::string response = \"bytes\";\n\n      if (parser_.opts.grpc_python_typed_handlers) {\n        request = namer_.Type(*method->request);\n        response = namer_.Type(*method->response);\n\n        imports->Import(ModuleFor(method->request), request);\n        imports->Import(ModuleFor(method->response), response);\n      }\n\n      ss << \"  def \" << method->name << \"(self, \";\n      if (ClientStreaming(method)) {\n        imports->Import(\"typing\");\n        ss << \"request_iterator: typing.Iterator[\" << request << \"]\";\n      } else {\n        ss << \"request: \" << request;\n      }\n      ss << \") -> \";\n      if (ServerStreaming(method)) {\n        imports->Import(\"typing\");\n        ss << \"typing.Iterator[\" << response << \"]\";\n      } else {\n        ss << response;\n      }\n      ss << \": ...\\n\";\n    }\n\n    ss << \"\\n\\n\";\n    ss << \"class \" << service->name << \"Servicer(object):\\n\";\n\n    for (const RPCCall* method : service->calls.vec) {\n      std::string request = \"bytes\";\n      std::string response = \"bytes\";\n\n      if (parser_.opts.grpc_python_typed_handlers) {\n        request = namer_.Type(*method->request);\n        response = namer_.Type(*method->response);\n\n        imports->Import(ModuleFor(method->request), request);\n        imports->Import(ModuleFor(method->response), response);\n      }\n\n      ss << \"  def \" << method->name << \"(self, \";\n      if (ClientStreaming(method)) {\n        imports->Import(\"typing\");\n        ss << \"request_iterator: typing.Iterator[\" << request << \"]\";\n      } else {\n        ss << \"request: \" << request;\n      }\n      ss << \", context: grpc.ServicerContext) -> \";\n      if (ServerStreaming(method)) {\n        imports->Import(\"typing\");\n        ss << \"typing.Iterator[\" << response << \"]\";\n      } else {\n        ss << response;\n      }\n      ss << \": ...\\n\";\n    }\n\n    ss << '\\n'\n       << '\\n'\n       << \"def add_\" << service->name\n       << \"Servicer_to_server(servicer: \" << service->name\n       << \"Servicer, server: grpc.Server) -> None: ...\\n\";\n  }\n};\n\nclass ServiceGenerator : public BaseGenerator {\n public:\n  ServiceGenerator(const Parser& parser, const std::string& path,\n                   const Version& version)\n      : BaseGenerator(parser, kConfig, path, version) {}\n\n  bool Generate() {\n    Imports imports;\n    std::stringstream ss;\n\n    imports.Import(\"flatbuffers\");\n\n    if (parser_.opts.grpc_python_typed_handlers) {\n      ss << \"def _serialize_to_bytes(table):\\n\"\n         << \"  buf = table._tab.Bytes\\n\"\n         << \"  n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, 0)\\n\"\n         << \"  if table._tab.Pos != n:\\n\"\n         << \"    raise ValueError('must be a top-level table')\\n\"\n         << \"  return bytes(buf)\\n\"\n         << '\\n'\n         << '\\n';\n    }\n\n    std::string ns_name{};\n    for (const ServiceDef* service : parser_.services_.vec) {\n      GenerateStub(ss, service, &imports);\n      GenerateServicer(ss, service, &imports);\n      GenerateRegister(ss, service, &imports);\n      ns_name = NamespaceDir(*service->defined_namespace, false);\n    }\n\n    std::string sanitized_suffix{parser_.opts.grpc_filename_suffix};\n    std::replace(sanitized_suffix.begin(), sanitized_suffix.end(), '.', '_');\n    std::string filename =\n        ns_name + kPathSeparator +\n        StripPath(StripExtension(parser_.file_being_parsed_)) + \"_grpc\" +\n        sanitized_suffix + namer_.config_.filename_extension;\n\n    return SaveService(filename, imports, ss.str());\n  }\n\n private:\n  bool SaveService(const std::string& filename, const Imports& imports,\n                   const std::string& content) {\n    std::stringstream ss;\n    ss << \"# Generated by the gRPC FlatBuffers compiler. DO NOT EDIT!\\n\"\n       << '\\n';\n    FormatImports(ss, imports);\n    ss << content << '\\n';\n\n    EnsureDirExists(StripFileName(filename));\n    return parser_.opts.file_saver->SaveFile(filename.c_str(), ss.str(), false);\n  }\n\n  void GenerateStub(std::stringstream& ss, const ServiceDef* service,\n                    Imports* imports) {\n    ss << \"class \" << service->name << \"Stub\";\n    if (version_.major != 3) ss << \"(object)\";\n    ss << \":\\n\"\n       << \"  '''Interface exported by the server.'''\\n\"\n       << '\\n'\n       << \"  def __init__(self, channel):\\n\"\n       << \"    '''Constructor.\\n\"\n       << '\\n'\n       << \"    Args:\\n\"\n       << \"      channel: A grpc.Channel.\\n\"\n       << \"    '''\\n\"\n       << '\\n';\n\n    for (const RPCCall* method : service->calls.vec) {\n      std::string response = namer_.Type(*method->response);\n\n      imports->Import(ModuleFor(method->response), response);\n\n      ss << \"    self.\" << method->name << \" = channel.\"\n         << (ClientStreaming(method) ? \"stream\" : \"unary\") << \"_\"\n         << (ServerStreaming(method) ? \"stream\" : \"unary\") << \"(\\n\"\n         << \"      method='/\"\n         << service->defined_namespace->GetFullyQualifiedName(service->name)\n         << \"/\" << method->name << \"'\";\n\n      if (parser_.opts.grpc_python_typed_handlers) {\n        ss << \",\\n\"\n           << \"      request_serializer=_serialize_to_bytes,\\n\"\n           << \"      response_deserializer=\" << response << \".GetRootAs\";\n      }\n      ss << \")\\n\\n\";\n    }\n\n    ss << '\\n';\n  }\n\n  void GenerateServicer(std::stringstream& ss, const ServiceDef* service,\n                        Imports* imports) {\n    imports->Import(\"grpc\");\n\n    ss << \"class \" << service->name << \"Servicer\";\n    if (version_.major != 3) ss << \"(object)\";\n    ss << \":\\n\"\n       << \"  '''Interface exported by the server.'''\\n\"\n       << '\\n';\n\n    for (const RPCCall* method : service->calls.vec) {\n      const std::string request_param =\n          ClientStreaming(method) ? \"request_iterator\" : \"request\";\n      ss << \"  def \" << method->name << \"(self, \" << request_param\n         << \", context):\\n\"\n         << \"    context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n\"\n         << \"    context.set_details('Method not implemented!')\\n\"\n         << \"    raise NotImplementedError('Method not implemented!')\\n\"\n         << '\\n';\n    }\n\n    ss << '\\n';\n  }\n\n  void GenerateRegister(std::stringstream& ss, const ServiceDef* service,\n                        Imports* imports) {\n    imports->Import(\"grpc\");\n\n    ss << \"def add_\" << service->name\n       << \"Servicer_to_server(servicer, server):\\n\"\n       << \"  rpc_method_handlers = {\\n\";\n\n    for (const RPCCall* method : service->calls.vec) {\n      std::string request = namer_.Type(*method->request);\n\n      imports->Import(ModuleFor(method->request), request);\n\n      ss << \"    '\" << method->name << \"': grpc.\"\n         << (ClientStreaming(method) ? \"stream\" : \"unary\") << \"_\"\n         << (ServerStreaming(method) ? \"stream\" : \"unary\")\n         << \"_rpc_method_handler(\\n\"\n         << \"      servicer.\" << method->name;\n\n      if (parser_.opts.grpc_python_typed_handlers) {\n        ss << \",\\n\"\n           << \"      request_deserializer=\" << request << \".GetRootAs,\\n\"\n           << \"      response_serializer=_serialize_to_bytes\";\n      }\n      ss << \"),\\n\";\n    }\n    ss << \"  }\\n\"\n       << '\\n'\n       << \"  generic_handler = grpc.method_handlers_generic_handler(\\n\"\n       << \"    '\"\n       << service->defined_namespace->GetFullyQualifiedName(service->name)\n       << \"', rpc_method_handlers)\\n\"\n       << '\\n'\n       << \"  server.add_generic_rpc_handlers((generic_handler,))\\n\"\n       << '\\n';\n  }\n};\n}  // namespace\n\nbool Generate(const Parser& parser, const std::string& path,\n              const Version& version) {\n  ServiceGenerator generator{parser, path, version};\n  return generator.Generate();\n}\n\nbool GenerateStub(const Parser& parser, const std::string& path,\n                  const Version& version) {\n  StubGenerator generator{parser, path, version};\n  return generator.Generate();\n}\n\n}  // namespace grpc\n}  // namespace python\n}  // namespace flatbuffers\n"
  },
  {
    "path": "grpc/src/compiler/python_generator.h",
    "content": "/*\n *\n * Copyright 2015 gRPC authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n */\n\n#ifndef GRPC_INTERNAL_COMPILER_PYTHON_GENERATOR_H\n#define GRPC_INTERNAL_COMPILER_PYTHON_GENERATOR_H\n\n#include \n\n#include \"codegen/python.h\"\n#include \"flatbuffers/idl.h\"\n\nnamespace flatbuffers {\nnamespace python {\nnamespace grpc {\nbool Generate(const Parser& parser, const std::string& path,\n              const Version& version);\n\nbool GenerateStub(const Parser& parser, const std::string& path,\n                  const Version& version);\n}  // namespace grpc\n}  // namespace python\n}  // namespace flatbuffers\n\n#endif  // GRPC_INTERNAL_COMPILER_PYTHON_GENERATOR_H\n"
  },
  {
    "path": "grpc/src/compiler/schema_interface.h",
    "content": "/*\n *\n * Copyright 2015 gRPC authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n */\n\n#ifndef GRPC_INTERNAL_COMPILER_SCHEMA_INTERFACE_H\n#define GRPC_INTERNAL_COMPILER_SCHEMA_INTERFACE_H\n\n#include \n#include \n#include \n\n#ifndef GRPC_CUSTOM_STRING\n#include \n#define GRPC_CUSTOM_STRING std::string\n#endif\n\nnamespace grpc {\n\ntypedef GRPC_CUSTOM_STRING string;\n\n}  // namespace grpc\n\nnamespace grpc_generator {\n\n// A common interface for objects having comments in the source.\n// Return formatted comments to be inserted in generated code.\nstruct CommentHolder {\n  virtual ~CommentHolder() {}\n  virtual grpc::string GetLeadingComments(const grpc::string prefix) const = 0;\n  virtual grpc::string GetTrailingComments(const grpc::string prefix) const = 0;\n  virtual std::vector GetAllComments() const = 0;\n};\n\n// An abstract interface representing a method.\nstruct Method : public CommentHolder {\n  virtual ~Method() {}\n\n  virtual grpc::string name() const = 0;\n\n  virtual grpc::string input_type_name() const = 0;\n  virtual grpc::string output_type_name() const = 0;\n\n  virtual bool get_module_and_message_path_input(\n      grpc::string* str, grpc::string generator_file_name,\n      bool generate_in_pb2_grpc, grpc::string import_prefix) const = 0;\n  virtual bool get_module_and_message_path_output(\n      grpc::string* str, grpc::string generator_file_name,\n      bool generate_in_pb2_grpc, grpc::string import_prefix) const = 0;\n\n  virtual std::vector get_input_namespace_parts() const = 0;\n  virtual grpc::string get_input_type_name() const = 0;\n  virtual std::vector get_output_namespace_parts() const = 0;\n  virtual grpc::string get_output_type_name() const = 0;\n\n  virtual grpc::string get_fb_builder() const = 0;\n\n  virtual bool NoStreaming() const = 0;\n  virtual bool ClientStreaming() const = 0;\n  virtual bool ServerStreaming() const = 0;\n  virtual bool BidiStreaming() const = 0;\n};\n\n// An abstract interface representing a service.\nstruct Service : public CommentHolder {\n  virtual ~Service() {}\n\n  virtual std::vector namespace_parts() const = 0;\n  virtual grpc::string name() const = 0;\n  virtual bool is_internal() const = 0;\n\n  virtual int method_count() const = 0;\n  virtual std::unique_ptr method(int i) const = 0;\n};\n\nstruct Printer {\n  virtual ~Printer() {}\n\n  virtual void Print(const std::map& vars,\n                     const char* template_string) = 0;\n  virtual void Print(const char* string) = 0;\n  virtual void SetIndentationSize(const size_t size) = 0;\n  virtual void Indent() = 0;\n  virtual void Outdent() = 0;\n};\n\n// An interface that allows the source generated to be output using various\n// libraries/idls/serializers.\nstruct File : public CommentHolder {\n  virtual ~File() {}\n\n  virtual grpc::string filename() const = 0;\n  virtual grpc::string filename_without_ext() const = 0;\n  virtual grpc::string package() const = 0;\n  virtual std::vector package_parts() const = 0;\n  virtual grpc::string additional_headers() const = 0;\n\n  virtual int service_count() const = 0;\n  virtual std::unique_ptr service(int i) const = 0;\n\n  virtual std::unique_ptr CreatePrinter(\n      grpc::string* str, const char indentation_type = ' ') const = 0;\n};\n}  // namespace grpc_generator\n\n#endif  // GRPC_INTERNAL_COMPILER_SCHEMA_INTERFACE_H\n"
  },
  {
    "path": "grpc/src/compiler/swift_generator.cc",
    "content": "/*\n * Copyright 2020 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*\n * NOTE: The following implementation is a translation for the Swift-grpc\n * generator since flatbuffers doesnt allow plugins for now. if an issue arises\n * please open an issue in the flatbuffers repository. This file should always\n * be maintained according to the Swift-grpc repository\n */\n#include \"src/compiler/swift_generator.h\"\n\n#include \n#include \n\n#include \"flatbuffers/util.h\"\n#include \"src/compiler/schema_interface.h\"\n\nnamespace grpc_swift_generator {\nnamespace {\n\nstatic std::string WrapInNameSpace(const std::vector& components,\n                                   const grpc::string& name) {\n  std::string qualified_name;\n  for (auto it = components.begin(); it != components.end(); ++it)\n    qualified_name += *it + \"_\";\n  return qualified_name + name;\n}\n\nstatic grpc::string GenerateMessage(const std::vector& components,\n                                    const grpc::string& name) {\n  return \"Message<\" + WrapInNameSpace(components, name) + \">\";\n}\n\n// MARK: - Client\n\nstatic void GenerateClientFuncName(\n    const grpc_generator::Method* method, grpc_generator::Printer* printer,\n    std::map* dictonary) {\n  auto vars = *dictonary;\n  if (method->NoStreaming()) {\n    printer->Print(vars,\n                   \"  $GenAccess$func $MethodName$(\\n\"\n                   \"    _ request: $Input$\\n\"\n                   \"    , callOptions: CallOptions?$isNil$\\n\"\n                   \"  ) -> UnaryCall<$Input$, $Output$>\");\n    return;\n  }\n\n  if (method->ServerStreaming()) {\n    printer->Print(vars,\n                   \"  $GenAccess$func $MethodName$(\\n\"\n                   \"    _ request: $Input$\\n\"\n                   \"    , callOptions: CallOptions?$isNil$,\\n\"\n                   \"    handler: @escaping ($Output$) -> Void\\n\"\n                   \"  ) -> ServerStreamingCall<$Input$, $Output$>\");\n    return;\n  }\n\n  if (method->ClientStreaming()) {\n    printer->Print(vars,\n                   \"  $GenAccess$func $MethodName$(\\n\"\n                   \"    callOptions: CallOptions?$isNil$\\n\"\n                   \"  ) -> ClientStreamingCall<$Input$, $Output$>\");\n    return;\n  }\n\n  printer->Print(vars,\n                 \"  $GenAccess$func $MethodName$(\\n\"\n                 \"    callOptions: CallOptions?$isNil$,\\n\"\n                 \"    handler: @escaping ($Output$ ) -> Void\\n\"\n                 \"  ) -> BidirectionalStreamingCall<$Input$, $Output$>\");\n}\n\nstatic void GenerateClientFuncBody(\n    const grpc_generator::Method* method, grpc_generator::Printer* printer,\n    std::map* dictonary) {\n  auto vars = *dictonary;\n  vars[\"Interceptor\"] =\n      \"interceptors: self.interceptors?.make$MethodName$Interceptors() ?? []\";\n  if (method->NoStreaming()) {\n    printer->Print(\n        vars,\n        \"    return self.makeUnaryCall(\\n\"\n        \"      path: \\\"/$PATH$$ServiceName$/$MethodName$\\\",\\n\"\n        \"      request: request,\\n\"\n        \"      callOptions: callOptions ?? self.defaultCallOptions,\\n\"\n        \"      $Interceptor$\\n\"\n        \"    )\\n\");\n    return;\n  }\n\n  if (method->ServerStreaming()) {\n    printer->Print(\n        vars,\n        \"    return self.makeServerStreamingCall(\\n\"\n        \"      path: \\\"/$PATH$$ServiceName$/$MethodName$\\\",\\n\"\n        \"      request: request,\\n\"\n        \"      callOptions: callOptions ?? self.defaultCallOptions,\\n\"\n        \"      $Interceptor$,\\n\"\n        \"      handler: handler\\n\"\n        \"    )\\n\");\n    return;\n  }\n\n  if (method->ClientStreaming()) {\n    printer->Print(\n        vars,\n        \"    return self.makeClientStreamingCall(\\n\"\n        \"      path: \\\"/$PATH$$ServiceName$/$MethodName$\\\",\\n\"\n        \"      callOptions: callOptions ?? self.defaultCallOptions,\\n\"\n        \"      $Interceptor$\\n\"\n        \"    )\\n\");\n    return;\n  }\n  printer->Print(vars,\n                 \"    return self.makeBidirectionalStreamingCall(\\n\"\n                 \"      path: \\\"/$PATH$$ServiceName$/$MethodName$\\\",\\n\"\n                 \"      callOptions: callOptions ?? self.defaultCallOptions,\\n\"\n                 \"      $Interceptor$,\\n\"\n                 \"      handler: handler\\n\"\n                 \"    )\\n\");\n}\n\nvoid GenerateClientProtocol(const grpc_generator::Service* service,\n                            grpc_generator::Printer* printer,\n                            std::map* dictonary) {\n  auto vars = *dictonary;\n  printer->Print(\n      vars,\n      \"$ACCESS$ protocol $ServiceQualifiedName$ClientProtocol: GRPCClient {\");\n  printer->Print(\"\\n\\n\");\n  printer->Print(\"  var serviceName: String { get }\");\n  printer->Print(\"\\n\\n\");\n  printer->Print(\n      vars,\n      \"  var interceptors: \"\n      \"$ServiceQualifiedName$ClientInterceptorFactoryProtocol? { get }\");\n  printer->Print(\"\\n\\n\");\n\n  vars[\"GenAccess\"] = \"\";\n  for (auto it = 0; it < service->method_count(); it++) {\n    auto method = service->method(it);\n    vars[\"Input\"] = GenerateMessage(method->get_input_namespace_parts(),\n                                    method->get_input_type_name());\n    vars[\"Output\"] = GenerateMessage(method->get_output_namespace_parts(),\n                                     method->get_output_type_name());\n    vars[\"MethodName\"] = method->name();\n    vars[\"isNil\"] = \"\";\n    GenerateClientFuncName(method.get(), &*printer, &vars);\n    printer->Print(\"\\n\\n\");\n  }\n  printer->Print(\"}\\n\\n\");\n\n  printer->Print(vars, \"extension $ServiceQualifiedName$ClientProtocol {\");\n  printer->Print(\"\\n\\n\");\n  printer->Print(vars,\n                 \"  $ACCESS$ var serviceName: String { \"\n                 \"\\\"$PATH$$ServiceName$\\\" }\\n\");\n\n  vars[\"GenAccess\"] = service->is_internal() ? \"internal \" : \"public \";\n  for (auto it = 0; it < service->method_count(); it++) {\n    auto method = service->method(it);\n    vars[\"Input\"] = GenerateMessage(method->get_input_namespace_parts(),\n                                    method->get_input_type_name());\n    vars[\"Output\"] = GenerateMessage(method->get_output_namespace_parts(),\n                                     method->get_output_type_name());\n    vars[\"MethodName\"] = method->name();\n    vars[\"isNil\"] = \" = nil\";\n    printer->Print(\"\\n\");\n    GenerateClientFuncName(method.get(), &*printer, &vars);\n    printer->Print(\" {\\n\");\n    GenerateClientFuncBody(method.get(), &*printer, &vars);\n    printer->Print(\"  }\\n\");\n  }\n  printer->Print(\"}\\n\\n\");\n\n  printer->Print(vars,\n                 \"$ACCESS$ protocol \"\n                 \"$ServiceQualifiedName$ClientInterceptorFactoryProtocol {\\n\");\n\n  for (auto it = 0; it < service->method_count(); it++) {\n    auto method = service->method(it);\n    vars[\"Input\"] = GenerateMessage(method->get_input_namespace_parts(),\n                                    method->get_input_type_name());\n    vars[\"Output\"] = GenerateMessage(method->get_output_namespace_parts(),\n                                     method->get_output_type_name());\n    vars[\"MethodName\"] = method->name();\n    printer->Print(\n        vars,\n        \"  /// - Returns: Interceptors to use when invoking '$MethodName$'.\\n\");\n    printer->Print(vars,\n                   \"  func make$MethodName$Interceptors() -> \"\n                   \"[ClientInterceptor<$Input$, $Output$>]\\n\\n\");\n  }\n  printer->Print(\"}\\n\\n\");\n}\n\nvoid GenerateClientClass(grpc_generator::Printer* printer,\n                         std::map* dictonary) {\n  auto vars = *dictonary;\n  printer->Print(vars,\n                 \"$ACCESS$ final class $ServiceQualifiedName$ServiceClient: \"\n                 \"$ServiceQualifiedName$ClientProtocol {\\n\");\n  printer->Print(vars, \"  $ACCESS$ let channel: GRPCChannel\\n\");\n  printer->Print(vars, \"  $ACCESS$ var defaultCallOptions: CallOptions\\n\");\n  printer->Print(vars,\n                 \"  $ACCESS$ var interceptors: \"\n                 \"$ServiceQualifiedName$ClientInterceptorFactoryProtocol?\\n\");\n  printer->Print(\"\\n\");\n  printer->Print(\n      vars,\n      \"  $ACCESS$ init(\\n\"\n      \"    channel: GRPCChannel,\\n\"\n      \"    defaultCallOptions: CallOptions = CallOptions(),\\n\"\n      \"    interceptors: \"\n      \"$ServiceQualifiedName$ClientInterceptorFactoryProtocol? = nil\\n\"\n      \"  ) {\\n\");\n  printer->Print(\"    self.channel = channel\\n\");\n  printer->Print(\"    self.defaultCallOptions = defaultCallOptions\\n\");\n  printer->Print(\"    self.interceptors = interceptors\\n\");\n  printer->Print(\"  }\");\n  printer->Print(\"\\n\");\n  printer->Print(\"}\\n\");\n}\n\n// MARK: - Server\n\ngrpc::string GenerateServerFuncName(const grpc_generator::Method* method) {\n  if (method->NoStreaming()) {\n    return \"func $MethodName$(request: $Input$\"\n           \", context: StatusOnlyCallContext) -> EventLoopFuture<$Output$>\";\n  }\n\n  if (method->ClientStreaming()) {\n    return \"func $MethodName$(context: UnaryResponseCallContext<$Output$>) -> \"\n           \"EventLoopFuture<(StreamEvent<$Input$\"\n           \">) -> Void>\";\n  }\n\n  if (method->ServerStreaming()) {\n    return \"func $MethodName$(request: $Input$\"\n           \", context: StreamingResponseCallContext<$Output$>) -> \"\n           \"EventLoopFuture\";\n  }\n  return \"func $MethodName$(context: StreamingResponseCallContext<$Output$>) \"\n         \"-> EventLoopFuture<(StreamEvent<$Input$>) -> Void>\";\n}\n\ngrpc::string GenerateServerExtensionBody(const grpc_generator::Method* method) {\n  grpc::string start = \"    case \\\"$MethodName$\\\":\\n    \";\n  grpc::string interceptors =\n      \"      interceptors: self.interceptors?.make$MethodName$Interceptors() \"\n      \"?? [],\\n\";\n  if (method->NoStreaming()) {\n    return start +\n           \"return UnaryServerHandler(\\n\"\n           \"      context: context,\\n\"\n           \"      requestDeserializer: GRPCPayloadDeserializer<$Input$>(),\\n\"\n           \"      responseSerializer: GRPCPayloadSerializer<$Output$>(),\\n\" +\n           interceptors +\n           \"      userFunction: self.$MethodName$(request:context:))\\n\";\n  }\n  if (method->ServerStreaming()) {\n    return start +\n           \"return ServerStreamingServerHandler(\\n\"\n           \"      context: context,\\n\"\n           \"      requestDeserializer: GRPCPayloadDeserializer<$Input$>(),\\n\"\n           \"      responseSerializer: GRPCPayloadSerializer<$Output$>(),\\n\" +\n           interceptors +\n           \"      userFunction: self.$MethodName$(request:context:))\\n\";\n  }\n  if (method->ClientStreaming()) {\n    return start +\n           \"return ClientStreamingServerHandler(\\n\"\n           \"      context: context,\\n\"\n           \"      requestDeserializer: GRPCPayloadDeserializer<$Input$>(),\\n\"\n           \"      responseSerializer: GRPCPayloadSerializer<$Output$>(),\\n\" +\n           interceptors +\n           \"      observerFactory: self.$MethodName$(context:))\\n\";\n  }\n  if (method->BidiStreaming()) {\n    return start +\n           \"return BidirectionalStreamingServerHandler(\\n\"\n           \"      context: context,\\n\"\n           \"      requestDeserializer: GRPCPayloadDeserializer<$Input$>(),\\n\"\n           \"      responseSerializer: GRPCPayloadSerializer<$Output$>(),\\n\" +\n           interceptors +\n           \"      observerFactory: self.$MethodName$(context:))\\n\";\n  }\n  return \"\";\n}\n\nvoid GenerateServerProtocol(const grpc_generator::Service* service,\n                            grpc_generator::Printer* printer,\n                            std::map* dictonary) {\n  auto vars = *dictonary;\n  printer->Print(vars,\n                 \"$ACCESS$ protocol $ServiceQualifiedName$Provider: \"\n                 \"CallHandlerProvider {\\n\");\n  printer->Print(\n      vars,\n      \"  var interceptors: \"\n      \"$ServiceQualifiedName$ServerInterceptorFactoryProtocol? { get }\\n\");\n  for (auto it = 0; it < service->method_count(); it++) {\n    auto method = service->method(it);\n    vars[\"Input\"] = GenerateMessage(method->get_input_namespace_parts(),\n                                    method->get_input_type_name());\n    vars[\"Output\"] = GenerateMessage(method->get_output_namespace_parts(),\n                                     method->get_output_type_name());\n    vars[\"MethodName\"] = method->name();\n    printer->Print(\"  \");\n    auto func = GenerateServerFuncName(method.get());\n    printer->Print(vars, func.c_str());\n    printer->Print(\"\\n\");\n  }\n  printer->Print(\"}\\n\\n\");\n\n  printer->Print(vars, \"$ACCESS$ extension $ServiceQualifiedName$Provider {\\n\");\n  printer->Print(\"\\n\");\n  printer->Print(vars,\n                 \"  var serviceName: Substring { return \"\n                 \"\\\"$PATH$$ServiceName$\\\" }\\n\");\n  printer->Print(\"\\n\");\n  printer->Print(\n      \"  func handle(method name: Substring, context: \"\n      \"CallHandlerContext) -> GRPCServerHandlerProtocol? {\\n\");\n  printer->Print(\"    switch name {\\n\");\n  for (auto it = 0; it < service->method_count(); it++) {\n    auto method = service->method(it);\n    vars[\"Input\"] = GenerateMessage(method->get_input_namespace_parts(),\n                                    method->get_input_type_name());\n    vars[\"Output\"] = GenerateMessage(method->get_output_namespace_parts(),\n                                     method->get_output_type_name());\n    vars[\"MethodName\"] = method->name();\n    auto body = GenerateServerExtensionBody(method.get());\n    printer->Print(vars, body.c_str());\n    printer->Print(\"\\n\");\n  }\n  printer->Print(\"    default: return nil;\\n\");\n  printer->Print(\"    }\\n\");\n  printer->Print(\"  }\\n\\n\");\n  printer->Print(\"}\\n\\n\");\n\n  printer->Print(vars,\n                 \"$ACCESS$ protocol \"\n                 \"$ServiceQualifiedName$ServerInterceptorFactoryProtocol {\\n\");\n  for (auto it = 0; it < service->method_count(); it++) {\n    auto method = service->method(it);\n    vars[\"Input\"] = GenerateMessage(method->get_input_namespace_parts(),\n                                    method->get_input_type_name());\n    vars[\"Output\"] = GenerateMessage(method->get_output_namespace_parts(),\n                                     method->get_output_type_name());\n    vars[\"MethodName\"] = method->name();\n    printer->Print(\n        vars,\n        \"  /// - Returns: Interceptors to use when handling '$MethodName$'.\\n\"\n        \"  ///   Defaults to calling `self.makeInterceptors()`.\\n\");\n    printer->Print(vars,\n                   \"  func make$MethodName$Interceptors() -> \"\n                   \"[ServerInterceptor<$Input$, $Output$>]\\n\\n\");\n  }\n  printer->Print(\"}\");\n}\n}  // namespace\n\ngrpc::string Generate(grpc_generator::File* file,\n                      const grpc_generator::Service* service) {\n  grpc::string output;\n  std::map vars;\n  vars[\"PATH\"] = file->package();\n  if (!file->package().empty()) {\n    vars[\"PATH\"].append(\".\");\n  }\n  vars[\"ServiceQualifiedName\"] =\n      WrapInNameSpace(service->namespace_parts(), service->name());\n  vars[\"ServiceName\"] = service->name();\n  vars[\"ACCESS\"] = service->is_internal() ? \"internal\" : \"public\";\n  auto printer = file->CreatePrinter(&output);\n  printer->Print(\n      vars,\n      \"/// Usage: instantiate $ServiceQualifiedName$ServiceClient, then call \"\n      \"methods of this protocol to make API calls.\\n\");\n  GenerateClientProtocol(service, &*printer, &vars);\n  GenerateClientClass(&*printer, &vars);\n  printer->Print(\"\\n\");\n  GenerateServerProtocol(service, &*printer, &vars);\n  printer->Print(\"\\n\");\n  printer->Print(\"#endif\\n\");\n  return output;\n}\n\ngrpc::string GenerateHeader() {\n  grpc::string code;\n  code +=\n      \"/// The following code is generated by the Flatbuffers library which \"\n      \"might not be in sync with grpc-swift\\n\";\n  code +=\n      \"/// in case of an issue please open github issue, though it would be \"\n      \"maintained\\n\";\n  code += \"\\n\";\n  code += \"// swiftlint:disable all\\n\";\n  code += \"// swiftformat:disable all\\n\";\n  code += \"\\n\";\n  code += \"#if !os(Windows)\\n\";\n  code += \"import Foundation\\n\";\n  code += \"import GRPC\\n\";\n  code += \"import NIO\\n\";\n  code += \"import NIOHTTP1\\n\";\n  code += \"import FlatBuffers\\n\";\n  code += \"\\n\";\n  code +=\n      \"public protocol GRPCFlatBufPayload: GRPCPayload, FlatBufferGRPCMessage \"\n      \"{}\\n\";\n\n  code += \"public extension GRPCFlatBufPayload {\\n\";\n  code += \"  init(serializedByteBuffer: inout NIO.ByteBuffer) throws {\\n\";\n  code +=\n      \"    self.init(byteBuffer: FlatBuffers.ByteBuffer(contiguousBytes: \"\n      \"serializedByteBuffer.readableBytesView, count: \"\n      \"serializedByteBuffer.readableBytes))\\n\";\n  code += \"  }\\n\";\n\n  code += \"  func serialize(into buffer: inout NIO.ByteBuffer) throws {\\n\";\n  code += \"    withUnsafeReadableBytes { buffer.writeBytes($0) }\\n\";\n  code += \"  }\\n\";\n  code += \"}\\n\";\n  code += \"extension Message: GRPCFlatBufPayload {}\\n\";\n  return code;\n}\n}  // namespace grpc_swift_generator\n"
  },
  {
    "path": "grpc/src/compiler/swift_generator.h",
    "content": "/*\n * Copyright 2020 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n\n#include \"src/compiler/schema_interface.h\"\n\n#ifndef GRPC_CUSTOM_STRING\n#include \n#define GRPC_CUSTOM_STRING std::string\n#endif\n\nnamespace grpc {\n\ntypedef GRPC_CUSTOM_STRING string;\n\n}  // namespace grpc\n\nnamespace grpc_swift_generator {\ngrpc::string Generate(grpc_generator::File* file,\n                      const grpc_generator::Service* service);\ngrpc::string GenerateHeader();\n}  // namespace grpc_swift_generator\n"
  },
  {
    "path": "grpc/src/compiler/ts_generator.cc",
    "content": "/*\n * Copyright 2020 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*\n * NOTE: The following implementation is a translation for the Swift-grpc\n * generator since flatbuffers doesnt allow plugins for now. if an issue arises\n * please open an issue in the flatbuffers repository. This file should always\n * be maintained according to the Swift-grpc repository\n */\n\n#include \"src/compiler/ts_generator.h\"\n\n#include \n#include \n\n#include \"flatbuffers/util.h\"\n#include \"src/compiler/schema_interface.h\"\n\nnamespace grpc_ts_generator {\nnamespace {\n\nstatic grpc::string GenerateNamespace(const std::vector ns,\n                                      const std::string filename,\n                                      const bool include_separator) {\n  grpc::string path = \"\";\n  if (include_separator) path += \".\";\n\n  for (auto it = ns.begin(); it < ns.end(); it++) {\n    if (include_separator) path += \"/\";\n    path += include_separator\n                ? flatbuffers::ConvertCase(*it, flatbuffers::Case::kDasher,\n                                           flatbuffers::Case::kUpperCamel)\n                : *it + \"_\";\n  }\n\n  if (include_separator) path += \"/\";\n  path += include_separator\n              ? flatbuffers::ConvertCase(filename, flatbuffers::Case::kDasher,\n                                         flatbuffers::Case::kUpperCamel)\n              : filename;\n  return path;\n}\n\n// MARK: - Shared code\n\nstatic void GenerateImports(const grpc_generator::Service* service,\n                            grpc_generator::Printer* printer,\n                            std::map* dictonary,\n                            const bool grpc_var_import) {\n  auto vars = *dictonary;\n  printer->Print(\n      \"// Generated GRPC code for FlatBuffers TS *** DO NOT EDIT ***\\n\");\n  printer->Print(\"import * as flatbuffers from 'flatbuffers';\\n\");\n\n  std::set generated_imports;\n\n  for (auto it = 0; it < service->method_count(); it++) {\n    auto method = service->method(it);\n    auto output = method->get_output_type_name();\n    auto input = method->get_input_type_name();\n    auto input_namespace = method->get_input_namespace_parts();\n\n    vars[\"OUTPUT\"] = output;\n    vars[\"INPUT\"] = input;\n\n    if (generated_imports.find(output) == generated_imports.end()) {\n      generated_imports.insert(output);\n      vars[\"OUTPUT_DIR\"] =\n          GenerateNamespace(method->get_output_namespace_parts(), output, true);\n      vars[\"Output_alias\"] = GenerateNamespace(\n          method->get_output_namespace_parts(), output, false);\n      printer->Print(\n          vars, \"import { $OUTPUT$ as $Output_alias$ } from '$OUTPUT_DIR$';\\n\");\n    }\n    if (generated_imports.find(input) == generated_imports.end()) {\n      generated_imports.insert(input);\n      vars[\"INPUT_DIR\"] =\n          GenerateNamespace(method->get_output_namespace_parts(), input, true);\n      vars[\"Input_alias\"] =\n          GenerateNamespace(method->get_output_namespace_parts(), input, false);\n      printer->Print(\n          vars, \"import { $INPUT$ as $Input_alias$ } from '$INPUT_DIR$';\\n\");\n    }\n  }\n  printer->Print(\"\\n\");\n  if (grpc_var_import)\n    printer->Print(\"var grpc = require('@grpc/grpc-js');\\n\");\n  else\n    printer->Print(\"import * as grpc from '@grpc/grpc-js';\\n\");\n  printer->Print(\"\\n\");\n}\n\n// MARK: - Generate Main GRPC Code\n\nstatic void GetStreamType(grpc_generator::Printer* printer,\n                          const grpc_generator::Method* method,\n                          std::map* dictonary) {\n  auto vars = *dictonary;\n  auto client_streaming = method->ClientStreaming() || method->BidiStreaming();\n  auto server_streaming = method->ServerStreaming() || method->BidiStreaming();\n  vars[\"ClientStreaming\"] = client_streaming ? \"true\" : \"false\";\n  vars[\"ServerStreaming\"] = server_streaming ? \"true\" : \"false\";\n  printer->Print(vars, \"requestStream: $ClientStreaming$,\\n\");\n  printer->Print(vars, \"responseStream: $ServerStreaming$,\\n\");\n}\n\nstatic void GenerateSerializeMethod(\n    grpc_generator::Printer* printer,\n    std::map* dictonary) {\n  auto vars = *dictonary;\n  printer->Print(vars, \"function serialize_$Type$(buffer_args) {\\n\");\n  printer->Indent();\n  printer->Print(vars, \"if (!(buffer_args instanceof $Type$)) {\\n\");\n  printer->Indent();\n  printer->Print(vars,\n                 \"throw new Error('Expected argument of type $VALUE$');\\n\");\n  printer->Outdent();\n  printer->Print(\"}\\n\");\n  printer->Print(vars, \"return Buffer.from(buffer_args.serialize());\\n\");\n  printer->Outdent();\n  printer->Print(\"}\\n\\n\");\n}\n\nstatic void GenerateDeserializeMethod(\n    grpc_generator::Printer* printer,\n    std::map* dictonary) {\n  auto vars = *dictonary;\n  printer->Print(vars, \"function deserialize_$Type$(buffer) {\\n\");\n  printer->Indent();\n  printer->Print(vars,\n                 \"return $Type$.getRootAs$VALUE$(new \"\n                 \"flatbuffers.ByteBuffer(buffer))\\n\");\n  printer->Outdent();\n  printer->Print(\"}\\n\\n\");\n}\n\nstatic void GenerateMethods(const grpc_generator::Service* service,\n                            grpc_generator::Printer* printer,\n                            std::map* dictonary) {\n  auto vars = *dictonary;\n\n  std::set generated_functions;\n\n  for (auto it = 0; it < service->method_count(); it++) {\n    auto method = service->method(it);\n    auto output = method->get_output_type_name();\n    auto input = method->get_input_type_name();\n\n    if (generated_functions.find(output) == generated_functions.end()) {\n      generated_functions.insert(output);\n      vars[\"VALUE\"] = output;\n      vars[\"Type\"] = GenerateNamespace(method->get_output_namespace_parts(),\n                                       output, false);\n      GenerateSerializeMethod(printer, &vars);\n      GenerateDeserializeMethod(printer, &vars);\n    }\n    printer->Print(\"\\n\");\n    if (generated_functions.find(input) == generated_functions.end()) {\n      generated_functions.insert(input);\n      vars[\"VALUE\"] = input;\n      vars[\"Type\"] =\n          GenerateNamespace(method->get_input_namespace_parts(), input, false);\n      GenerateSerializeMethod(printer, &vars);\n      GenerateDeserializeMethod(printer, &vars);\n    }\n  }\n}\n\nstatic void GenerateService(const grpc_generator::Service* service,\n                            grpc_generator::Printer* printer,\n                            std::map* dictonary) {\n  auto vars = *dictonary;\n  vars[\"NAME\"] = service->name() + \"Service\";\n\n  printer->Print(vars, \"var $NAME$ = exports.$NAME$ = {\\n\");\n  printer->Indent();\n  for (auto it = 0; it < service->method_count(); it++) {\n    auto method = service->method(it);\n    vars[\"MethodName\"] = method->name();\n    vars[\"OUTPUT\"] = GenerateNamespace(method->get_output_namespace_parts(),\n                                       method->get_output_type_name(), false);\n    vars[\"INPUT\"] = GenerateNamespace(method->get_input_namespace_parts(),\n                                      method->get_input_type_name(), false);\n    printer->Print(vars, \"$MethodName$: {\\n\");\n    printer->Indent();\n    printer->Print(vars, \"path: '/$PATH$$ServiceName$/$MethodName$',\\n\");\n    GetStreamType(printer, &*method, &vars);\n    printer->Print(vars, \"requestType: flatbuffers.ByteBuffer,\\n\");\n    printer->Print(vars, \"responseType: $OUTPUT$,\\n\");\n    printer->Print(vars, \"requestSerialize: serialize_$INPUT$,\\n\");\n    printer->Print(vars, \"requestDeserialize: deserialize_$INPUT$,\\n\");\n    printer->Print(vars, \"responseSerialize: serialize_$OUTPUT$,\\n\");\n    printer->Print(vars, \"responseDeserialize: deserialize_$OUTPUT$,\\n\");\n    printer->Outdent();\n    printer->Print(\"},\\n\");\n  }\n  printer->Outdent();\n  printer->Print(\"};\\n\");\n  printer->Print(vars,\n                 \"exports.$ServiceName$Client = \"\n                 \"grpc.makeGenericClientConstructor($NAME$);\");\n}\n\n}  // namespace\n\ngrpc::string Generate(grpc_generator::File* file,\n                      const grpc_generator::Service* service,\n                      const grpc::string& filename) {\n  grpc::string output;\n  std::map vars;\n\n  vars[\"PATH\"] = file->package();\n\n  if (!file->package().empty()) {\n    vars[\"PATH\"].append(\".\");\n  }\n\n  vars[\"ServiceName\"] = service->name();\n  vars[\"FBSFile\"] = service->name() + \"_fbs\";\n  vars[\"Filename\"] = filename;\n  auto printer = file->CreatePrinter(&output);\n\n  GenerateImports(service, &*printer, &vars, true);\n  GenerateMethods(service, &*printer, &vars);\n  GenerateService(service, &*printer, &vars);\n  return output;\n}\n\nnamespace {\n\n// MARK: - Generate Interface\n\nstatic void FillInterface(grpc_generator::Printer* printer,\n                          std::map* dictonary) {\n  auto vars = *dictonary;\n  printer->Print(vars,\n                 \"interface I$ServiceName$Service_I$MethodName$ extends \"\n                 \"grpc.MethodDefinition<$INPUT$, $OUTPUT$> {\\n\");\n  printer->Indent();\n  printer->Print(vars, \"path: string; // /$PATH$$ServiceName$/$MethodName$\\n\");\n  printer->Print(vars, \"requestStream: boolean; // $ClientStreaming$\\n\");\n  printer->Print(vars, \"responseStream: boolean; // $ServerStreaming$\\n\");\n  printer->Print(vars, \"requestSerialize: grpc.serialize<$INPUT$>;\\n\");\n  printer->Print(vars, \"requestDeserialize: grpc.deserialize<$INPUT$>;\\n\");\n  printer->Print(vars, \"responseSerialize: grpc.serialize<$OUTPUT$>;\\n\");\n  printer->Print(vars, \"responseDeserialize: grpc.deserialize<$OUTPUT$>;\\n\");\n  printer->Outdent();\n  printer->Print(\"}\\n\");\n}\n\nstatic void GenerateInterfaces(\n    const grpc_generator::Service* service, grpc_generator::Printer* printer,\n    std::map* dictonary) {\n  auto vars = *dictonary;\n  for (auto it = 0; it < service->method_count(); it++) {\n    auto method = service->method(it);\n    auto client_streaming =\n        method->ClientStreaming() || method->BidiStreaming();\n    auto server_streaming =\n        method->ServerStreaming() || method->BidiStreaming();\n    vars[\"ClientStreaming\"] = client_streaming ? \"true\" : \"false\";\n    vars[\"ServerStreaming\"] = server_streaming ? \"true\" : \"false\";\n    vars[\"MethodName\"] = method->name();\n    vars[\"OUTPUT\"] = GenerateNamespace(method->get_output_namespace_parts(),\n                                       method->get_output_type_name(), false);\n    vars[\"INPUT\"] = GenerateNamespace(method->get_input_namespace_parts(),\n                                      method->get_input_type_name(), false);\n    FillInterface(printer, &vars);\n    printer->Print(\"\\n\");\n  }\n}\n\nstatic void GenerateExportedInterface(\n    const grpc_generator::Service* service, grpc_generator::Printer* printer,\n    std::map* dictonary) {\n  auto vars = *dictonary;\n  printer->Print(vars,\n                 \"export interface I$ServiceName$Server extends \"\n                 \"grpc.UntypedServiceImplementation {\\n\");\n  printer->Indent();\n  for (auto it = 0; it < service->method_count(); it++) {\n    auto method = service->method(it);\n    vars[\"Name\"] = method->name();\n    vars[\"OUTPUT\"] = GenerateNamespace(method->get_output_namespace_parts(),\n                                       method->get_output_type_name(), false);\n    vars[\"INPUT\"] = GenerateNamespace(method->get_input_namespace_parts(),\n                                      method->get_input_type_name(), false);\n    if (method->BidiStreaming()) {\n      printer->Print(vars,\n                     \"$Name$: grpc.handleBidiStreamingCall<$INPUT$, \"\n                     \"$OUTPUT$>;\\n\");\n      continue;\n    }\n    if (method->NoStreaming()) {\n      printer->Print(vars,\n                     \"$Name$: grpc.handleUnaryCall<$INPUT$, \"\n                     \"$OUTPUT$>;\\n\");\n      continue;\n    }\n    if (method->ClientStreaming()) {\n      printer->Print(vars,\n                     \"$Name$: grpc.handleClientStreamingCall<$INPUT$, \"\n                     \"$OUTPUT$>;\\n\");\n      continue;\n    }\n    if (method->ServerStreaming()) {\n      printer->Print(vars,\n                     \"$Name$: grpc.handleServerStreamingCall<$INPUT$, \"\n                     \"$OUTPUT$>;\\n\");\n      continue;\n    }\n  }\n  printer->Outdent();\n  printer->Print(\"}\\n\");\n}\n\nstatic void GenerateMainInterface(\n    const grpc_generator::Service* service, grpc_generator::Printer* printer,\n    std::map* dictonary) {\n  auto vars = *dictonary;\n  printer->Print(\n      vars,\n      \"interface I$ServiceName$Service extends \"\n      \"grpc.ServiceDefinition {\\n\");\n  printer->Indent();\n  for (auto it = 0; it < service->method_count(); it++) {\n    auto method = service->method(it);\n    vars[\"MethodName\"] = method->name();\n    printer->Print(vars,\n                   \"$MethodName$: I$ServiceName$Service_I$MethodName$;\\n\");\n  }\n  printer->Outdent();\n  printer->Print(\"}\\n\");\n  GenerateInterfaces(service, printer, &vars);\n  printer->Print(\"\\n\");\n  printer->Print(vars,\n                 \"export const $ServiceName$Service: I$ServiceName$Service;\\n\");\n  printer->Print(\"\\n\");\n  GenerateExportedInterface(service, printer, &vars);\n}\n\nstatic grpc::string GenerateMetaData() { return \"metadata: grpc.Metadata\"; }\n\nstatic grpc::string GenerateOptions() {\n  return \"options: Partial\";\n}\n\nstatic void GenerateUnaryClientInterface(\n    grpc_generator::Printer* printer,\n    std::map* dictonary) {\n  auto vars = *dictonary;\n  grpc::string main = \"$ISPUBLIC$$MethodName$(request: $INPUT$, \";\n  grpc::string callback =\n      \"callback: (error: grpc.ServiceError | null, response: \"\n      \"$OUTPUT$) => void): grpc.ClientUnaryCall;\\n\";\n  auto meta_data = GenerateMetaData() + \", \";\n  auto options = GenerateOptions() + \", \";\n  printer->Print(vars, (main + callback).c_str());\n  printer->Print(vars, (main + meta_data + callback).c_str());\n  printer->Print(vars, (main + meta_data + options + callback).c_str());\n}\n\nstatic void GenerateClientWriteStreamInterface(\n    grpc_generator::Printer* printer,\n    std::map* dictonary) {\n  auto vars = *dictonary;\n  grpc::string main = \"$ISPUBLIC$$MethodName$(\";\n  grpc::string callback =\n      \"callback: (error: grpc.ServiceError | null, response: \"\n      \"$INPUT$) => void): \"\n      \"grpc.ClientWritableStream<$OUTPUT$>;\\n\";\n  auto meta_data = GenerateMetaData() + \", \";\n  auto options = GenerateOptions() + \", \";\n  printer->Print(vars, (main + callback).c_str());\n  printer->Print(vars, (main + meta_data + callback).c_str());\n  printer->Print(vars, (main + options + callback).c_str());\n  printer->Print(vars, (main + meta_data + options + callback).c_str());\n}\n\nstatic void GenerateClientReadableStreamInterface(\n    grpc_generator::Printer* printer,\n    std::map* dictonary) {\n  auto vars = *dictonary;\n  grpc::string main = \"$ISPUBLIC$$MethodName$(request: $INPUT$, \";\n  grpc::string end_function = \"): grpc.ClientReadableStream<$OUTPUT$>;\\n\";\n  auto meta_data = GenerateMetaData();\n  auto options = GenerateOptions();\n  printer->Print(vars, (main + meta_data + end_function).c_str());\n  printer->Print(vars, (main + options + end_function).c_str());\n}\n\nstatic void GenerateDepluxStreamInterface(\n    grpc_generator::Printer* printer,\n    std::map* dictonary) {\n  auto vars = *dictonary;\n  grpc::string main = \"$ISPUBLIC$$MethodName$(\";\n  grpc::string end_function =\n      \"): grpc.ClientDuplexStream<$INPUT$, $OUTPUT$>;\\n\";\n  auto meta_data = GenerateMetaData();\n  auto options = GenerateOptions();\n  printer->Print(vars, (main + end_function).c_str());\n  printer->Print(vars, (main + options + end_function).c_str());\n  printer->Print(vars, (main + meta_data +\n                        \", options?: Partial\" + end_function)\n                           .c_str());\n}\n\nstatic void GenerateClientInterface(\n    const grpc_generator::Service* service, grpc_generator::Printer* printer,\n    std::map* dictonary) {\n  auto vars = *dictonary;\n  printer->Print(vars, \"export interface I$ServiceName$Client {\\n\");\n  printer->Indent();\n  for (auto it = 0; it < service->method_count(); it++) {\n    auto method = service->method(it);\n    vars[\"MethodName\"] = method->name();\n    vars[\"OUTPUT\"] = GenerateNamespace(method->get_output_namespace_parts(),\n                                       method->get_output_type_name(), false);\n    vars[\"INPUT\"] = GenerateNamespace(method->get_input_namespace_parts(),\n                                      method->get_input_type_name(), false);\n    vars[\"ISPUBLIC\"] = \"\";\n\n    if (method->NoStreaming()) {\n      GenerateUnaryClientInterface(printer, &vars);\n      continue;\n    }\n    if (method->BidiStreaming()) {\n      GenerateDepluxStreamInterface(printer, &vars);\n      continue;\n    }\n\n    if (method->ClientStreaming()) {\n      GenerateClientWriteStreamInterface(printer, &vars);\n      continue;\n    }\n\n    if (method->ServerStreaming()) {\n      GenerateClientReadableStreamInterface(printer, &vars);\n      continue;\n    }\n  }\n  printer->Outdent();\n  printer->Print(\"}\\n\");\n}\n\nstatic void GenerateClientClassInterface(\n    const grpc_generator::Service* service, grpc_generator::Printer* printer,\n    std::map* dictonary) {\n  auto vars = *dictonary;\n  printer->Print(vars,\n                 \"export class $ServiceName$Client extends grpc.Client \"\n                 \"implements I$ServiceName$Client {\\n\");\n  printer->Indent();\n  printer->Print(\n      \"constructor(address: string, credentials: grpc.ChannelCredentials, \"\n      \"options?: object);\\n\");\n  for (auto it = 0; it < service->method_count(); it++) {\n    auto method = service->method(it);\n    vars[\"MethodName\"] = method->name();\n    vars[\"OUTPUT\"] = GenerateNamespace(method->get_output_namespace_parts(),\n                                       method->get_output_type_name(), false);\n    vars[\"INPUT\"] = GenerateNamespace(method->get_input_namespace_parts(),\n                                      method->get_input_type_name(), false);\n    vars[\"ISPUBLIC\"] = \"public \";\n    if (method->NoStreaming()) {\n      GenerateUnaryClientInterface(printer, &vars);\n      continue;\n    }\n    if (method->BidiStreaming()) {\n      GenerateDepluxStreamInterface(printer, &vars);\n      continue;\n    }\n\n    if (method->ClientStreaming()) {\n      GenerateClientWriteStreamInterface(printer, &vars);\n      continue;\n    }\n\n    if (method->ServerStreaming()) {\n      GenerateClientReadableStreamInterface(printer, &vars);\n      continue;\n    }\n  }\n  printer->Outdent();\n  printer->Print(\"}\\n\");\n}\n}  // namespace\n\ngrpc::string GenerateInterface(grpc_generator::File* file,\n                               const grpc_generator::Service* service,\n                               const grpc::string& filename) {\n  grpc::string output;\n\n  std::set generated_functions;\n  std::map vars;\n\n  vars[\"PATH\"] = file->package();\n\n  if (!file->package().empty()) {\n    vars[\"PATH\"].append(\".\");\n  }\n\n  vars[\"ServiceName\"] = service->name();\n  vars[\"FBSFile\"] = service->name() + \"_fbs\";\n  vars[\"Filename\"] = filename;\n  auto printer = file->CreatePrinter(&output);\n\n  GenerateImports(service, &*printer, &vars, false);\n  GenerateMainInterface(service, &*printer, &vars);\n  printer->Print(\"\\n\");\n  GenerateClientInterface(service, &*printer, &vars);\n  printer->Print(\"\\n\");\n  GenerateClientClassInterface(service, &*printer, &vars);\n  return output;\n}\n}  // namespace grpc_ts_generator\n"
  },
  {
    "path": "grpc/src/compiler/ts_generator.h",
    "content": "#include \n#include \n#include \n\n#include \"src/compiler/schema_interface.h\"\n\n#ifndef GRPC_CUSTOM_STRING\n#include \n#define GRPC_CUSTOM_STRING std::string\n#endif\n\nnamespace grpc {\n\ntypedef GRPC_CUSTOM_STRING string;\n\n}  // namespace grpc\n\nnamespace grpc_ts_generator {\ngrpc::string Generate(grpc_generator::File* file,\n                      const grpc_generator::Service* service,\n                      const grpc::string& filename);\n\ngrpc::string GenerateInterface(grpc_generator::File* file,\n                               const grpc_generator::Service* service,\n                               const grpc::string& filename);\n}  // namespace grpc_ts_generator\n"
  },
  {
    "path": "grpc/tests/BUILD",
    "content": "load(\"@rules_cc//cc:defs.bzl\", \"cc_test\")\n\ncc_test(\n    name = \"grpc_test\",\n    srcs = [\n        \"grpctest.cpp\",\n        \"message_builder_test.cpp\",\n    ],\n    copts = [\"-Itests\"],\n    # This is required.\n    linkstatic = 1,\n    deps = [\n        \"//tests:monster_test_cc_fbs\",\n        \"//tests:monster_test_grpc\",\n        \"//tests:test_assert\",\n        \"//tests:test_builder\",\n        \"@com_github_grpc_grpc//:grpc++\",\n    ],\n)\n\ncc_test(\n    name = \"grpc_callback_compile_test\",\n    srcs = [\"grpctest_callback_compile.cpp\"],\n    copts = [\"-Itests\"],\n    linkstatic = 1,\n    deps = [\n        \"//tests:monster_test_cc_fbs\",\n        \"//tests:monster_test_grpc\",\n        \"@com_github_grpc_grpc//:grpc++\",\n    ],\n)\n\ncc_test(\n    name = \"grpc_callback_client_compile_test\",\n    srcs = [\"grpctest_callback_client_compile.cpp\"],\n    copts = [\"-Itests\"],\n    linkstatic = 1,\n    deps = [\n        \"//tests:monster_test_cc_fbs\",\n        \"//tests:monster_test_grpc\",\n        \"@com_github_grpc_grpc//:grpc++\",\n    ],\n)\n"
  },
  {
    "path": "grpc/tests/GameFactory.java",
    "content": "import MyGame.Example.Monster;\nimport MyGame.Example.Stat;\nimport com.google.flatbuffers.FlatBufferBuilder;\nimport java.nio.ByteBuffer;\n\nclass GameFactory {\n  public static Monster createMonster(\n      String monsterName, short nestedMonsterHp, short nestedMonsterMana) {\n    FlatBufferBuilder builder = new FlatBufferBuilder();\n\n    int name_offset = builder.createString(monsterName);\n    Monster.startMonster(builder);\n    Monster.addName(builder, name_offset);\n    Monster.addHp(builder, nestedMonsterHp);\n    Monster.addMana(builder, nestedMonsterMana);\n    int monster_offset = Monster.endMonster(builder);\n    Monster.finishMonsterBuffer(builder, monster_offset);\n\n    ByteBuffer buffer = builder.dataBuffer();\n    Monster monster = Monster.getRootAsMonster(buffer);\n    return monster;\n  }\n\n  public static Monster createMonsterFromStat(Stat stat, int seqNo) {\n    FlatBufferBuilder builder = new FlatBufferBuilder();\n    int name_offset = builder.createString(stat.id() + \" No.\" + seqNo);\n    Monster.startMonster(builder);\n    Monster.addName(builder, name_offset);\n    int monster_offset = Monster.endMonster(builder);\n    Monster.finishMonsterBuffer(builder, monster_offset);\n    Monster monster = Monster.getRootAsMonster(builder.dataBuffer());\n    return monster;\n  }\n\n  public static Stat createStat(String greeting, long val, int count) {\n    FlatBufferBuilder builder = new FlatBufferBuilder();\n    int statOffset = Stat.createStat(builder, builder.createString(greeting), val, count);\n    builder.finish(statOffset);\n    Stat stat = Stat.getRootAsStat(builder.dataBuffer());\n    return stat;\n  }\n}\n"
  },
  {
    "path": "grpc/tests/JavaGrpcTest.java",
    "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport MyGame.Example.Monster;\nimport MyGame.Example.MonsterStorageGrpc;\nimport MyGame.Example.Stat;\nimport io.grpc.ManagedChannel;\nimport io.grpc.ManagedChannelBuilder;\nimport io.grpc.Server;\nimport io.grpc.ServerBuilder;\nimport io.grpc.stub.StreamObserver;\nimport java.io.IOException;\nimport java.util.Iterator;\nimport java.util.concurrent.CountDownLatch;\nimport java.util.concurrent.TimeUnit;\nimport java.util.concurrent.atomic.AtomicInteger;\nimport java.util.concurrent.atomic.AtomicReference;\nimport org.junit.Assert;\n\n/** Demonstrates basic client-server interaction using grpc-java over netty. */\npublic class JavaGrpcTest {\n  static final String BIG_MONSTER_NAME = \"Cyberdemon\";\n  static final short nestedMonsterHp = 600;\n  static final short nestedMonsterMana = 1024;\n  static final int numStreamedMsgs = 10;\n  static final int timeoutMs = 3000;\n  static Server server;\n  static ManagedChannel channel;\n  static MonsterStorageGrpc.MonsterStorageBlockingStub blockingStub;\n  static MonsterStorageGrpc.MonsterStorageStub asyncStub;\n\n  static class MyService extends MonsterStorageGrpc.MonsterStorageImplBase {\n    @Override\n    public void store(Monster request, io.grpc.stub.StreamObserver responseObserver) {\n      Assert.assertEquals(request.name(), BIG_MONSTER_NAME);\n      Assert.assertEquals(request.hp(), nestedMonsterHp);\n      Assert.assertEquals(request.mana(), nestedMonsterMana);\n      System.out.println(\"Received store request from \" + request.name());\n      // Create a response from the incoming request name.\n      Stat stat = GameFactory.createStat(\"Hello \" + request.name(), 100, 10);\n      responseObserver.onNext(stat);\n      responseObserver.onCompleted();\n    }\n\n    @Override\n    public void retrieve(Stat request, io.grpc.stub.StreamObserver responseObserver) {\n      // Create 10 monsters for streaming response.\n      for (int i = 0; i < numStreamedMsgs; i++) {\n        Monster monster = GameFactory.createMonsterFromStat(request, i);\n        responseObserver.onNext(monster);\n      }\n      responseObserver.onCompleted();\n    }\n\n    @Override\n    public StreamObserver getMaxHitPoint(final StreamObserver responseObserver) {\n      return computeMinMax(responseObserver, false);\n    }\n\n    @Override\n    public StreamObserver getMinMaxHitPoints(final StreamObserver responseObserver) {\n      return computeMinMax(responseObserver, true);\n    }\n\n    private StreamObserver computeMinMax(\n        final StreamObserver responseObserver, final boolean includeMin) {\n      final AtomicInteger maxHp = new AtomicInteger(Integer.MIN_VALUE);\n      final AtomicReference maxHpMonsterName = new AtomicReference();\n      final AtomicInteger maxHpCount = new AtomicInteger();\n\n      final AtomicInteger minHp = new AtomicInteger(Integer.MAX_VALUE);\n      final AtomicReference minHpMonsterName = new AtomicReference();\n      final AtomicInteger minHpCount = new AtomicInteger();\n\n      return new StreamObserver() {\n        public void onNext(Monster monster) {\n          if (monster.hp() > maxHp.get()) {\n            // Found a monster of higher hit points.\n            maxHp.set(monster.hp());\n            maxHpMonsterName.set(monster.name());\n            maxHpCount.set(1);\n          } else if (monster.hp() == maxHp.get()) {\n            // Count how many times we saw a monster of current max hit points.\n            maxHpCount.getAndIncrement();\n          }\n\n          if (monster.hp() < minHp.get()) {\n            // Found a monster of a lower hit points.\n            minHp.set(monster.hp());\n            minHpMonsterName.set(monster.name());\n            minHpCount.set(1);\n          } else if (monster.hp() == minHp.get()) {\n            // Count how many times we saw a monster of current min hit points.\n            minHpCount.getAndIncrement();\n          }\n        }\n\n        public void onCompleted() {\n          Stat maxHpStat =\n              GameFactory.createStat(maxHpMonsterName.get(), maxHp.get(), maxHpCount.get());\n          // Send max hit points first.\n          responseObserver.onNext(maxHpStat);\n          if (includeMin) {\n            // Send min hit points.\n            Stat minHpStat =\n                GameFactory.createStat(minHpMonsterName.get(), minHp.get(), minHpCount.get());\n            responseObserver.onNext(minHpStat);\n          }\n          responseObserver.onCompleted();\n        }\n\n        public void onError(Throwable t) {\n          // Not expected\n          Assert.fail();\n        }\n        ;\n      };\n    }\n  }\n\n  @org.junit.BeforeClass\n  public static void startServer() throws IOException {\n    server = ServerBuilder.forPort(0).addService(new MyService()).build().start();\n    int port = server.getPort();\n    channel =\n        ManagedChannelBuilder.forAddress(\"localhost\", port)\n            // Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid\n            // needing certificates.\n            .usePlaintext()\n            .directExecutor()\n            .build();\n    blockingStub = MonsterStorageGrpc.newBlockingStub(channel);\n    asyncStub = MonsterStorageGrpc.newStub(channel);\n  }\n\n  @org.junit.Test\n  public void testUnary() throws IOException {\n    Monster monsterRequest =\n        GameFactory.createMonster(BIG_MONSTER_NAME, nestedMonsterHp, nestedMonsterMana);\n    Stat stat = blockingStub.store(monsterRequest);\n    Assert.assertEquals(stat.id(), \"Hello \" + BIG_MONSTER_NAME);\n    System.out.println(\"Received stat response from service: \" + stat.id());\n  }\n\n  @org.junit.Test\n  public void testServerStreaming() throws IOException {\n    Monster monsterRequest =\n        GameFactory.createMonster(BIG_MONSTER_NAME, nestedMonsterHp, nestedMonsterMana);\n    Stat stat = blockingStub.store(monsterRequest);\n    Iterator iterator = blockingStub.retrieve(stat);\n    int counter = 0;\n    while (iterator.hasNext()) {\n      Monster m = iterator.next();\n      System.out.println(\"Received monster \" + m.name());\n      counter++;\n    }\n    Assert.assertEquals(counter, numStreamedMsgs);\n    System.out.println(\"FlatBuffers GRPC client/server test: completed successfully\");\n  }\n\n  @org.junit.Test\n  public void testClientStreaming() throws IOException, InterruptedException {\n    final AtomicReference maxHitStat = new AtomicReference();\n    final CountDownLatch streamAlive = new CountDownLatch(1);\n\n    StreamObserver statObserver =\n        new StreamObserver() {\n          public void onCompleted() {\n            streamAlive.countDown();\n          }\n\n          public void onError(Throwable ex) {}\n\n          public void onNext(Stat stat) {\n            maxHitStat.set(stat);\n          }\n        };\n    StreamObserver monsterStream = asyncStub.getMaxHitPoint(statObserver);\n    short count = 10;\n    for (short i = 0; i < count; ++i) {\n      Monster monster =\n          GameFactory.createMonster(\n              BIG_MONSTER_NAME + i, (short) (nestedMonsterHp * i), nestedMonsterMana);\n      monsterStream.onNext(monster);\n    }\n    monsterStream.onCompleted();\n    // Wait a little bit for the server to send the stats of the monster with the max hit-points.\n    streamAlive.await(timeoutMs, TimeUnit.MILLISECONDS);\n    Assert.assertEquals(maxHitStat.get().id(), BIG_MONSTER_NAME + (count - 1));\n    Assert.assertEquals(maxHitStat.get().val(), nestedMonsterHp * (count - 1));\n    Assert.assertEquals(maxHitStat.get().count(), 1);\n  }\n\n  @org.junit.Test\n  public void testBiDiStreaming() throws IOException, InterruptedException {\n    final AtomicReference maxHitStat = new AtomicReference();\n    final AtomicReference minHitStat = new AtomicReference();\n    final CountDownLatch streamAlive = new CountDownLatch(1);\n\n    StreamObserver statObserver =\n        new StreamObserver() {\n          public void onCompleted() {\n            streamAlive.countDown();\n          }\n\n          public void onError(Throwable ex) {}\n\n          public void onNext(Stat stat) {\n            // We expect the server to send the max stat first and then the min stat.\n            if (maxHitStat.get() == null) {\n              maxHitStat.set(stat);\n            } else {\n              minHitStat.set(stat);\n            }\n          }\n        };\n    StreamObserver monsterStream = asyncStub.getMinMaxHitPoints(statObserver);\n    short count = 10;\n    for (short i = 0; i < count; ++i) {\n      Monster monster =\n          GameFactory.createMonster(\n              BIG_MONSTER_NAME + i, (short) (nestedMonsterHp * i), nestedMonsterMana);\n      monsterStream.onNext(monster);\n    }\n    monsterStream.onCompleted();\n\n    // Wait a little bit for the server to send the stats of the monster with the max and min\n    // hit-points.\n    streamAlive.await(timeoutMs, TimeUnit.MILLISECONDS);\n\n    Assert.assertEquals(maxHitStat.get().id(), BIG_MONSTER_NAME + (count - 1));\n    Assert.assertEquals(maxHitStat.get().val(), nestedMonsterHp * (count - 1));\n    Assert.assertEquals(maxHitStat.get().count(), 1);\n\n    Assert.assertEquals(minHitStat.get().id(), BIG_MONSTER_NAME + 0);\n    Assert.assertEquals(minHitStat.get().val(), nestedMonsterHp * 0);\n    Assert.assertEquals(minHitStat.get().count(), 1);\n  }\n}\n"
  },
  {
    "path": "grpc/tests/go_test.go",
    "content": "package testing\n\nimport (\n\tflatbuffers \"github.com/google/flatbuffers/go\"\n\t\"github.com/google/flatbuffers/tests/MyGame/Example\"\n\n\t\"context\"\n\t\"net\"\n\t\"testing\"\n\n\t\"google.golang.org/grpc\"\n\t\"google.golang.org/grpc/encoding\"\n)\n\ntype server struct {\n\tExample.UnimplementedMonsterStorageServer\n}\n\n// test used to send and receive in grpc methods\nvar test = \"Flatbuffers\"\nvar addr = \"0.0.0.0:50051\"\n\n// gRPC server store method\nfunc (s *server) Store(context context.Context, in *Example.Monster) (*flatbuffers.Builder, error) {\n\tb := flatbuffers.NewBuilder(0)\n\ti := b.CreateString(test)\n\tExample.StatStart(b)\n\tExample.StatAddId(b, i)\n\tb.Finish(Example.StatEnd(b))\n\treturn b, nil\n\n}\n\n// gRPC server retrieve method\nfunc (s *server) Retrieve(context context.Context, in *Example.Stat) (*flatbuffers.Builder, error) {\n\tb := flatbuffers.NewBuilder(0)\n\ti := b.CreateString(test)\n\tExample.MonsterStart(b)\n\tExample.MonsterAddName(b, i)\n\tb.Finish(Example.MonsterEnd(b))\n\treturn b, nil\n}\n\nfunc StoreClient(c Example.MonsterStorageClient, t *testing.T) {\n\tb := flatbuffers.NewBuilder(0)\n\ti := b.CreateString(test)\n\tExample.MonsterStart(b)\n\tExample.MonsterAddName(b, i)\n\tb.Finish(Example.MonsterEnd(b))\n\tout, err := c.Store(context.Background(), b)\n\tif err != nil {\n\t\tt.Fatalf(\"Store client failed: %v\", err)\n\t}\n\tif string(out.Id()) != test {\n\t\tt.Errorf(\"StoreClient failed: expected=%s, got=%s\\n\", test, out.Id())\n\t\tt.Fail()\n\t}\n}\n\nfunc RetrieveClient(c Example.MonsterStorageClient, t *testing.T) {\n\tb := flatbuffers.NewBuilder(0)\n\ti := b.CreateString(test)\n\tExample.StatStart(b)\n\tExample.StatAddId(b, i)\n\tb.Finish(Example.StatEnd(b))\n\tout, err := c.Retrieve(context.Background(), b)\n\tif err != nil {\n\t\tt.Fatalf(\"Retrieve client failed: %v\", err)\n\t}\n\tmonster, err := out.Recv()\n\tif err != nil {\n\t\tt.Fatalf(\"Recv failed: %v\", err)\n\t}\n\tif string(monster.Name()) != test {\n\t\tt.Errorf(\"RetrieveClient failed: expected=%s, got=%s\\n\", test, monster.Name())\n\t\tt.Fail()\n\t}\n}\n\nfunc TestGRPC(t *testing.T) {\n\tlis, err := net.Listen(\"tcp\", addr)\n\tif err != nil {\n\t\tt.Fatalf(\"Failed to listen: %v\", err)\n\t}\n\tser := grpc.NewServer()\n\tencoding.RegisterCodec(flatbuffers.FlatbuffersCodec{})\n\tExample.RegisterMonsterStorageServer(ser, &server{})\n\tgo func() {\n\t\tif err := ser.Serve(lis); err != nil {\n\t\t\tt.Fatalf(\"Failed to serve: %v\", err)\n\t\t\tt.FailNow()\n\t\t}\n\t}()\n\tconn, err := grpc.Dial(addr, grpc.WithInsecure(), grpc.WithCodec(flatbuffers.FlatbuffersCodec{}))\n\tif err != nil {\n\t\tt.Fatalf(\"Failed to connect: %v\", err)\n\t}\n\tdefer conn.Close()\n\tclient := Example.NewMonsterStorageClient(conn)\n\tStoreClient(client, t)\n\tRetrieveClient(client, t)\n}\n"
  },
  {
    "path": "grpc/tests/grpctest.cpp",
    "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n\n#include \n#include \n\n#include \"monster_test.grpc.fb.h\"\n#include \"monster_test_generated.h\"\n#include \"test_assert.h\"\n\nusing namespace MyGame::Example;\nusing flatbuffers::FlatBufferBuilder;\nusing flatbuffers::grpc::MessageBuilder;\n\nvoid message_builder_tests();\n\n// The callback implementation of our server, that derives from the generated\n// code. It implements all rpcs specified in the FlatBuffers schema.\nclass ServiceImpl final : public MyGame::Example::MonsterStorage::Service {\n  virtual ::grpc::Status Store(\n      ::grpc::ServerContext* context,\n      const flatbuffers::grpc::Message* request,\n      flatbuffers::grpc::Message* response) override {\n    // Create a response from the incoming request name.\n    fbb_.Clear();\n    auto stat_offset = CreateStat(\n        fbb_, fbb_.CreateString(\"Hello, \" + request->GetRoot()->name()->str()));\n    fbb_.Finish(stat_offset);\n    // Transfer ownership of the message to gRPC\n    *response = fbb_.ReleaseMessage();\n    return grpc::Status::OK;\n  }\n  virtual ::grpc::Status Retrieve(\n      ::grpc::ServerContext* context,\n      const flatbuffers::grpc::Message* request,\n      ::grpc::ServerWriter>* writer)\n      override {\n    for (int i = 0; i < 5; i++) {\n      fbb_.Clear();\n      // Create 5 monsters for resposne.\n      auto monster_offset =\n          CreateMonster(fbb_, 0, 0, 0,\n                        fbb_.CreateString(request->GetRoot()->id()->str() +\n                                          \" No.\" + std::to_string(i)));\n      fbb_.Finish(monster_offset);\n\n      flatbuffers::grpc::Message monster =\n          fbb_.ReleaseMessage();\n\n      // Send monster to client using streaming.\n      writer->Write(monster);\n    }\n    return grpc::Status::OK;\n  }\n\n private:\n  flatbuffers::grpc::MessageBuilder fbb_;\n};\n\n// Track the server instance, so we can terminate it later.\ngrpc::Server* server_instance = nullptr;\n// Mutex to protec this variable.\nstd::mutex wait_for_server;\nstd::condition_variable server_instance_cv;\n\n// This function implements the server thread.\nvoid RunServer() {\n  auto server_address = \"0.0.0.0:50051\";\n  // Callback interface we implemented above.\n  ServiceImpl service;\n  grpc::ServerBuilder builder;\n  builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());\n  builder.RegisterService(&service);\n\n  // Start the server. Lock to change the variable we're changing.\n  wait_for_server.lock();\n  server_instance = builder.BuildAndStart().release();\n  wait_for_server.unlock();\n  server_instance_cv.notify_one();\n\n  std::cout << \"Server listening on \" << server_address << std::endl;\n  // This will block the thread and serve requests.\n  server_instance->Wait();\n}\n\ntemplate \nvoid StoreRPC(MonsterStorage::Stub* stub) {\n  Builder fbb;\n  grpc::ClientContext context;\n  // Build a request with the name set.\n  auto monster_offset = CreateMonster(fbb, 0, 0, 0, fbb.CreateString(\"Fred\"));\n  MessageBuilder mb(std::move(fbb));\n  mb.Finish(monster_offset);\n  auto request = mb.ReleaseMessage();\n  flatbuffers::grpc::Message response;\n\n  // The actual RPC.\n  auto status = stub->Store(&context, request, &response);\n\n  if (status.ok()) {\n    auto resp = response.GetRoot()->id();\n    std::cout << \"RPC response: \" << resp->str() << std::endl;\n  } else {\n    std::cout << \"RPC failed\" << std::endl;\n  }\n}\n\ntemplate \nvoid RetrieveRPC(MonsterStorage::Stub* stub) {\n  Builder fbb;\n  grpc::ClientContext context;\n  fbb.Clear();\n  auto stat_offset = CreateStat(fbb, fbb.CreateString(\"Fred\"));\n  fbb.Finish(stat_offset);\n  auto request = MessageBuilder(std::move(fbb)).ReleaseMessage();\n\n  flatbuffers::grpc::Message response;\n  auto stream = stub->Retrieve(&context, request);\n  while (stream->Read(&response)) {\n    auto resp = response.GetRoot()->name();\n    std::cout << \"RPC Streaming response: \" << resp->str() << std::endl;\n  }\n}\n\nint grpc_server_test() {\n  // Launch server.\n  std::thread server_thread(RunServer);\n\n  // wait for server to spin up.\n  std::unique_lock lock(wait_for_server);\n  while (!server_instance) server_instance_cv.wait(lock);\n\n  // Now connect the client.\n  auto channel = grpc::CreateChannel(\"localhost:50051\",\n                                     grpc::InsecureChannelCredentials());\n  auto stub = MyGame::Example::MonsterStorage::NewStub(channel);\n\n  StoreRPC(stub.get());\n  StoreRPC(stub.get());\n\n  RetrieveRPC(stub.get());\n  RetrieveRPC(stub.get());\n\n#if !FLATBUFFERS_GRPC_DISABLE_AUTO_VERIFICATION\n  {\n    // Test that an invalid request errors out correctly\n    grpc::ClientContext context;\n    flatbuffers::grpc::Message request;  // simulate invalid message\n    flatbuffers::grpc::Message response;\n    auto status = stub->Store(&context, request, &response);\n    // The rpc status should be INTERNAL to indicate a verification error. This\n    // matches the protobuf gRPC status code for an unparseable message.\n    assert(!status.ok());\n    assert(status.error_code() == ::grpc::StatusCode::INTERNAL);\n    assert(strcmp(status.error_message().c_str(),\n                  \"Message verification failed\") == 0);\n  }\n#endif\n\n  server_instance->Shutdown();\n\n  server_thread.join();\n\n  delete server_instance;\n\n  return 0;\n}\n\nint main(int /*argc*/, const char* /*argv*/[]) {\n  message_builder_tests();\n  grpc_server_test();\n\n  if (!testing_fails) {\n    TEST_OUTPUT_LINE(\"ALL TESTS PASSED\");\n    return 0;\n  } else {\n    TEST_OUTPUT_LINE(\"%d FAILED TESTS\", testing_fails);\n    return 1;\n  }\n}\n"
  },
  {
    "path": "grpc/tests/grpctest.py",
    "content": "from __future__ import print_function\n\nfrom concurrent import futures\nimport os\nimport sys\n\nimport flatbuffers\nimport grpc\n\nsys.path.append(os.path.join(os.path.dirname(__file__), \"..\", \"..\", \"tests\"))\nimport MyGame.Example.Monster as Monster\nimport MyGame.Example.Stat as Stat\nimport MyGame.Example.Vec3 as Vec3\nimport MyGame.Example.Test as Test\nimport MyGame.Example.monster_test_grpc_fb as monster_grpc_fb\n\n\ntest_stat_id = \"test_stat_id\"\ntest_stat_val = 8\ntest_stat_count = 1\n\ntest_monster_name1 = \"test_monster_name1\"\ntest_monster_name2 = \"test_monster_name2\"\ntest_string = \"test_string\"\ntest_color = 2\ntest_X = 3.0\ntest_Y = 2.0\ntest_Z = 6.0\ntest_test1 = 4.0\ntest_a = 8\ntest_b = 5\ntest_hp = 67\ntest_inventory = [1, 1, 2, 3, 5, 8]\ntest_testtype = 4\n\ntest_monsters_name_retrieve = [\"big_monster\", \"small_monster\"]\ntest_no_of_monsters = 2\n\n\nclass MonsterStorage(monster_grpc_fb.MonsterStorageServicer):\n\n  def Store(self, request, context):\n\n    m = Monster.Monster().GetRootAsMonster(request, 0)\n\n    assert m.Name().decode(\"utf-8\") == test_monster_name1\n\n    assert m.Pos().X() == test_X\n    assert m.Pos().Y() == test_Y\n    assert m.Pos().Z() == test_Z\n    assert m.Pos().Test1() == test_test1\n    assert m.Pos().Test2() == test_color\n    test3 = Test.Test()\n    assert m.Pos().Test3(test3).A() == test_a\n    assert m.Pos().Test3(test3).B() == test_b\n\n    assert m.Hp() == test_hp\n\n    assert m.Color() == test_color\n\n    assert m.InventoryLength() == len(test_inventory)\n    for i in range(0, len(test_inventory)):\n      assert m.Inventory(i) == test_inventory[len(test_inventory) - i - 1]\n\n    assert m.TestType() == test_testtype\n\n    assert m.Test() is not None\n    table = m.Test()\n\n    m2 = Monster.Monster()\n    m2.Init(table.Bytes, table.Pos)\n    assert m2.Name().decode(\"utf-8\") == test_monster_name2\n\n    m3 = m.Enemy()\n    assert m3.Name().decode(\"utf-8\") == test_monster_name2\n\n    assert m.Testarrayofstring(0).decode(\"utf-8\") == test_string\n\n    b = flatbuffers.Builder(0)\n    i = b.CreateString(test_stat_id)\n    Stat.StatStart(b)\n    Stat.StatAddId(b, i)\n    Stat.StatAddVal(b, test_stat_val)\n    Stat.StatAddCount(b, test_stat_count)\n    b.Finish(Stat.StatEnd(b))\n    return bytes(b.Output())\n\n  def Retrieve(self, request, context):\n\n    s = Stat.Stat().GetRootAsStat(request, 0)\n\n    no_of_monsters = test_no_of_monsters\n    for i in range(0, no_of_monsters):\n      b = flatbuffers.Builder(0)\n      i = b.CreateString(test_monsters_name_retrieve[i])\n      Monster.MonsterStart(b)\n      Monster.MonsterAddName(b, i)\n      b.Finish(Monster.MonsterEnd(b))\n      yield bytes(b.Output())\n\n\ndef serve():\n\n  server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))\n  monster_grpc_fb.add_MonsterStorageServicer_to_server(MonsterStorage(), server)\n  server.add_insecure_port(\"[::]:50051\")\n\n  server.start()\n\n  run()\n\n\ndef run():\n\n  channel = grpc.insecure_channel(\"127.0.0.1:50051\")\n  stub = monster_grpc_fb.MonsterStorageStub(channel)\n\n  b = flatbuffers.Builder(0)\n  name2 = b.CreateString(test_monster_name2)\n  name1 = b.CreateString(test_monster_name1)\n  Monster.MonsterStart(b)\n  Monster.MonsterAddName(b, name2)\n  monster2 = Monster.MonsterEnd(b)\n  test1 = b.CreateString(test_string)\n\n  Monster.MonsterStartInventoryVector(b, len(test_inventory))\n  for i in range(0, len(test_inventory)):\n    b.PrependByte(test_inventory[i])\n  inv = b.EndVector()\n\n  Monster.MonsterStartTest4Vector(b, 2)\n  Test.CreateTest(b, 10, 20)\n  Test.CreateTest(b, 30, 40)\n  test4 = b.EndVector()\n\n  Monster.MonsterStartTestarrayofstringVector(b, 1)\n  b.PrependUOffsetTRelative(test1)\n  test_array_of_string = b.EndVector()\n\n  Monster.MonsterStart(b)\n\n  Monster.MonsterAddHp(b, test_hp)\n  Monster.MonsterAddName(b, name1)\n  Monster.MonsterAddColor(b, test_color)\n  pos = Vec3.CreateVec3(\n      b, test_X, test_Y, test_Z, test_test1, test_color, test_a, test_b\n  )\n  Monster.MonsterAddPos(b, pos)\n  Monster.MonsterAddInventory(b, inv)\n  Monster.MonsterAddTestType(b, test_testtype)\n  Monster.MonsterAddTest(b, monster2)\n  Monster.MonsterAddTest4(b, test4)\n  Monster.MonsterAddEnemy(b, monster2)\n  Monster.MonsterAddTestarrayofstring(b, test_array_of_string)\n  monster = Monster.MonsterEnd(b)\n\n  b.Finish(monster)\n\n  stat_response = stub.Store(bytes(b.Output()))\n\n  s = Stat.Stat().GetRootAsStat(stat_response, 0)\n\n  assert s.Id().decode(\"utf-8\") == test_stat_id\n  assert s.Val() == test_stat_val\n  assert s.Count() == test_stat_count\n\n  monster_reponses = stub.Retrieve(stat_response)\n  count = 0\n  for monster_reponse in monster_reponses:\n    m = Monster.Monster().GetRootAsMonster(monster_reponse, 0)\n    assert m.Name().decode(\"utf-8\") == test_monsters_name_retrieve[count]\n    count = count + 1\n\n\nif __name__ == \"__main__\":\n  serve()\n"
  },
  {
    "path": "grpc/tests/grpctest_callback_client_compile.cpp",
    "content": "// Verifies that the generated gRPC callback client stub methods are present.\n// This is a compile-time only test: it never performs an actual RPC.\n// It supplements grpctest_callback_compile.cpp (server side) by checking\n// client-side async_ / reactor entry points.\n\n#include \n\n#include \"monster_test.grpc.fb.h\"\n\n#if defined(FLATBUFFERS_GENERATED_GRPC_CALLBACK_API) && \\\n    defined(GRPC_CALLBACK_API_NONEXPERIMENTAL)\nusing Stub = MyGame::Example::MonsterStorage::Stub;\nusing namespace MyGame::Example;  // NOLINT\n\n// Unary async overloads\nstatic_assert(std::is_member_function_pointer<\n                  decltype(static_cast&,\n                               flatbuffers::grpc::Message*,\n                               std::function)>(\n                      &Stub::async_Store))>::value,\n              \"Function-form unary async_Store missing\");\nstatic_assert(\n    std::is_member_function_pointer<\n        decltype(static_cast&,\n                     flatbuffers::grpc::Message*,\n                     ::grpc::ClientUnaryReactor*)>(&Stub::async_Store))>::value,\n    \"Reactor-form unary async_Store missing\");\n\n// Streaming reactor entry points\nstatic_assert(\n    std::is_member_function_pointer<\n        decltype(static_cast&,\n                     ::grpc::ClientReadReactor >*)>(&Stub::async_Retrieve))>::value,\n    \"Server streaming reactor async_Retrieve missing\");\nstatic_assert(\n    std::is_member_function_pointer<\n        decltype(static_cast*,\n                     ::grpc::ClientWriteReactor >*)>(&Stub::async_GetMaxHitPoint))>::value,\n    \"Client streaming reactor async_GetMaxHitPoint missing\");\nstatic_assert(std::is_member_function_pointer<\n                  decltype(static_cast,\n                                   flatbuffers::grpc::Message >*)>(\n                      &Stub::async_GetMinMaxHitPoints))>::value,\n              \"Bidi streaming reactor async_GetMinMaxHitPoints missing\");\n#endif  // FLATBUFFERS_GENERATED_GRPC_CALLBACK_API &&\n        // GRPC_CALLBACK_API_NONEXPERIMENTAL\n\nint main() { return 0; }\n"
  },
  {
    "path": "grpc/tests/grpctest_callback_compile.cpp",
    "content": "#include \"monster_test.grpc.fb.h\"\n\n// This test only verifies that the generated CallbackService compiles when the\n// callback API is available. It does not run any RPCs.\n\n#if defined(FLATBUFFERS_GENERATED_GRPC_CALLBACK_API) && \\\n    defined(GRPC_CALLBACK_API_NONEXPERIMENTAL)\nclass CallbackServiceImpl\n    : public MyGame::Example::MonsterStorage::CallbackService {\n public:\n  // For brevity we don't override methods; user code will provide reactors.\n};\n#endif\n\nint main() {\n#if defined(FLATBUFFERS_GENERATED_GRPC_CALLBACK_API) && \\\n    defined(GRPC_CALLBACK_API_NONEXPERIMENTAL)\n  CallbackServiceImpl svc;\n  (void)svc;  // suppress unused\n#endif\n  return 0;\n}\n"
  },
  {
    "path": "grpc/tests/java-grpc-test.sh",
    "content": "#!/bin/sh\n\n# NOTE: make sure `mvn install` in /gprc is executed before running this test\nmvn test\n"
  },
  {
    "path": "grpc/tests/message_builder_test.cpp",
    "content": "#include \"flatbuffers/grpc.h\"\n#include \"monster_test_generated.h\"\n#include \"test_assert.h\"\n#include \"test_builder.h\"\n\nusing MyGame::Example::Any_NONE;\nusing MyGame::Example::CreateStat;\nusing MyGame::Example::Vec3;\n\nbool verify(flatbuffers::grpc::Message& msg,\n            const std::string& expected_name, Color expected_color) {\n  const Monster* monster = msg.GetRoot();\n  const auto name = monster->name()->str();\n  const auto color = monster->color();\n  TEST_EQ(name, expected_name);\n  TEST_EQ(color, expected_color);\n  return (name == expected_name) && (color == expected_color);\n}\n\nbool release_n_verify(flatbuffers::grpc::MessageBuilder& mbb,\n                      const std::string& expected_name, Color expected_color) {\n  flatbuffers::grpc::Message msg = mbb.ReleaseMessage();\n  return verify(msg, expected_name, expected_color);\n}\n\nvoid builder_move_assign_after_releaseraw_test(\n    flatbuffers::grpc::MessageBuilder dst) {\n  auto root_offset1 = populate1(dst);\n  dst.Finish(root_offset1);\n  size_t size, offset;\n  ::grpc::Slice slice;\n  dst.ReleaseRaw(size, offset, slice);\n  flatbuffers::FlatBufferBuilder src;\n  auto root_offset2 = populate2(src);\n  src.Finish(root_offset2);\n  auto src_size = src.GetSize();\n  // Move into a released builder.\n  dst = std::move(src);\n  TEST_EQ(dst.GetSize(), src_size);\n  TEST_ASSERT(release_n_verify(dst, m2_name(), m2_color()));\n  TEST_EQ(src.GetSize(), 0);\n}\n\ntemplate \nstruct BuilderReuseTests {\n  static void builder_reusable_after_release_message_test(\n      TestSelector selector) {\n    if (!selector.count(REUSABLE_AFTER_RELEASE_MESSAGE)) {\n      return;\n    }\n\n    flatbuffers::grpc::MessageBuilder mb;\n    std::vector> buffers;\n    for (int i = 0; i < 5; ++i) {\n      auto root_offset1 = populate1(mb);\n      mb.Finish(root_offset1);\n      buffers.push_back(mb.ReleaseMessage());\n      TEST_ASSERT_FUNC(verify(buffers[i], m1_name(), m1_color()));\n    }\n  }\n\n  static void builder_reusable_after_release_test(TestSelector selector) {\n    if (!selector.count(REUSABLE_AFTER_RELEASE)) {\n      return;\n    }\n\n    // FIXME: Populate-Release loop fails assert(GRPC_SLICE_IS_EMPTY(slice_)) in\n    // SliceAllocator::allocate in the second iteration.\n\n    flatbuffers::grpc::MessageBuilder mb;\n    std::vector buffers;\n    for (int i = 0; i < 2; ++i) {\n      auto root_offset1 = populate1(mb);\n      mb.Finish(root_offset1);\n      buffers.push_back(mb.Release());\n      TEST_ASSERT_FUNC(verify(buffers[i], m1_name(), m1_color()));\n    }\n  }\n\n  static void builder_reusable_after_releaseraw_test(TestSelector selector) {\n    if (!selector.count(REUSABLE_AFTER_RELEASE_RAW)) {\n      return;\n    }\n\n    flatbuffers::grpc::MessageBuilder mb;\n    for (int i = 0; i < 5; ++i) {\n      auto root_offset1 = populate1(mb);\n      mb.Finish(root_offset1);\n      size_t size, offset;\n      ::grpc::Slice slice;\n      const uint8_t* buf = mb.ReleaseRaw(size, offset, slice);\n      TEST_ASSERT_FUNC(verify(buf, offset, m1_name(), m1_color()));\n    }\n  }\n\n  static void builder_reusable_after_release_and_move_assign_test(\n      TestSelector selector) {\n    if (!selector.count(REUSABLE_AFTER_RELEASE_AND_MOVE_ASSIGN)) {\n      return;\n    }\n\n    // FIXME: Release-move_assign loop fails assert(p ==\n    // GRPC_SLICE_START_PTR(slice_)) in DetachedBuffer destructor after all the\n    // iterations\n\n    flatbuffers::grpc::MessageBuilder dst;\n    std::vector buffers;\n\n    for (int i = 0; i < 2; ++i) {\n      auto root_offset1 = populate1(dst);\n      dst.Finish(root_offset1);\n      buffers.push_back(dst.Release());\n      TEST_ASSERT_FUNC(verify(buffers[i], m1_name(), m1_color()));\n\n      // bring dst back to life.\n      SrcBuilder src;\n      dst = std::move(src);\n      TEST_EQ_FUNC(dst.GetSize(), 0);\n      TEST_EQ_FUNC(src.GetSize(), 0);\n    }\n  }\n\n  static void builder_reusable_after_release_message_and_move_assign_test(\n      TestSelector selector) {\n    if (!selector.count(REUSABLE_AFTER_RELEASE_MESSAGE_AND_MOVE_ASSIGN)) {\n      return;\n    }\n\n    flatbuffers::grpc::MessageBuilder dst;\n    std::vector> buffers;\n\n    for (int i = 0; i < 5; ++i) {\n      auto root_offset1 = populate1(dst);\n      dst.Finish(root_offset1);\n      buffers.push_back(dst.ReleaseMessage());\n      TEST_ASSERT_FUNC(verify(buffers[i], m1_name(), m1_color()));\n\n      // bring dst back to life.\n      SrcBuilder src;\n      dst = std::move(src);\n      TEST_EQ_FUNC(dst.GetSize(), 0);\n      TEST_EQ_FUNC(src.GetSize(), 0);\n    }\n  }\n\n  static void builder_reusable_after_releaseraw_and_move_assign_test(\n      TestSelector selector) {\n    if (!selector.count(REUSABLE_AFTER_RELEASE_RAW_AND_MOVE_ASSIGN)) {\n      return;\n    }\n\n    flatbuffers::grpc::MessageBuilder dst;\n    for (int i = 0; i < 5; ++i) {\n      auto root_offset1 = populate1(dst);\n      dst.Finish(root_offset1);\n      size_t size, offset;\n      ::grpc::Slice slice;\n      const uint8_t* buf = dst.ReleaseRaw(size, offset, slice);\n      TEST_ASSERT_FUNC(verify(buf, offset, m1_name(), m1_color()));\n\n      SrcBuilder src;\n      dst = std::move(src);\n      TEST_EQ_FUNC(dst.GetSize(), 0);\n      TEST_EQ_FUNC(src.GetSize(), 0);\n    }\n  }\n\n  static void run_tests(TestSelector selector) {\n    builder_reusable_after_release_test(selector);\n    builder_reusable_after_release_message_test(selector);\n    builder_reusable_after_releaseraw_test(selector);\n    builder_reusable_after_release_and_move_assign_test(selector);\n    builder_reusable_after_releaseraw_and_move_assign_test(selector);\n    builder_reusable_after_release_message_and_move_assign_test(selector);\n  }\n};\n\nvoid slice_allocator_tests() {\n  // move-construct no-delete test\n  {\n    size_t size = 2048;\n    flatbuffers::grpc::SliceAllocator sa1;\n    uint8_t* buf = sa1.allocate(size);\n    TEST_ASSERT_FUNC(buf != 0);\n    buf[0] = 100;\n    buf[size - 1] = 200;\n    flatbuffers::grpc::SliceAllocator sa2(std::move(sa1));\n    // buf should not be deleted after move-construct\n    TEST_EQ_FUNC(buf[0], 100);\n    TEST_EQ_FUNC(buf[size - 1], 200);\n    // buf is freed here\n  }\n\n  // move-assign test\n  {\n    flatbuffers::grpc::SliceAllocator sa1, sa2;\n    uint8_t* buf = sa1.allocate(2048);\n    sa1 = std::move(sa2);\n    // sa1 deletes previously allocated memory in move-assign.\n    // So buf is no longer usable here.\n    TEST_ASSERT_FUNC(buf != 0);\n  }\n}\n\n/// This function does not populate exactly the first half of the table. But it\n/// could.\nvoid populate_first_half(MyGame::Example::MonsterBuilder& wrapper,\n                         flatbuffers::Offset name_offset) {\n  wrapper.add_name(name_offset);\n  wrapper.add_color(m1_color());\n}\n\n/// This function does not populate exactly the second half of the table. But it\n/// could.\nvoid populate_second_half(MyGame::Example::MonsterBuilder& wrapper) {\n  wrapper.add_hp(77);\n  wrapper.add_mana(88);\n  Vec3 vec3;\n  wrapper.add_pos(&vec3);\n}\n\n/// This function is a hack to update the FlatBufferBuilder reference (fbb_) in\n/// the MonsterBuilder object. This function will break if fbb_ is not the first\n/// member in MonsterBuilder. In that case, some offset must be added. This\n/// function is used exclusively for testing correctness of move operations\n/// between FlatBufferBuilders. If MonsterBuilder had a fbb_ pointer, this hack\n/// would be unnecessary. That involves a code-generator change though.\nvoid test_only_hack_update_fbb_reference(\n    MyGame::Example::MonsterBuilder& monsterBuilder,\n    flatbuffers::grpc::MessageBuilder& mb) {\n  *reinterpret_cast(&monsterBuilder) = &mb;\n}\n\n/// This test validates correctness of move conversion of FlatBufferBuilder to a\n/// MessageBuilder DURING a table construction. Half of the table is constructed\n/// using FlatBufferBuilder and the other half of the table is constructed using\n/// a MessageBuilder.\nvoid builder_move_ctor_conversion_before_finish_half_n_half_table_test() {\n  for (size_t initial_size = 4; initial_size <= 2048; initial_size *= 2) {\n    flatbuffers::FlatBufferBuilder fbb(initial_size);\n    auto name_offset = fbb.CreateString(m1_name());\n    MyGame::Example::MonsterBuilder monsterBuilder(\n        fbb);  // starts a table in FlatBufferBuilder\n    populate_first_half(monsterBuilder, name_offset);\n    flatbuffers::grpc::MessageBuilder mb(std::move(fbb));\n    test_only_hack_update_fbb_reference(monsterBuilder, mb);  // hack\n    populate_second_half(monsterBuilder);\n    mb.Finish(monsterBuilder.Finish());  // ends the table in MessageBuilder\n    TEST_ASSERT_FUNC(release_n_verify(mb, m1_name(), m1_color()));\n    TEST_EQ_FUNC(fbb.GetSize(), 0);\n  }\n}\n\n/// This test populates a COMPLETE inner table before move conversion and later\n/// populates more members in the outer table.\nvoid builder_move_ctor_conversion_before_finish_test() {\n  for (size_t initial_size = 1; initial_size <= 2048; initial_size += 1) {\n    flatbuffers::FlatBufferBuilder fbb(initial_size);\n    auto stat_offset = CreateStat(fbb, fbb.CreateString(\"SomeId\"), 0, 0);\n    flatbuffers::grpc::MessageBuilder mb(std::move(fbb));\n    auto monster_offset =\n        CreateMonster(mb, 0, 150, 100, mb.CreateString(m1_name()), 0,\n                      m1_color(), Any_NONE, 0, 0, 0, 0, 0, 0, stat_offset);\n    mb.Finish(monster_offset);\n    {\n      auto mon = flatbuffers::GetRoot(mb.GetBufferPointer());\n      TEST_NOTNULL(mon);\n      TEST_NOTNULL(mon->name());\n      TEST_EQ_STR(mon->name()->c_str(), m1_name().c_str());\n      TEST_EQ(mon->color(), m1_color());\n    }\n    TEST_EQ(1, MyGame::Example::Color_Red);\n    TEST_EQ(1, m1_color());\n    TEST_ASSERT_FUNC(release_n_verify(mb, m1_name(), m1_color()));\n    TEST_EQ_FUNC(fbb.GetSize(), 0);\n  }\n}\n\n/// This test validates correctness of move conversion of FlatBufferBuilder to a\n/// MessageBuilder DURING a table construction. Half of the table is constructed\n/// using FlatBufferBuilder and the other half of the table is constructed using\n/// a MessageBuilder.\nvoid builder_move_assign_conversion_before_finish_half_n_half_table_test() {\n  flatbuffers::FlatBufferBuilder fbb;\n  flatbuffers::grpc::MessageBuilder mb;\n\n  for (int i = 0; i < 5; ++i) {\n    flatbuffers::FlatBufferBuilder fbb;\n    auto name_offset = fbb.CreateString(m1_name());\n    MyGame::Example::MonsterBuilder monsterBuilder(\n        fbb);  // starts a table in FlatBufferBuilder\n    populate_first_half(monsterBuilder, name_offset);\n    mb = std::move(fbb);\n    test_only_hack_update_fbb_reference(monsterBuilder, mb);  // hack\n    populate_second_half(monsterBuilder);\n    mb.Finish(monsterBuilder.Finish());  // ends the table in MessageBuilder\n    TEST_ASSERT_FUNC(release_n_verify(mb, m1_name(), m1_color()));\n    TEST_EQ_FUNC(fbb.GetSize(), 0);\n  }\n}\n\n/// This test populates a COMPLETE inner table before move conversion and later\n/// populates more members in the outer table.\nvoid builder_move_assign_conversion_before_finish_test() {\n  flatbuffers::FlatBufferBuilder fbb;\n  flatbuffers::grpc::MessageBuilder mb;\n\n  for (int i = 0; i < 5; ++i) {\n    auto stat_offset = CreateStat(fbb, fbb.CreateString(\"SomeId\"), 0, 0);\n    mb = std::move(fbb);\n    auto monster_offset =\n        CreateMonster(mb, 0, 150, 100, mb.CreateString(m1_name()), 0,\n                      m1_color(), Any_NONE, 0, 0, 0, 0, 0, 0, stat_offset);\n    mb.Finish(monster_offset);\n    TEST_ASSERT_FUNC(release_n_verify(mb, m1_name(), m1_color()));\n    TEST_EQ_FUNC(fbb.GetSize(), 0);\n  }\n}\n\n/// This test populates data, finishes the buffer, and does move conversion\n/// after.\nvoid builder_move_ctor_conversion_after_finish_test() {\n  flatbuffers::FlatBufferBuilder fbb;\n  fbb.Finish(populate1(fbb));\n  flatbuffers::grpc::MessageBuilder mb(std::move(fbb));\n  TEST_ASSERT_FUNC(release_n_verify(mb, m1_name(), m1_color()));\n  TEST_EQ_FUNC(fbb.GetSize(), 0);\n}\n\n/// This test populates data, finishes the buffer, and does move conversion\n/// after.\nvoid builder_move_assign_conversion_after_finish_test() {\n  flatbuffers::FlatBufferBuilder fbb;\n  flatbuffers::grpc::MessageBuilder mb;\n\n  for (int i = 0; i < 5; ++i) {\n    fbb.Finish(populate1(fbb));\n    mb = std::move(fbb);\n    TEST_ASSERT_FUNC(release_n_verify(mb, m1_name(), m1_color()));\n    TEST_EQ_FUNC(fbb.GetSize(), 0);\n  }\n}\n\nvoid message_builder_tests() {\n  using flatbuffers::FlatBufferBuilder;\n  using flatbuffers::grpc::MessageBuilder;\n\n  slice_allocator_tests();\n\n#ifndef __APPLE__\n  builder_move_ctor_conversion_before_finish_half_n_half_table_test();\n  builder_move_assign_conversion_before_finish_half_n_half_table_test();\n#endif  // __APPLE__\n  builder_move_ctor_conversion_before_finish_test();\n  builder_move_assign_conversion_before_finish_test();\n\n  builder_move_ctor_conversion_after_finish_test();\n  builder_move_assign_conversion_after_finish_test();\n\n  BuilderTests::all_tests();\n  BuilderTests::all_tests();\n\n  BuilderReuseTestSelector tests[6] = {\n      // REUSABLE_AFTER_RELEASE,                 // Assertion failed:\n      // (GRPC_SLICE_IS_EMPTY(slice_))\n      // REUSABLE_AFTER_RELEASE_AND_MOVE_ASSIGN, // Assertion failed: (p ==\n      // GRPC_SLICE_START_PTR(slice_)\n\n      REUSABLE_AFTER_RELEASE_RAW, REUSABLE_AFTER_RELEASE_MESSAGE,\n      REUSABLE_AFTER_RELEASE_MESSAGE_AND_MOVE_ASSIGN,\n      REUSABLE_AFTER_RELEASE_RAW_AND_MOVE_ASSIGN};\n\n  BuilderReuseTests::run_tests(\n      TestSelector(tests, tests + 6));\n  BuilderReuseTests::run_tests(\n      TestSelector(tests, tests + 6));\n}\n"
  },
  {
    "path": "grpc/tests/pom.xml",
    "content": "\n    4.0.0\n    \n        com.google.flatbuffers\n        flatbuffers-parent\n        2.0.3\n    \n    grpc-test\n    Example/Test project demonstrating usage of flatbuffers with GRPC-Java instead of protobufs\n    \n    \n        2.0.3\n    \n    \n        \n            com.google.flatbuffers\n            flatbuffers-java\n            ${project.parent.version}\n            test\n        \n        \n            com.google.flatbuffers\n            flatbuffers-java-grpc\n            ${project.parent.version}\n            test\n        \n        \n            io.grpc\n            grpc-stub\n            ${gRPC.version}\n            test\n        \n        \n            io.grpc\n            grpc-netty\n            ${gRPC.version}\n            test\n        \n        \n            junit\n            junit\n            4.13.1\n            test\n        \n    \n\n    \n        \n            \n                org.codehaus.mojo\n                build-helper-maven-plugin\n                \n                    \n                        add-source\n                        generate-sources\n                        \n                            add-test-source\n                        \n                        \n                            \n                                ${project.basedir}\n\t\t\t\t${project.basedir}/../../tests\n                            \n                        \n                    \n                \n            \n        \n        \n    \n\n\n"
  },
  {
    "path": "include/codegen/BUILD.bazel",
    "content": "load(\"@rules_cc//cc:defs.bzl\", \"cc_library\")\n\npackage(\n    default_visibility = [\"//visibility:private\"],\n)\n\nfilegroup(\n    name = \"distribution\",\n    srcs = [\n        \"BUILD.bazel\",\n    ] + glob([\n        \"*.cc\",\n        \"*.h\",\n    ]),\n    visibility = [\"//visibility:public\"],\n)\n\ncc_library(\n    name = \"namer\",\n    hdrs = [\n        \"idl_namer.h\",\n        \"namer.h\",\n    ],\n    strip_include_prefix = \"/include\",\n    visibility = [\"//:__subpackages__\"],\n    deps = [\"//:runtime_cc\"],\n)\n\ncc_library(\n    name = \"python\",\n    srcs = [\"python.cc\"],\n    hdrs = [\"python.h\"],\n    strip_include_prefix = \"/include\",\n    visibility = [\n        \"//grpc:__subpackages__\",\n        \"//src:__subpackages__\",\n    ],\n    deps = [\":namer\"],\n)\n"
  },
  {
    "path": "include/codegen/idl_namer.h",
    "content": "#ifndef FLATBUFFERS_INCLUDE_CODEGEN_IDL_NAMER_H_\n#define FLATBUFFERS_INCLUDE_CODEGEN_IDL_NAMER_H_\n\n#include \"codegen/namer.h\"\n#include \"flatbuffers/idl.h\"\n\nnamespace flatbuffers {\n\n// Provides Namer capabilities to types defined in the flatbuffers IDL.\nclass IdlNamer : public Namer {\n public:\n  explicit IdlNamer(Config config, std::set keywords)\n      : Namer(config, std::move(keywords)) {}\n\n  using Namer::Constant;\n  using Namer::Directories;\n  using Namer::Field;\n  using Namer::File;\n  using Namer::Function;\n  using Namer::Method;\n  using Namer::Namespace;\n  using Namer::NamespacedType;\n  using Namer::ObjectType;\n  using Namer::Type;\n  using Namer::Variable;\n  using Namer::Variant;\n\n  std::string Constant(const FieldDef& d) const { return Constant(d.name); }\n\n  // Types are always structs or enums so we can only expose these two\n  // overloads.\n  std::string Type(const StructDef& d) const { return Type(d.name); }\n  std::string Type(const EnumDef& d) const { return Type(d.name); }\n\n  std::string Function(const Definition& s) const { return Function(s.name); }\n  std::string Function(const std::string& prefix, const Definition& s) const {\n    return Function(prefix + s.name);\n  }\n\n  std::string Field(const FieldDef& s) const { return Field(s.name); }\n  std::string Field(const FieldDef& d, const std::string& s) const {\n    return Field(d.name + \"_\" + s);\n  }\n\n  std::string Variable(const FieldDef& s) const { return Variable(s.name); }\n\n  std::string Variable(const StructDef& s) const { return Variable(s.name); }\n\n  std::string Variant(const EnumVal& s) const { return Variant(s.name); }\n\n  std::string EnumVariant(const EnumDef& e, const EnumVal& v) const {\n    return Type(e) + config_.enum_variant_seperator + Variant(v);\n  }\n\n  std::string ObjectType(const StructDef& d) const {\n    return ObjectType(d.name);\n  }\n  std::string ObjectType(const EnumDef& d) const { return ObjectType(d.name); }\n\n  std::string Method(const FieldDef& d, const std::string& suffix) const {\n    return Method(d.name, suffix);\n  }\n  std::string Method(const std::string& prefix, const StructDef& d) const {\n    return Method(prefix, d.name);\n  }\n  std::string Method(const std::string& prefix, const FieldDef& d) const {\n    return Method(prefix, d.name);\n  }\n  std::string Method(const std::string& prefix, const FieldDef& d,\n                     const std::string& suffix) const {\n    return Method(prefix, d.name, suffix);\n  }\n\n  std::string Namespace(const struct Namespace& ns) const {\n    return Namespace(ns.components);\n  }\n\n  std::string NamespacedEnumVariant(const EnumDef& e, const EnumVal& v) const {\n    return NamespacedString(e.defined_namespace, EnumVariant(e, v));\n  }\n\n  std::string NamespacedType(const Definition& def) const {\n    return NamespacedString(def.defined_namespace, Type(def.name));\n  }\n\n  std::string NamespacedObjectType(const Definition& def) const {\n    return NamespacedString(def.defined_namespace, ObjectType(def.name));\n  }\n\n  std::string Directories(const struct Namespace& ns,\n                          SkipDir skips = SkipDir::None,\n                          Case input_case = Case::kUpperCamel) const {\n    return Directories(ns.components, skips, input_case);\n  }\n\n  // Legacy fields do not really follow the usual config and should be\n  // considered for deprecation.\n\n  std::string LegacyRustNativeVariant(const EnumVal& v) const {\n    return ConvertCase(EscapeKeyword(v.name), Case::kUpperCamel);\n  }\n\n  std::string LegacyRustFieldOffsetName(const FieldDef& field) const {\n    return \"VT_\" + ConvertCase(EscapeKeyword(field.name), Case::kAllUpper);\n  }\n  std::string LegacyRustUnionTypeOffsetName(const FieldDef& field) const {\n    return \"VT_\" +\n           ConvertCase(EscapeKeyword(field.name + \"_type\"), Case::kAllUpper);\n  }\n\n  std::string LegacySwiftVariant(const EnumVal& ev) const {\n    auto name = ev.name;\n    if (isupper(name.front())) {\n      std::transform(name.begin(), name.end(), name.begin(), CharToLower);\n    }\n    return EscapeKeyword(ConvertCase(name, Case::kLowerCamel));\n  }\n\n  // Also used by Kotlin, lol.\n  std::string LegacyJavaMethod2(const std::string& prefix, const StructDef& sd,\n                                const std::string& suffix) const {\n    return prefix + sd.name + suffix;\n  }\n\n  std::string LegacyKotlinVariant(EnumVal& ev) const {\n    // Namer assumes the input case is snake case which is wrong...\n    return ConvertCase(EscapeKeyword(ev.name), Case::kLowerCamel);\n  }\n  // Kotlin methods escapes keywords after case conversion but before\n  // prefixing and suffixing.\n  std::string LegacyKotlinMethod(const std::string& prefix, const FieldDef& d,\n                                 const std::string& suffix) const {\n    return prefix + ConvertCase(EscapeKeyword(d.name), Case::kUpperCamel) +\n           suffix;\n  }\n  std::string LegacyKotlinMethod(const std::string& prefix, const StructDef& d,\n                                 const std::string& suffix) const {\n    return prefix + ConvertCase(EscapeKeyword(d.name), Case::kUpperCamel) +\n           suffix;\n  }\n\n  // This is a mix of snake case and keep casing, when Ts should be using\n  // lower camel case.\n  std::string LegacyTsMutateMethod(const FieldDef& d) {\n    return \"mutate_\" + d.name;\n  }\n\n  std::string LegacyRustUnionTypeMethod(const FieldDef& d) {\n    // assert d is a union\n    // d should convert case but not escape keywords due to historical reasons\n    return ConvertCase(d.name, config_.fields, Case::kLowerCamel) + \"_type\";\n  }\n\n private:\n  std::string NamespacedString(const struct Namespace* ns,\n                               const std::string& str) const {\n    std::string ret;\n    if (ns != nullptr) {\n      ret += Namespace(ns->components);\n    }\n    if (!ret.empty()) ret += config_.namespace_seperator;\n    return ret + str;\n  }\n};\n\n// This is a temporary helper function for code generators to call until all\n// flag-overriding logic into flatc.cpp\ninline Namer::Config WithFlagOptions(const Namer::Config& input,\n                                     const IDLOptions& opts,\n                                     const std::string& path) {\n  Namer::Config result = input;\n  result.object_prefix = opts.object_prefix;\n  result.object_suffix = opts.object_suffix;\n  result.output_path = path;\n  result.filename_suffix = opts.filename_suffix;\n  return result;\n}\n\n}  // namespace flatbuffers\n\n#endif  // FLATBUFFERS_INCLUDE_CODEGEN_IDL_NAMER_H_\n"
  },
  {
    "path": "include/codegen/namer.h",
    "content": "#ifndef FLATBUFFERS_INCLUDE_CODEGEN_NAMER_H_\n#define FLATBUFFERS_INCLUDE_CODEGEN_NAMER_H_\n\n#include \"flatbuffers/util.h\"\n\nnamespace flatbuffers {\n\n// Options for Namer::File.\nenum class SkipFile {\n  None = 0,\n  Suffix = 1,\n  Extension = 2,\n  SuffixAndExtension = 3,\n};\ninline SkipFile operator&(SkipFile a, SkipFile b) {\n  return static_cast(static_cast(a) & static_cast(b));\n}\n// Options for Namer::Directories\nenum class SkipDir {\n  None = 0,\n  // Skip prefixing the -o $output_path.\n  OutputPath = 1,\n  // Skip trailing path seperator.\n  TrailingPathSeperator = 2,\n  OutputPathAndTrailingPathSeparator = 3,\n};\ninline SkipDir operator&(SkipDir a, SkipDir b) {\n  return static_cast(static_cast(a) & static_cast(b));\n}\n\n// `Namer` applies style configuration to symbols in generated code. It manages\n// casing, escapes keywords, and object API naming.\n// TODO: Refactor all code generators to use this.\nclass Namer {\n public:\n  struct Config {\n    // Symbols in code.\n\n    // Case style for flatbuffers-defined types.\n    // e.g. `class TableA {}`\n    Case types;\n    // Case style for flatbuffers-defined constants.\n    // e.g. `uint64_t ENUM_A_MAX`;\n    Case constants;\n    // Case style for flatbuffers-defined methods.\n    // e.g. `class TableA { int field_a(); }`\n    Case methods;\n    // Case style for flatbuffers-defined functions.\n    // e.g. `TableA* get_table_a_root()`;\n    Case functions;\n    // Case style for flatbuffers-defined fields.\n    // e.g. `struct Struct { int my_field; }`\n    Case fields;\n    // Case style for flatbuffers-defined variables.\n    // e.g. `int my_variable = 2`\n    Case variables;\n    // Case style for flatbuffers-defined variants.\n    // e.g. `enum class Enum { MyVariant, }`\n    Case variants;\n    // Seperator for qualified enum names.\n    // e.g. `Enum::MyVariant` uses `::`.\n    std::string enum_variant_seperator;\n\n    // Configures, when formatting code, whether symbols are checked against\n    // keywords and escaped before or after case conversion. It does not make\n    // sense to do so before, but its legacy behavior. :shrug:\n    // TODO(caspern): Deprecate.\n    enum class Escape {\n      BeforeConvertingCase,\n      AfterConvertingCase,\n    };\n    Escape escape_keywords;\n\n    // Namespaces\n\n    // e.g. `namespace my_namespace {}`\n    Case namespaces;\n    // The seperator between namespaces in a namespace path.\n    std::string namespace_seperator;\n\n    // Object API.\n    // Native versions flatbuffers types have this prefix.\n    // e.g. \"\" (it's usually empty string)\n    std::string object_prefix;\n    // Native versions flatbuffers types have this suffix.\n    // e.g. \"T\"\n    std::string object_suffix;\n\n    // Keywords.\n    // Prefix used to escape keywords. It is usually empty string.\n    std::string keyword_prefix;\n    // Suffix used to escape keywords. It is usually \"_\".\n    std::string keyword_suffix;\n    // The casing used for keywords when escaping. For most languages, keywords\n    // are case sensitive. PHP is an instance where some keywords are case\n    // insensitive.\n    enum class KeywordsCasing {\n      CaseSensitive,\n      CaseInsensitive,\n    };\n    KeywordsCasing keywords_casing;\n\n    // Files.\n\n    // Case style for filenames. e.g. `foo_bar_generated.rs`\n    Case filenames;\n    // Case style for directories, e.g. `output_files/foo_bar/baz/`\n    Case directories;\n    // The directory within which we will generate files.\n    std::string output_path;\n    // Suffix for generated file names, e.g. \"_generated\".\n    std::string filename_suffix;\n    // Extension for generated files, e.g. \".cpp\" or \".rs\".\n    std::string filename_extension;\n  };\n  Namer(Config config, std::set keywords)\n      : config_(config), keywords_(std::move(keywords)) {}\n\n  virtual ~Namer() {}\n\n  template \n  std::string Method(const T& s) const {\n    return Method(s.name);\n  }\n\n  virtual std::string Method(const std::string& pre, const std::string& mid,\n                             const std::string& suf) const {\n    return Format(pre + \"_\" + mid + \"_\" + suf, config_.methods);\n  }\n  virtual std::string Method(const std::string& pre,\n                             const std::string& suf) const {\n    return Format(pre + \"_\" + suf, config_.methods);\n  }\n  virtual std::string Method(const std::string& s) const {\n    return Format(s, config_.methods);\n  }\n\n  virtual std::string Constant(const std::string& s) const {\n    return Format(s, config_.constants);\n  }\n\n  virtual std::string Function(const std::string& s) const {\n    return Format(s, config_.functions);\n  }\n\n  virtual std::string Variable(const std::string& s) const {\n    return Format(s, config_.variables);\n  }\n\n  template \n  std::string Variable(const std::string& p, const T& s) const {\n    return Format(p + \"_\" + s.name, config_.variables);\n  }\n  virtual std::string Variable(const std::string& p,\n                               const std::string& s) const {\n    return Format(p + \"_\" + s, config_.variables);\n  }\n\n  virtual std::string Namespace(const std::string& s) const {\n    return Format(s, config_.namespaces);\n  }\n\n  virtual std::string Namespace(const std::vector& ns) const {\n    std::string result;\n    for (auto it = ns.begin(); it != ns.end(); it++) {\n      if (it != ns.begin()) result += config_.namespace_seperator;\n      result += Namespace(*it);\n    }\n    return result;\n  }\n\n  virtual std::string NamespacedType(const std::vector& ns,\n                                     const std::string& s) const {\n    return (ns.empty() ? \"\" : (Namespace(ns) + config_.namespace_seperator)) +\n           Type(s);\n  }\n\n  // Returns `filename` with the right casing, suffix, and extension.\n  virtual std::string File(const std::string& filename,\n                           SkipFile skips = SkipFile::None) const {\n    const bool skip_suffix = (skips & SkipFile::Suffix) != SkipFile::None;\n    const bool skip_ext = (skips & SkipFile::Extension) != SkipFile::None;\n    return ConvertCase(filename, config_.filenames, Case::kUpperCamel) +\n           (skip_suffix ? \"\" : config_.filename_suffix) +\n           (skip_ext ? \"\" : config_.filename_extension);\n  }\n  template \n  std::string File(const T& f, SkipFile skips = SkipFile::None) const {\n    return File(f.name, skips);\n  }\n\n  // Formats `directories` prefixed with the output_path and joined with the\n  // right seperator. Output path prefixing and the trailing separator may be\n  // skiped using `skips`.\n  // Callers may want to use `EnsureDirExists` with the result.\n  // input_case is used to tell how to modify namespace. e.g. kUpperCamel will\n  // add a underscode between case changes, so MyGame turns into My_Game\n  // (depending also on the output_case).\n  virtual std::string Directories(const std::vector& directories,\n                                  SkipDir skips = SkipDir::None,\n                                  Case input_case = Case::kUpperCamel) const {\n    const bool skip_output_path =\n        (skips & SkipDir::OutputPath) != SkipDir::None;\n    const bool skip_trailing_seperator =\n        (skips & SkipDir::TrailingPathSeperator) != SkipDir::None;\n    std::string result = skip_output_path ? \"\" : config_.output_path;\n    for (auto d = directories.begin(); d != directories.end(); d++) {\n      result += ConvertCase(*d, config_.directories, input_case);\n      result.push_back(kPathSeparator);\n    }\n    if (skip_trailing_seperator && !result.empty()) result.pop_back();\n    return result;\n  }\n\n  virtual std::string NormalizeKeywordCase(const std::string& name) const {\n    if (config_.keywords_casing == Config::KeywordsCasing::CaseInsensitive) {\n      return ConvertCase(name, Case::kAllLower);\n    } else {\n      return name;\n    }\n  }\n\n  virtual std::string EscapeKeyword(const std::string& name) const {\n    if (keywords_.find(NormalizeKeywordCase(name)) == keywords_.end()) {\n      return name;\n    } else {\n      return config_.keyword_prefix + name + config_.keyword_suffix;\n    }\n  }\n\n  virtual std::string Type(const std::string& s) const {\n    return Format(s, config_.types);\n  }\n  virtual std::string Type(const std::string& t, const std::string& s) const {\n    return Format(t + \"_\" + s, config_.types);\n  }\n\n  virtual std::string ObjectType(const std::string& s) const {\n    return config_.object_prefix + Type(s) + config_.object_suffix;\n  }\n\n  virtual std::string Field(const std::string& s) const {\n    return Format(s, config_.fields);\n  }\n\n  virtual std::string Variant(const std::string& s) const {\n    return Format(s, config_.variants);\n  }\n\n  virtual std::string Format(const std::string& s, Case casing) const {\n    if (config_.escape_keywords == Config::Escape::BeforeConvertingCase) {\n      return ConvertCase(EscapeKeyword(s), casing, Case::kLowerCamel);\n    } else {\n      return EscapeKeyword(ConvertCase(s, casing, Case::kLowerCamel));\n    }\n  }\n\n  // Denamespaces a string (e.g. The.Quick.Brown.Fox) by returning the last part\n  // after the `delimiter` (Fox) and placing the rest in `namespace_prefix`\n  // (The.Quick.Brown).\n  virtual std::string Denamespace(const std::string& s,\n                                  std::string& namespace_prefix,\n                                  const char delimiter = '.') const {\n    const size_t pos = s.find_last_of(delimiter);\n    if (pos == std::string::npos) {\n      namespace_prefix = \"\";\n      return s;\n    }\n    namespace_prefix = s.substr(0, pos);\n    return s.substr(pos + 1);\n  }\n\n  // Same as above, but disregards the prefix.\n  virtual std::string Denamespace(const std::string& s,\n                                  const char delimiter = '.') const {\n    std::string prefix;\n    return Denamespace(s, prefix, delimiter);\n  }\n\n  const Config config_;\n  const std::set keywords_;\n};\n\n}  // namespace flatbuffers\n\n#endif  // FLATBUFFERS_INCLUDE_CODEGEN_NAMER_H_\n"
  },
  {
    "path": "include/codegen/python.cc",
    "content": "#include \"codegen/python.h\"\n\n#include \n#include \n#include \n#include \n\nnamespace flatbuffers {\nnamespace python {\nVersion::Version(const std::string& version) {\n  std::stringstream ss(version);\n  char dot;\n  ss >> major >> dot >> minor >> dot >> micro;\n}\n\nbool Version::IsValid() const {\n  return (major == 0 || major == 2 || major == 3) && minor >= 0 && micro >= 0;\n}\n\nstd::set Keywords(const Version& version) {\n  switch (version.major) {\n    case 2:\n      // https://docs.python.org/2/reference/lexical_analysis.html#keywords\n      return {\n          \"and\",   \"as\",     \"assert\", \"break\",  \"class\", \"continue\", \"def\",\n          \"del\",   \"elif\",   \"else\",   \"except\", \"exec\",  \"finally\",  \"for\",\n          \"from\",  \"global\", \"if\",     \"import\", \"in\",    \"is\",       \"lambda\",\n          \"not\",   \"or\",     \"pass\",   \"print\",  \"raise\", \"return\",   \"try\",\n          \"while\", \"with\",   \"yield\",\n      };\n    case 0:\n    case 3:\n      // https://docs.python.org/3/reference/lexical_analysis.html#keywords\n      return {\n          \"and\",      \"as\",       \"assert\",  \"async\", \"await\",  \"break\",\n          \"class\",    \"continue\", \"def\",     \"del\",   \"elif\",   \"else\",\n          \"except\",   \"False\",    \"finally\", \"for\",   \"from\",   \"global\",\n          \"if\",       \"import\",   \"in\",      \"is\",    \"lambda\", \"None\",\n          \"nonlocal\", \"not\",      \"or\",      \"pass\",  \"raise\",  \"return\",\n          \"True\",     \"try\",      \"while\",   \"with\",  \"yield\",\n      };\n    default:\n      return {};\n  }\n}\n\nconst python::Import& python::Imports::Import(const std::string& module) {\n  python::Import import;\n  import.module = module;\n  imports.push_back(std::move(import));\n  return imports.back();\n}\n\nconst python::Import& python::Imports::Import(const std::string& module,\n                                              const std::string& name) {\n  python::Import import;\n  import.module = module;\n  import.name = name;\n  imports.push_back(std::move(import));\n  return imports.back();\n}\n\nconst python::Import& python::Imports::Export(const std::string& module) {\n  python::Import import;\n  import.module = module;\n  exports.push_back(std::move(import));\n  return exports.back();\n}\n\nconst python::Import& python::Imports::Export(const std::string& module,\n                                              const std::string& name) {\n  python::Import import;\n  import.module = module;\n  import.name = name;\n  exports.push_back(std::move(import));\n  return exports.back();\n}\n}  // namespace python\n}  // namespace flatbuffers\n"
  },
  {
    "path": "include/codegen/python.h",
    "content": "#ifndef FLATBUFFERS_INCLUDE_CODEGEN_PYTHON_H_\n#define FLATBUFFERS_INCLUDE_CODEGEN_PYTHON_H_\n\n#include \n#include \n#include \n#include \n\n#include \"codegen/namer.h\"\n\nnamespace flatbuffers {\nnamespace python {\nstatic const Namer::Config kConfig = {\n    /*types=*/Case::kKeep,\n    /*constants=*/Case::kScreamingSnake,\n    /*methods=*/Case::kUpperCamel,\n    /*functions=*/Case::kUpperCamel,\n    /*fields=*/Case::kLowerCamel,\n    /*variable=*/Case::kLowerCamel,\n    /*variants=*/Case::kKeep,\n    /*enum_variant_seperator=*/\".\",\n    /*escape_keywords=*/Namer::Config::Escape::AfterConvertingCase,\n    /*namespaces=*/Case::kKeep,  // Packages in python.\n    /*namespace_seperator=*/\".\",\n    /*object_prefix=*/\"\",\n    /*object_suffix=*/\"T\",\n    /*keyword_prefix=*/\"\",\n    /*keyword_suffix=*/\"_\",\n    /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,\n    /*filenames=*/Case::kKeep,\n    /*directories=*/Case::kKeep,\n    /*output_path=*/\"\",\n    /*filename_suffix=*/\"\",\n    /*filename_extension=*/\".py\",\n};\n\nstatic const Namer::Config kStubConfig = {\n    /*types=*/Case::kKeep,\n    /*constants=*/Case::kScreamingSnake,\n    /*methods=*/Case::kUpperCamel,\n    /*functions=*/Case::kUpperCamel,\n    /*fields=*/Case::kLowerCamel,\n    /*variables=*/Case::kLowerCamel,\n    /*variants=*/Case::kKeep,\n    /*enum_variant_seperator=*/\".\",\n    /*escape_keywords=*/Namer::Config::Escape::AfterConvertingCase,\n    /*namespaces=*/Case::kKeep,  // Packages in python.\n    /*namespace_seperator=*/\".\",\n    /*object_prefix=*/\"\",\n    /*object_suffix=*/\"T\",\n    /*keyword_prefix=*/\"\",\n    /*keyword_suffix=*/\"_\",\n    /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,\n    /*filenames=*/Case::kKeep,\n    /*directories=*/Case::kKeep,\n    /*output_path=*/\"\",\n    /*filename_suffix=*/\"\",\n    /*filename_extension=*/\".pyi\",\n};\n\n// `Version` represent a Python version.\n//\n// The zero value (i.e. `Version{}`) represents both Python2 and Python3.\n//\n// https://docs.python.org/3/faq/general.html#how-does-the-python-version-numbering-scheme-work\nstruct Version {\n  explicit Version(const std::string& version);\n\n  bool IsValid() const;\n\n  int16_t major = 0;\n  int16_t minor = 0;\n  int16_t micro = 0;\n};\n\nstd::set Keywords(const Version& version);\n\nstruct Import {\n  bool IsLocal() const { return module == \".\"; }\n\n  std::string module;\n  std::string name;\n};\n\nstruct Imports {\n  const python::Import& Import(const std::string& module);\n  const python::Import& Import(const std::string& module,\n                               const std::string& name);\n\n  const python::Import& Export(const std::string& module);\n  const python::Import& Export(const std::string& module,\n                               const std::string& name);\n\n  std::vector imports;\n  std::vector exports;\n};\n}  // namespace python\n}  // namespace flatbuffers\n\n#endif  // FLATBUFFERS_INCLUDE_CODEGEN_PYTHON_H_\n"
  },
  {
    "path": "include/flatbuffers/allocator.h",
    "content": "/*\n * Copyright 2021 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef FLATBUFFERS_ALLOCATOR_H_\n#define FLATBUFFERS_ALLOCATOR_H_\n\n#include \"flatbuffers/base.h\"\n\nnamespace flatbuffers {\n\n// Allocator interface. This is flatbuffers-specific and meant only for\n// `vector_downward` usage.\nclass Allocator {\n public:\n  virtual ~Allocator() {}\n\n  // Allocate `size` bytes of memory.\n  virtual uint8_t* allocate(size_t size) = 0;\n\n  // Deallocate `size` bytes of memory at `p` allocated by this allocator.\n  virtual void deallocate(uint8_t* p, size_t size) = 0;\n\n  // Reallocate `new_size` bytes of memory, replacing the old region of size\n  // `old_size` at `p`. In contrast to a normal realloc, this grows downwards,\n  // and is intended specifcally for `vector_downward` use.\n  // `in_use_back` and `in_use_front` indicate how much of `old_size` is\n  // actually in use at each end, and needs to be copied.\n  virtual uint8_t* reallocate_downward(uint8_t* old_p, size_t old_size,\n                                       size_t new_size, size_t in_use_back,\n                                       size_t in_use_front) {\n    FLATBUFFERS_ASSERT(new_size > old_size);  // vector_downward only grows\n    uint8_t* new_p = allocate(new_size);\n    memcpy_downward(old_p, old_size, new_p, new_size, in_use_back,\n                    in_use_front);\n    deallocate(old_p, old_size);\n    return new_p;\n  }\n\n protected:\n  // Called by `reallocate_downward` to copy memory from `old_p` of `old_size`\n  // to `new_p` of `new_size`. Only memory of size `in_use_front` and\n  // `in_use_back` will be copied from the front and back of the old memory\n  // allocation.\n  void memcpy_downward(uint8_t* old_p, size_t old_size, uint8_t* new_p,\n                       size_t new_size, size_t in_use_back,\n                       size_t in_use_front) {\n    memcpy(new_p + new_size - in_use_back, old_p + old_size - in_use_back,\n           in_use_back);\n    memcpy(new_p, old_p, in_use_front);\n  }\n};\n\n}  // namespace flatbuffers\n\n#endif  // FLATBUFFERS_ALLOCATOR_H_\n"
  },
  {
    "path": "include/flatbuffers/array.h",
    "content": "/*\n * Copyright 2021 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef FLATBUFFERS_ARRAY_H_\n#define FLATBUFFERS_ARRAY_H_\n\n#include \n#include \n\n#include \"flatbuffers/base.h\"\n#include \"flatbuffers/stl_emulation.h\"\n#include \"flatbuffers/vector.h\"\n\nnamespace flatbuffers {\n\n// This is used as a helper type for accessing arrays.\ntemplate \nclass Array {\n  // Array can carry only POD data types (scalars or structs).\n  typedef typename flatbuffers::bool_constant::value>\n      scalar_tag;\n\n public:\n  typedef uint16_t size_type;\n  typedef typename IndirectHelper::return_type return_type;\n  typedef VectorConstIterator const_iterator;\n  typedef VectorReverseIterator const_reverse_iterator;\n\n  // If T is a non-pointer and a LE-scalar or a struct (!scalar_tag::value).\n  static FLATBUFFERS_CONSTEXPR bool is_span_observable =\n      !std::is_pointer::value &&\n      ((scalar_tag::value && (FLATBUFFERS_LITTLEENDIAN || sizeof(T) == 1)) ||\n       !scalar_tag::value);\n\n  FLATBUFFERS_CONSTEXPR uint16_t size() const { return length; }\n\n  return_type Get(uoffset_t i) const {\n    FLATBUFFERS_ASSERT(i < size());\n    return IndirectHelper::Read(Data(), i);\n  }\n\n  return_type operator[](uoffset_t i) const { return Get(i); }\n\n  // If this is a Vector of enums, T will be its storage type, not the enum\n  // type. This function makes it convenient to retrieve value with enum\n  // type E.\n  template \n  E GetEnum(uoffset_t i) const {\n    return static_cast(Get(i));\n  }\n\n  const_iterator begin() const { return const_iterator(Data(), 0); }\n  const_iterator end() const { return const_iterator(Data(), size()); }\n\n  const_reverse_iterator rbegin() const {\n    return const_reverse_iterator(end());\n  }\n  const_reverse_iterator rend() const {\n    return const_reverse_iterator(begin());\n  }\n\n  const_iterator cbegin() const { return begin(); }\n  const_iterator cend() const { return end(); }\n\n  const_reverse_iterator crbegin() const { return rbegin(); }\n  const_reverse_iterator crend() const { return rend(); }\n\n  // Get a mutable pointer to elements inside this array.\n  // This method used to mutate arrays of structs followed by a @p Mutate\n  // operation. For primitive types use @p Mutate directly.\n  // @warning Assignments and reads to/from the dereferenced pointer are not\n  //  automatically converted to the correct endianness.\n  typename flatbuffers::conditional::type\n  GetMutablePointer(uoffset_t i) const {\n    FLATBUFFERS_ASSERT(i < size());\n    return const_cast(&data()[i]);\n  }\n\n  // Change elements if you have a non-const pointer to this object.\n  void Mutate(uoffset_t i, const T& val) { MutateImpl(scalar_tag(), i, val); }\n\n  // The raw data in little endian format. Use with care.\n  const uint8_t* Data() const { return data_; }\n\n  uint8_t* Data() { return data_; }\n\n  // Similarly, but typed, much like std::vector::data\n  const T* data() const { return reinterpret_cast(Data()); }\n  T* data() { return reinterpret_cast(Data()); }\n\n  // Copy data from a span with endian conversion.\n  // If this Array and the span overlap, the behavior is undefined.\n  void CopyFromSpan(flatbuffers::span src) {\n    const auto p1 = reinterpret_cast(src.data());\n    const auto p2 = Data();\n    FLATBUFFERS_ASSERT(!(p1 >= p2 && p1 < (p2 + length)) &&\n                       !(p2 >= p1 && p2 < (p1 + length)));\n    (void)p1;\n    (void)p2;\n    CopyFromSpanImpl(flatbuffers::bool_constant(), src);\n  }\n\n protected:\n  void MutateImpl(flatbuffers::true_type, uoffset_t i, const T& val) {\n    FLATBUFFERS_ASSERT(i < size());\n    WriteScalar(data() + i, val);\n  }\n\n  void MutateImpl(flatbuffers::false_type, uoffset_t i, const T& val) {\n    *(GetMutablePointer(i)) = val;\n  }\n\n  void CopyFromSpanImpl(flatbuffers::true_type,\n                        flatbuffers::span src) {\n    // Use std::memcpy() instead of std::copy() to avoid performance degradation\n    // due to aliasing if T is char or unsigned char.\n    // The size is known at compile time, so memcpy would be inlined.\n    std::memcpy(data(), src.data(), length * sizeof(T));\n  }\n\n  // Copy data from flatbuffers::span with endian conversion.\n  void CopyFromSpanImpl(flatbuffers::false_type,\n                        flatbuffers::span src) {\n    for (size_type k = 0; k < length; k++) {\n      Mutate(k, src[k]);\n    }\n  }\n\n  // This class is only used to access pre-existing data. Don't ever\n  // try to construct these manually.\n  // 'constexpr' allows us to use 'size()' at compile time.\n  // @note Must not use 'FLATBUFFERS_CONSTEXPR' here, as const is not allowed on\n  //  a constructor.\n#if defined(__cpp_constexpr)\n  constexpr Array();\n#else\n  Array();\n#endif\n\n  uint8_t data_[length * sizeof(T)];\n\n private:\n  // This class is a pointer. Copying will therefore create an invalid object.\n  // Private and unimplemented copy constructor.\n  Array(const Array&);\n  Array& operator=(const Array&);\n};\n\n// Specialization for Array[struct] with access using Offset pointer.\n// This specialization used by idl_gen_text.cpp.\ntemplate  class OffsetT>\nclass Array, length> {\n  static_assert(flatbuffers::is_same::value, \"unexpected type T\");\n\n public:\n  typedef const void* return_type;\n  typedef uint16_t size_type;\n\n  const uint8_t* Data() const { return data_; }\n\n  // Make idl_gen_text.cpp::PrintContainer happy.\n  return_type operator[](uoffset_t) const {\n    FLATBUFFERS_ASSERT(false);\n    return nullptr;\n  }\n\n private:\n  // This class is only used to access pre-existing data.\n  Array();\n  Array(const Array&);\n  Array& operator=(const Array&);\n\n  uint8_t data_[1];\n};\n\ntemplate \nFLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span make_span(Array& arr)\n    FLATBUFFERS_NOEXCEPT {\n  static_assert(\n      Array::is_span_observable,\n      \"wrong type U, only plain struct, LE-scalar, or byte types are allowed\");\n  return span(arr.data(), N);\n}\n\ntemplate \nFLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span make_span(\n    const Array& arr) FLATBUFFERS_NOEXCEPT {\n  static_assert(\n      Array::is_span_observable,\n      \"wrong type U, only plain struct, LE-scalar, or byte types are allowed\");\n  return span(arr.data(), N);\n}\n\ntemplate \nFLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span\nmake_bytes_span(Array& arr) FLATBUFFERS_NOEXCEPT {\n  static_assert(Array::is_span_observable,\n                \"internal error, Array might hold only scalars or structs\");\n  return span(arr.Data(), sizeof(U) * N);\n}\n\ntemplate \nFLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span\nmake_bytes_span(const Array& arr) FLATBUFFERS_NOEXCEPT {\n  static_assert(Array::is_span_observable,\n                \"internal error, Array might hold only scalars or structs\");\n  return span(arr.Data(), sizeof(U) * N);\n}\n\n// Cast a raw T[length] to a raw flatbuffers::Array\n// without endian conversion. Use with care.\n// TODO: move these Cast-methods to `internal` namespace.\ntemplate \nArray& CastToArray(T (&arr)[length]) {\n  return *reinterpret_cast*>(arr);\n}\n\ntemplate \nconst Array& CastToArray(const T (&arr)[length]) {\n  return *reinterpret_cast*>(arr);\n}\n\ntemplate \nArray& CastToArrayOfEnum(T (&arr)[length]) {\n  static_assert(sizeof(E) == sizeof(T), \"invalid enum type E\");\n  return *reinterpret_cast*>(arr);\n}\n\ntemplate \nconst Array& CastToArrayOfEnum(const T (&arr)[length]) {\n  static_assert(sizeof(E) == sizeof(T), \"invalid enum type E\");\n  return *reinterpret_cast*>(arr);\n}\n\ntemplate \nbool operator==(const Array& lhs,\n                const Array& rhs) noexcept {\n  return std::addressof(lhs) == std::addressof(rhs) ||\n         (lhs.size() == rhs.size() &&\n          std::memcmp(lhs.Data(), rhs.Data(), rhs.size() * sizeof(T)) == 0);\n}\n\n}  // namespace flatbuffers\n\n#endif  // FLATBUFFERS_ARRAY_H_\n"
  },
  {
    "path": "include/flatbuffers/base.h",
    "content": "#ifndef FLATBUFFERS_BASE_H_\n#define FLATBUFFERS_BASE_H_\n\n// clang-format off\n\n// If activate should be declared and included first.\n#if defined(FLATBUFFERS_MEMORY_LEAK_TRACKING) && \\\n    defined(_MSC_VER) && defined(_DEBUG)\n  // The _CRTDBG_MAP_ALLOC inside  will replace\n  // calloc/free (etc) to its debug version using #define directives.\n  #define _CRTDBG_MAP_ALLOC\n  #include \n  #include \n  // Replace operator new by trace-enabled version.\n  #define DEBUG_NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)\n  #define new DEBUG_NEW\n#endif\n\n#if !defined(FLATBUFFERS_ASSERT)\n#include \n#define FLATBUFFERS_ASSERT assert\n#elif defined(FLATBUFFERS_ASSERT_INCLUDE)\n// Include file with forward declaration\n#include FLATBUFFERS_ASSERT_INCLUDE\n#endif\n\n#ifndef ARDUINO\n#include \n#endif\n\n#include \n#include \n#include \n\n#if defined(ARDUINO) && !defined(ARDUINOSTL_M_H) && defined(__AVR__)\n  #include \n#else\n  #include \n#endif\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#if defined(__unix__) && !defined(FLATBUFFERS_LOCALE_INDEPENDENT)\n  #include \n#endif\n\n#ifdef __ANDROID__\n  #include \n#endif\n\n#if defined(__ICCARM__)\n#include \n#endif\n\n// Note the __clang__ check is needed, because clang presents itself\n// as an older GNUC compiler (4.2).\n// Clang 3.3 and later implement all of the ISO C++ 2011 standard.\n// Clang 3.4 and later implement all of the ISO C++ 2014 standard.\n// http://clang.llvm.org/cxx_status.html\n\n// Note the MSVC value '__cplusplus' may be incorrect:\n// The '__cplusplus' predefined macro in the MSVC stuck at the value 199711L,\n// indicating (erroneously!) that the compiler conformed to the C++98 Standard.\n// This value should be correct starting from MSVC2017-15.7-Preview-3.\n// The '__cplusplus' will be valid only if MSVC2017-15.7-P3 and the `/Zc:__cplusplus` switch is set.\n// Workaround (for details see MSDN):\n// Use the _MSC_VER and _MSVC_LANG definition instead of the __cplusplus  for compatibility.\n// The _MSVC_LANG macro reports the Standard version regardless of the '/Zc:__cplusplus' switch.\n\n#if defined(__GNUC__) && !defined(__clang__)\n  #define FLATBUFFERS_GCC (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)\n#else\n  #define FLATBUFFERS_GCC 0\n#endif\n\n#if defined(__clang__)\n  #define FLATBUFFERS_CLANG (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)\n#else\n  #define FLATBUFFERS_CLANG 0\n#endif\n\n/// @cond FLATBUFFERS_INTERNAL\n#if __cplusplus <= 199711L && \\\n    (!defined(_MSC_VER) || _MSC_VER < 1600) && \\\n    (!defined(__GNUC__) || \\\n      (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ < 40400))\n  #error A C++11 compatible compiler with support for the auto typing is \\\n         required for FlatBuffers.\n  #error __cplusplus _MSC_VER __GNUC__  __GNUC_MINOR__  __GNUC_PATCHLEVEL__\n#endif\n\n#if !defined(__clang__) && \\\n    defined(__GNUC__) && \\\n    (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ < 40600)\n  // Backwards compatibility for g++ 4.4, and 4.5 which don't have the nullptr\n  // and constexpr keywords. Note the __clang__ check is needed, because clang\n  // presents itself as an older GNUC compiler.\n  #ifndef nullptr_t\n    const class nullptr_t {\n    public:\n      template inline operator T*() const { return 0; }\n    private:\n      void operator&() const;\n    } nullptr = {};\n  #endif\n  #ifndef constexpr\n    #define constexpr const\n  #endif\n#endif\n\n// The wire format uses a little endian encoding (since that's efficient for\n// the common platforms).\n#if defined(__s390x__)\n  #define FLATBUFFERS_LITTLEENDIAN 0\n#endif // __s390x__\n#if !defined(FLATBUFFERS_LITTLEENDIAN)\n  #if defined(__GNUC__) || defined(__clang__) || defined(__ICCARM__)\n    #if (defined(__BIG_ENDIAN__) || \\\n         (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))\n      #define FLATBUFFERS_LITTLEENDIAN 0\n    #else\n      #define FLATBUFFERS_LITTLEENDIAN 1\n    #endif // __BIG_ENDIAN__\n  #elif defined(_MSC_VER)\n    #if defined(_M_PPC)\n      #define FLATBUFFERS_LITTLEENDIAN 0\n    #else\n      #define FLATBUFFERS_LITTLEENDIAN 1\n    #endif\n  #else\n    #error Unable to determine endianness, define FLATBUFFERS_LITTLEENDIAN.\n  #endif\n#endif // !defined(FLATBUFFERS_LITTLEENDIAN)\n\n#define FLATBUFFERS_VERSION_MAJOR 25\n#define FLATBUFFERS_VERSION_MINOR 12\n#define FLATBUFFERS_VERSION_REVISION 19\n#define FLATBUFFERS_STRING_EXPAND(X) #X\n#define FLATBUFFERS_STRING(X) FLATBUFFERS_STRING_EXPAND(X)\nnamespace flatbuffers {\n  // Returns version as string  \"MAJOR.MINOR.REVISION\".\n  const char* FLATBUFFERS_VERSION();\n}\n\n#if (!defined(_MSC_VER) || _MSC_VER > 1600) && \\\n    (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 407)) || \\\n    defined(__clang__)\n  #define FLATBUFFERS_FINAL_CLASS final\n  #define FLATBUFFERS_OVERRIDE override\n  #define FLATBUFFERS_EXPLICIT_CPP11 explicit\n  #define FLATBUFFERS_VTABLE_UNDERLYING_TYPE : ::flatbuffers::voffset_t\n#else\n  #define FLATBUFFERS_FINAL_CLASS\n  #define FLATBUFFERS_OVERRIDE\n  #define FLATBUFFERS_EXPLICIT_CPP11\n  #define FLATBUFFERS_VTABLE_UNDERLYING_TYPE\n#endif\n\n#if (!defined(_MSC_VER) || _MSC_VER >= 1900) && \\\n    (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 406)) || \\\n    (defined(__cpp_constexpr) && __cpp_constexpr >= 200704)\n  #define FLATBUFFERS_CONSTEXPR constexpr\n  #define FLATBUFFERS_CONSTEXPR_CPP11 constexpr\n  #define FLATBUFFERS_CONSTEXPR_DEFINED\n#else\n  #define FLATBUFFERS_CONSTEXPR const\n  #define FLATBUFFERS_CONSTEXPR_CPP11\n#endif\n\n#if (defined(__cplusplus) && __cplusplus >= 201402L) || \\\n    (defined(__cpp_constexpr) && __cpp_constexpr >= 201304)\n  #define FLATBUFFERS_CONSTEXPR_CPP14 FLATBUFFERS_CONSTEXPR_CPP11\n#else\n  #define FLATBUFFERS_CONSTEXPR_CPP14\n#endif\n\n#if (defined(__GXX_EXPERIMENTAL_CXX0X__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 406)) || \\\n    (defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 190023026)) || \\\n    defined(__clang__)\n  #define FLATBUFFERS_NOEXCEPT noexcept\n#else\n  #define FLATBUFFERS_NOEXCEPT\n#endif\n\n// NOTE: the FLATBUFFERS_DELETE_FUNC macro may change the access mode to\n// private, so be sure to put it at the end or reset access mode explicitly.\n#if (!defined(_MSC_VER) || _MSC_FULL_VER >= 180020827) && \\\n    (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 404)) || \\\n    defined(__clang__)\n  #define FLATBUFFERS_DELETE_FUNC(func) func = delete\n#else\n  #define FLATBUFFERS_DELETE_FUNC(func) private: func\n#endif\n\n#if (!defined(_MSC_VER) || _MSC_VER >= 1900) && \\\n    (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 409)) || \\\n    defined(__clang__)\n  #define FLATBUFFERS_DEFAULT_DECLARATION\n#endif\n\n// Check if we can use template aliases\n// Not possible if Microsoft Compiler before 2012\n// Possible is the language feature __cpp_alias_templates is defined well\n// Or possible if the C++ std is C+11 or newer\n#if (defined(_MSC_VER) && _MSC_VER > 1700 /* MSVC2012 */) \\\n    || (defined(__cpp_alias_templates) && __cpp_alias_templates >= 200704) \\\n    || (defined(__cplusplus) && __cplusplus >= 201103L)\n  #define FLATBUFFERS_TEMPLATES_ALIASES\n#endif\n\n#ifndef FLATBUFFERS_HAS_STRING_VIEW\n  // Only provide flatbuffers::string_view if __has_include can be used\n  // to detect a header that provides an implementation\n  #if defined(__has_include)\n    // Check for std::string_view (in c++17)\n    #if __has_include() && (__cplusplus >= 201606 || (defined(_HAS_CXX17) && _HAS_CXX17))\n      #include \n      namespace flatbuffers {\n        typedef std::string_view string_view;\n      }\n      #define FLATBUFFERS_HAS_STRING_VIEW 1\n    // Check for std::experimental::string_view (in c++14, compiler-dependent)\n    #elif __has_include() && (__cplusplus >= 201411)\n      #include \n      namespace flatbuffers {\n        typedef std::experimental::string_view string_view;\n      }\n      #define FLATBUFFERS_HAS_STRING_VIEW 1\n    // Check for absl::string_view\n    #elif __has_include(\"absl/strings/string_view.h\") && \\\n          __has_include(\"absl/base/config.h\") && \\\n          (__cplusplus >= 201411)\n      #include \"absl/base/config.h\"\n      #if !defined(ABSL_USES_STD_STRING_VIEW)\n        #include \"absl/strings/string_view.h\"\n        namespace flatbuffers {\n          typedef absl::string_view string_view;\n        }\n        #define FLATBUFFERS_HAS_STRING_VIEW 1\n      #endif\n    #endif\n  #endif // __has_include\n#endif // !FLATBUFFERS_HAS_STRING_VIEW\n\n#ifndef FLATBUFFERS_GENERAL_HEAP_ALLOC_OK\n  // Allow heap allocations to be used\n  #define FLATBUFFERS_GENERAL_HEAP_ALLOC_OK 1\n#endif // !FLATBUFFERS_GENERAL_HEAP_ALLOC_OK\n\n#ifndef FLATBUFFERS_HAS_NEW_STRTOD\n  // Modern (C++11) strtod and strtof functions are available for use.\n  // 1) nan/inf strings as argument of strtod;\n  // 2) hex-float  as argument of  strtod/strtof.\n  #if (defined(_MSC_VER) && _MSC_VER >= 1900) || \\\n      (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 409)) || \\\n      (defined(__clang__))\n    #define FLATBUFFERS_HAS_NEW_STRTOD 1\n  #endif\n#endif // !FLATBUFFERS_HAS_NEW_STRTOD\n\n#ifndef FLATBUFFERS_LOCALE_INDEPENDENT\n  // Enable locale independent functions {strtof_l, strtod_l,strtoll_l,\n  // strtoull_l} on platforms that support them.\n  #if (defined(_MSC_VER) && _MSC_VER >= 1800) || \\\n      (defined(__ANDROID__) && defined(__ANDROID_API__) && __ANDROID_API__>= 26) || \\\n      (defined(_XOPEN_VERSION) && (_XOPEN_VERSION >= 700)) && \\\n      !defined(__Fuchsia__)\n    #define FLATBUFFERS_LOCALE_INDEPENDENT 1\n  #else\n    #define FLATBUFFERS_LOCALE_INDEPENDENT 0\n  #endif\n#endif  // !FLATBUFFERS_LOCALE_INDEPENDENT\n\n// Suppress Undefined Behavior Sanitizer (recoverable only). Usage:\n// - FLATBUFFERS_SUPPRESS_UBSAN(\"undefined\")\n// - FLATBUFFERS_SUPPRESS_UBSAN(\"signed-integer-overflow\")\n#if defined(__clang__) && (__clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >=7))\n  #define FLATBUFFERS_SUPPRESS_UBSAN(type) __attribute__((no_sanitize(type)))\n#elif defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 409)\n  #define FLATBUFFERS_SUPPRESS_UBSAN(type) __attribute__((no_sanitize_undefined))\n#else\n  #define FLATBUFFERS_SUPPRESS_UBSAN(type)\n#endif\n\nnamespace flatbuffers {\n  // This is constexpr function used for checking compile-time constants.\n  // Avoid `#pragma warning(disable: 4127) // C4127: expression is constant`.\n  template FLATBUFFERS_CONSTEXPR inline bool IsConstTrue(T t) {\n    return !!t;\n  }\n}\n\n// Enable C++ attribute [[]] if std:c++17 or higher.\n#if ((__cplusplus >= 201703L) \\\n    || (defined(_MSVC_LANG) &&  (_MSVC_LANG >= 201703L)))\n  // All attributes unknown to an implementation are ignored without causing an error.\n  #define FLATBUFFERS_ATTRIBUTE(attr) attr\n\n  #define FLATBUFFERS_FALLTHROUGH() [[fallthrough]]\n#else\n  #define FLATBUFFERS_ATTRIBUTE(attr)\n\n  #if FLATBUFFERS_CLANG >= 30800\n    #define FLATBUFFERS_FALLTHROUGH() [[clang::fallthrough]]\n  #elif FLATBUFFERS_GCC >= 70300\n    #define FLATBUFFERS_FALLTHROUGH() [[gnu::fallthrough]]\n  #else\n    #define FLATBUFFERS_FALLTHROUGH()\n  #endif\n#endif\n\n/// @endcond\n\n/// @file\nnamespace flatbuffers {\n\n/// @cond FLATBUFFERS_INTERNAL\n// Our default offset / size type, 32bit on purpose on 64bit systems.\n// Also, using a consistent offset type maintains compatibility of serialized\n// offset values between 32bit and 64bit systems.\ntypedef uint32_t uoffset_t;\ntypedef uint64_t uoffset64_t;\n\n// Signed offsets for references that can go in both directions.\ntypedef int32_t soffset_t;\ntypedef int64_t soffset64_t;\n\n// Offset/index used in v-tables, can be changed to uint8_t in\n// format forks to save a bit of space if desired.\ntypedef uint16_t voffset_t;\n\ntypedef uintmax_t largest_scalar_t;\n\n// In 32bits, this evaluates to 2GB - 1\n#define FLATBUFFERS_MAX_BUFFER_SIZE (std::numeric_limits<::flatbuffers::soffset_t>::max)()\n#define FLATBUFFERS_MAX_64_BUFFER_SIZE (std::numeric_limits<::flatbuffers::soffset64_t>::max)()\n\n// The minimum size buffer that can be a valid flatbuffer.\n// Includes the offset to the root table (uoffset_t), the offset to the vtable\n// of the root table (soffset_t), the size of the vtable (uint16_t), and the\n// size of the referring table (uint16_t).\n#define FLATBUFFERS_MIN_BUFFER_SIZE sizeof(::flatbuffers::uoffset_t) + \\\n  sizeof(::flatbuffers::soffset_t) + sizeof(uint16_t) + sizeof(uint16_t)\n\n// We support aligning the contents of buffers up to this size.\n#ifndef FLATBUFFERS_MAX_ALIGNMENT\n  #define FLATBUFFERS_MAX_ALIGNMENT 32\n#endif\n\n/// @brief The length of a FlatBuffer file header.\nstatic const size_t kFileIdentifierLength = 4;\n\ninline bool VerifyAlignmentRequirements(size_t align, size_t min_align = 1) {\n  return (min_align <= align) && (align <= (FLATBUFFERS_MAX_ALIGNMENT)) &&\n         (align & (align - 1)) == 0;  // must be power of 2\n}\n\n#if defined(_MSC_VER)\n  #pragma warning(push)\n  #pragma warning(disable: 4127) // C4127: conditional expression is constant\n#endif\n\ntemplate T EndianSwap(T t) {\n  #if defined(_MSC_VER)\n    #define FLATBUFFERS_BYTESWAP16 _byteswap_ushort\n    #define FLATBUFFERS_BYTESWAP32 _byteswap_ulong\n    #define FLATBUFFERS_BYTESWAP64 _byteswap_uint64\n  #elif defined(__ICCARM__)\n    #define FLATBUFFERS_BYTESWAP16 __REV16\n    #define FLATBUFFERS_BYTESWAP32 __REV\n    #define FLATBUFFERS_BYTESWAP64(x) \\\n       ((__REV(static_cast(x >> 32U))) | (static_cast(__REV(static_cast(x)))) << 32U)\n  #else\n    #if defined(__GNUC__) && __GNUC__ * 100 + __GNUC_MINOR__ < 408 && !defined(__clang__)\n      // __builtin_bswap16 was missing prior to GCC 4.8.\n      #define FLATBUFFERS_BYTESWAP16(x) \\\n        static_cast(__builtin_bswap32(static_cast(x) << 16))\n    #else\n      #define FLATBUFFERS_BYTESWAP16 __builtin_bswap16\n    #endif\n    #define FLATBUFFERS_BYTESWAP32 __builtin_bswap32\n    #define FLATBUFFERS_BYTESWAP64 __builtin_bswap64\n  #endif\n  if (sizeof(T) == 1) {   // Compile-time if-then's.\n    return t;\n  } else if (sizeof(T) == 2) {\n    union { T t; uint16_t i; } u = { t };\n    u.i = FLATBUFFERS_BYTESWAP16(u.i);\n    return u.t;\n  } else if (sizeof(T) == 4) {\n    union { T t; uint32_t i; } u = { t };\n    u.i = FLATBUFFERS_BYTESWAP32(u.i);\n    return u.t;\n  } else if (sizeof(T) == 8) {\n    union { T t; uint64_t i; } u = { t };\n    u.i = FLATBUFFERS_BYTESWAP64(u.i);\n    return u.t;\n  } else {\n    FLATBUFFERS_ASSERT(0);\n    return t;\n  }\n}\n\n#if defined(_MSC_VER)\n  #pragma warning(pop)\n#endif\n\n\ntemplate T EndianScalar(T t) {\n  #if FLATBUFFERS_LITTLEENDIAN\n    return t;\n  #else\n    return EndianSwap(t);\n  #endif\n}\n\ntemplate\n// UBSAN: C++ aliasing type rules, see std::bit_cast<> for details.\nFLATBUFFERS_SUPPRESS_UBSAN(\"alignment\")\nT ReadScalar(const void *p) {\n  return EndianScalar(*reinterpret_cast(p));\n}\n\n// See https://github.com/google/flatbuffers/issues/5950\n\n#if (FLATBUFFERS_GCC >= 100000) && (FLATBUFFERS_GCC < 110000)\n  #pragma GCC diagnostic push\n  #pragma GCC diagnostic ignored \"-Wstringop-overflow\"\n#endif\n\ntemplate\n// UBSAN: C++ aliasing type rules, see std::bit_cast<> for details.\nFLATBUFFERS_SUPPRESS_UBSAN(\"alignment\")\nvoid WriteScalar(void *p, T t) {\n  *reinterpret_cast(p) = EndianScalar(t);\n}\n\ntemplate struct Offset;\ntemplate FLATBUFFERS_SUPPRESS_UBSAN(\"alignment\") void WriteScalar(void *p, Offset t) {\n  *reinterpret_cast(p) = EndianScalar(t.o);\n}\n\n#if (FLATBUFFERS_GCC >= 100000) && (FLATBUFFERS_GCC < 110000)\n  #pragma GCC diagnostic pop\n#endif\n\n// Computes how many bytes you'd have to pad to be able to write an\n// \"scalar_size\" scalar if the buffer had grown to \"buf_size\" (downwards in\n// memory).\nFLATBUFFERS_SUPPRESS_UBSAN(\"unsigned-integer-overflow\")\ninline size_t PaddingBytes(size_t buf_size, size_t scalar_size) {\n  return ((~buf_size) + 1) & (scalar_size - 1);\n}\n\n#if !defined(_MSC_VER)\n  #pragma GCC diagnostic push\n  #pragma GCC diagnostic ignored \"-Wfloat-equal\"\n#endif\n// Generic 'operator==' with conditional specialisations.\n// T e - new value of a scalar field.\n// T def - default of scalar (is known at compile-time).\ntemplate inline bool IsTheSameAs(T e, T def) { return e == def; }\n#if !defined(_MSC_VER)\n  #pragma GCC diagnostic pop\n#endif\n\n#if defined(FLATBUFFERS_NAN_DEFAULTS) && \\\n    defined(FLATBUFFERS_HAS_NEW_STRTOD) && (FLATBUFFERS_HAS_NEW_STRTOD > 0)\n// Like `operator==(e, def)` with weak NaN if T=(float|double).\ntemplate inline bool IsFloatTheSameAs(T e, T def) {\n  return (e == def) || ((def != def) && (e != e));\n}\ntemplate<> inline bool IsTheSameAs(float e, float def) {\n  return IsFloatTheSameAs(e, def);\n}\ntemplate<> inline bool IsTheSameAs(double e, double def) {\n  return IsFloatTheSameAs(e, def);\n}\n#endif\n\n// Check 'v' is out of closed range [low; high].\n// Workaround for GCC warning [-Werror=type-limits]:\n// comparison is always true due to limited range of data type.\ntemplate\ninline bool IsOutRange(const T &v, const T &low, const T &high) {\n  return (v < low) || (high < v);\n}\n\n// Check 'v' is in closed range [low; high].\ntemplate\ninline bool IsInRange(const T &v, const T &low, const T &high) {\n  return !IsOutRange(v, low, high);\n}\n\n}  // namespace flatbuffers\n#endif  // FLATBUFFERS_BASE_H_\n"
  },
  {
    "path": "include/flatbuffers/buffer.h",
    "content": "/*\n * Copyright 2021 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef FLATBUFFERS_BUFFER_H_\n#define FLATBUFFERS_BUFFER_H_\n\n#include \n\n#include \"flatbuffers/base.h\"\n#include \"flatbuffers/stl_emulation.h\"\n\nnamespace flatbuffers {\n\n// Wrapper for uoffset_t to allow safe template specialization.\n// Value is allowed to be 0 to indicate a null object (see e.g. AddOffset).\ntemplate \nstruct Offset {\n  // The type of offset to use.\n  typedef uoffset_t offset_type;\n\n  offset_type o;\n  Offset() : o(0) {}\n  Offset(const offset_type _o) : o(_o) {}\n  Offset<> Union() const { return o; }\n  bool IsNull() const { return !o; }\n};\n\ntemplate \nstruct is_specialisation_of_Offset : false_type {};\ntemplate \nstruct is_specialisation_of_Offset> : true_type {};\n\n// Wrapper for uoffset64_t Offsets.\ntemplate \nstruct Offset64 {\n  // The type of offset to use.\n  typedef uoffset64_t offset_type;\n\n  offset_type o;\n  Offset64() : o(0) {}\n  Offset64(const offset_type offset) : o(offset) {}\n  Offset64<> Union() const { return o; }\n  bool IsNull() const { return !o; }\n};\n\ntemplate \nstruct is_specialisation_of_Offset64 : false_type {};\ntemplate \nstruct is_specialisation_of_Offset64> : true_type {};\n\n// Litmus check for ensuring the Offsets are the expected size.\nstatic_assert(sizeof(Offset<>) == 4, \"Offset has wrong size\");\nstatic_assert(sizeof(Offset64<>) == 8, \"Offset64 has wrong size\");\n\ninline void EndianCheck() {\n  int endiantest = 1;\n  // If this fails, see FLATBUFFERS_LITTLEENDIAN above.\n  FLATBUFFERS_ASSERT(*reinterpret_cast(&endiantest) ==\n                     FLATBUFFERS_LITTLEENDIAN);\n  (void)endiantest;\n}\n\ntemplate \nFLATBUFFERS_CONSTEXPR size_t AlignOf() {\n  // clang-format off\n  #ifdef _MSC_VER\n    return __alignof(T);\n  #else\n    #ifndef alignof\n      return __alignof__(T);\n    #else\n      return alignof(T);\n    #endif\n  #endif\n  // clang-format on\n}\n\n// Lexicographically compare two strings (possibly containing nulls), and\n// return true if the first is less than the second.\nstatic inline bool StringLessThan(const char* a_data, uoffset_t a_size,\n                                  const char* b_data, uoffset_t b_size) {\n  const auto cmp = memcmp(a_data, b_data, (std::min)(a_size, b_size));\n  return cmp == 0 ? a_size < b_size : cmp < 0;\n}\n\n// When we read serialized data from memory, in the case of most scalars,\n// we want to just read T, but in the case of Offset, we want to actually\n// perform the indirection and return a pointer.\n// The template specialization below does just that.\n// It is wrapped in a struct since function templates can't overload on the\n// return type like this.\n// The typedef is for the convenience of callers of this function\n// (avoiding the need for a trailing return decltype)\ntemplate \nstruct IndirectHelper {\n  typedef T return_type;\n  typedef T mutable_return_type;\n  static const size_t element_stride = sizeof(T);\n\n  static return_type Read(const uint8_t* p, const size_t i) {\n    return EndianScalar((reinterpret_cast(p))[i]);\n  }\n  static mutable_return_type Read(uint8_t* p, const size_t i) {\n    return reinterpret_cast(\n        Read(const_cast(p), i));\n  }\n};\n\n// For vector of Offsets.\ntemplate  class OffsetT>\nstruct IndirectHelper> {\n  typedef const T* return_type;\n  typedef T* mutable_return_type;\n  typedef typename OffsetT::offset_type offset_type;\n  static const offset_type element_stride = sizeof(offset_type);\n\n  static return_type Read(const uint8_t* const p, const offset_type i) {\n    // Offsets are relative to themselves, so first update the pointer to\n    // point to the offset location.\n    const uint8_t* const offset_location = p + i * element_stride;\n\n    // Then read the scalar value of the offset (which may be 32 or 64-bits) and\n    // then determine the relative location from the offset location.\n    return reinterpret_cast(\n        offset_location + ReadScalar(offset_location));\n  }\n  static mutable_return_type Read(uint8_t* const p, const offset_type i) {\n    // Offsets are relative to themselves, so first update the pointer to\n    // point to the offset location.\n    uint8_t* const offset_location = p + i * element_stride;\n\n    // Then read the scalar value of the offset (which may be 32 or 64-bits) and\n    // then determine the relative location from the offset location.\n    return reinterpret_cast(\n        offset_location + ReadScalar(offset_location));\n  }\n};\n\n// For vector of structs.\ntemplate \nstruct IndirectHelper<\n    T, typename std::enable_if<\n           !std::is_scalar::type>::value &&\n           !is_specialisation_of_Offset::value &&\n           !is_specialisation_of_Offset64::value>::type> {\n private:\n  typedef typename std::remove_pointer::type>::type\n      pointee_type;\n\n public:\n  typedef const pointee_type* return_type;\n  typedef pointee_type* mutable_return_type;\n  static const size_t element_stride = sizeof(pointee_type);\n\n  static return_type Read(const uint8_t* const p, const size_t i) {\n    // Structs are stored inline, relative to the first struct pointer.\n    return reinterpret_cast(p + i * element_stride);\n  }\n  static mutable_return_type Read(uint8_t* const p, const size_t i) {\n    // Structs are stored inline, relative to the first struct pointer.\n    return reinterpret_cast(p + i * element_stride);\n  }\n};\n\n/// @brief Get a pointer to the file_identifier section of the buffer.\n/// @return Returns a const char pointer to the start of the file_identifier\n/// characters in the buffer.  The returned char * has length\n/// 'flatbuffers::FlatBufferBuilder::kFileIdentifierLength'.\n/// This function is UNDEFINED for FlatBuffers whose schema does not include\n/// a file_identifier (likely points at padding or the start of a the root\n/// vtable).\ninline const char* GetBufferIdentifier(const void* buf,\n                                       bool size_prefixed = false) {\n  return reinterpret_cast(buf) +\n         ((size_prefixed) ? 2 * sizeof(uoffset_t) : sizeof(uoffset_t));\n}\n\n// Helper to see if the identifier in a buffer has the expected value.\ninline bool BufferHasIdentifier(const void* buf, const char* identifier,\n                                bool size_prefixed = false) {\n  return strncmp(GetBufferIdentifier(buf, size_prefixed), identifier,\n                 flatbuffers::kFileIdentifierLength) == 0;\n}\n\n/// @cond FLATBUFFERS_INTERNAL\n// Helpers to get a typed pointer to the root object contained in the buffer.\ntemplate \nT* GetMutableRoot(void* buf) {\n  if (!buf) return nullptr;\n  EndianCheck();\n  return reinterpret_cast(reinterpret_cast(buf) +\n                              EndianScalar(*reinterpret_cast(buf)));\n}\n\ntemplate \nT* GetMutableSizePrefixedRoot(void* buf) {\n  return GetMutableRoot(reinterpret_cast(buf) + sizeof(SizeT));\n}\n\ntemplate \nconst T* GetRoot(const void* buf) {\n  return GetMutableRoot(const_cast(buf));\n}\n\ntemplate \nconst T* GetSizePrefixedRoot(const void* buf) {\n  return GetRoot(reinterpret_cast(buf) + sizeof(SizeT));\n}\n\n}  // namespace flatbuffers\n\n#endif  // FLATBUFFERS_BUFFER_H_\n"
  },
  {
    "path": "include/flatbuffers/buffer_ref.h",
    "content": "/*\n * Copyright 2021 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef FLATBUFFERS_BUFFER_REF_H_\n#define FLATBUFFERS_BUFFER_REF_H_\n\n#include \"flatbuffers/base.h\"\n#include \"flatbuffers/verifier.h\"\n\nnamespace flatbuffers {\n\n// Convenient way to bundle a buffer and its length, to pass it around\n// typed by its root.\n// A BufferRef does not own its buffer.\nstruct BufferRefBase {};  // for std::is_base_of\n\ntemplate \nstruct BufferRef : BufferRefBase {\n  BufferRef() : buf(nullptr), len(0), must_free(false) {}\n  BufferRef(uint8_t* _buf, uoffset_t _len)\n      : buf(_buf), len(_len), must_free(false) {}\n\n  ~BufferRef() {\n    if (must_free) free(buf);\n  }\n\n  const T* GetRoot() const { return flatbuffers::GetRoot(buf); }\n\n  bool Verify() {\n    Verifier verifier(buf, len);\n    return verifier.VerifyBuffer(nullptr);\n  }\n\n  uint8_t* buf;\n  uoffset_t len;\n  bool must_free;\n};\n\n}  // namespace flatbuffers\n\n#endif  // FLATBUFFERS_BUFFER_REF_H_\n"
  },
  {
    "path": "include/flatbuffers/code_generator.h",
    "content": "/*\n * Copyright 2023 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef FLATBUFFERS_CODE_GENERATOR_H_\n#define FLATBUFFERS_CODE_GENERATOR_H_\n\n#include \n\n#include \"flatbuffers/file_manager.h\"\n#include \"flatbuffers/idl.h\"\n\nnamespace flatbuffers {\n\nstruct CodeGenOptions {\n  std::string output_path;\n  FileSaver* file_saver{nullptr};\n};\n\n// A code generator interface for producing converting flatbuffer schema into\n// code.\nclass CodeGenerator {\n public:\n  virtual ~CodeGenerator() = default;\n\n  enum Status {\n    OK = 0,\n    ERROR = 1,\n    FAILED_VERIFICATION = 2,\n    NOT_IMPLEMENTED = 3\n  };\n\n  std::string status_detail;\n\n  // Generate code from the provided `parser`.\n  //\n  // DEPRECATED: prefer using the other overload of GenerateCode for bfbs.\n  virtual Status GenerateCode(const Parser& parser, const std::string& path,\n                              const std::string& filename) = 0;\n\n  // Generate code from the provided `parser` and place it in the output.\n  virtual Status GenerateCodeString(const Parser& parser,\n                                    const std::string& filename,\n                                    std::string& output) {\n    (void)parser;\n    (void)filename;\n    (void)output;\n    return Status::NOT_IMPLEMENTED;\n  }\n\n  // Generate code from the provided `buffer` of given `length`. The buffer is a\n  // serialized reflection.fbs.\n  virtual Status GenerateCode(const uint8_t* buffer, int64_t length,\n                              const CodeGenOptions& options) = 0;\n\n  virtual Status GenerateMakeRule(const Parser& parser, const std::string& path,\n                                  const std::string& filename,\n                                  std::string& output) = 0;\n\n  virtual Status GenerateGrpcCode(const Parser& parser, const std::string& path,\n                                  const std::string& filename) = 0;\n\n  virtual Status GenerateRootFile(const Parser& parser,\n                                  const std::string& path) = 0;\n\n  virtual bool IsSchemaOnly() const = 0;\n\n  virtual bool SupportsBfbsGeneration() const = 0;\n\n  virtual bool SupportsRootFileGeneration() const = 0;\n\n  virtual IDLOptions::Language Language() const = 0;\n\n  virtual std::string LanguageName() const = 0;\n\n protected:\n  CodeGenerator() = default;\n\n private:\n  // Copying is not supported.\n  CodeGenerator(const CodeGenerator&) = delete;\n  CodeGenerator& operator=(const CodeGenerator&) = delete;\n};\n\n}  // namespace flatbuffers\n\n#endif  // FLATBUFFERS_CODE_GENERATOR_H_\n"
  },
  {
    "path": "include/flatbuffers/code_generators.h",
    "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef FLATBUFFERS_CODE_GENERATORS_H_\n#define FLATBUFFERS_CODE_GENERATORS_H_\n\n#include \n#include \n\n#include \"flatbuffers/idl.h\"\n\nnamespace flatbuffers {\n\n// Utility class to assist in generating code through use of text templates.\n//\n// Example code:\n//   CodeWriter code(\"\\t\");\n//   code.SetValue(\"NAME\", \"Foo\");\n//   code += \"void {{NAME}}() { printf(\"%s\", \"{{NAME}}\"); }\";\n//   code.SetValue(\"NAME\", \"Bar\");\n//   code += \"void {{NAME}}() { printf(\"%s\", \"{{NAME}}\"); }\";\n//   std::cout << code.ToString() << std::endl;\n//\n// Output:\n//  void Foo() { printf(\"%s\", \"Foo\"); }\n//  void Bar() { printf(\"%s\", \"Bar\"); }\nclass CodeWriter {\n public:\n  CodeWriter(std::string pad = std::string())\n      : pad_(pad), cur_ident_lvl_(0), ignore_ident_(false) {}\n\n  // Clears the current \"written\" code.\n  void Clear() {\n    stream_.str(\"\");\n    stream_.clear();\n  }\n\n  // Associates a key with a value.  All subsequent calls to operator+=, where\n  // the specified key is contained in {{ and }} delimiters will be replaced by\n  // the given value.\n  void SetValue(const std::string& key, const std::string& value) {\n    value_map_[key] = value;\n  }\n\n  std::string GetValue(const std::string& key) const {\n    const auto it = value_map_.find(key);\n    return it == value_map_.end() ? \"\" : it->second;\n  }\n\n  // Appends the given text to the generated code as well as a newline\n  // character.  Any text within {{ and }} delimiters is replaced by values\n  // previously stored in the CodeWriter by calling SetValue above.  The newline\n  // will be suppressed if the text ends with the \\\\ character.\n  void operator+=(std::string text);\n\n  // Returns the current contents of the CodeWriter as a std::string.\n  std::string ToString() const { return stream_.str(); }\n\n  // Increase ident level for writing code\n  void IncrementIdentLevel() { cur_ident_lvl_++; }\n  // Decrease ident level for writing code\n  void DecrementIdentLevel() {\n    if (cur_ident_lvl_) cur_ident_lvl_--;\n  }\n\n  void SetPadding(const std::string& padding) { pad_ = padding; }\n\n private:\n  std::map value_map_;\n  std::stringstream stream_;\n  std::string pad_;\n  int cur_ident_lvl_;\n  bool ignore_ident_;\n\n  // Add ident padding (tab or space) based on ident level\n  void AppendIdent(std::stringstream& stream);\n};\n\nclass BaseGenerator {\n public:\n  virtual bool generate() = 0;\n\n  static std::string NamespaceDir(const Parser& parser, const std::string& path,\n                                  const Namespace& ns,\n                                  const bool dasherize = false);\n\n  std::string GeneratedFileName(const std::string& path,\n                                const std::string& file_name,\n                                const IDLOptions& options) const;\n\n protected:\n  BaseGenerator(const Parser& parser, const std::string& path,\n                const std::string& file_name, std::string qualifying_start,\n                std::string qualifying_separator, std::string default_extension)\n      : parser_(parser),\n        path_(path),\n        file_name_(file_name),\n        qualifying_start_(qualifying_start),\n        qualifying_separator_(qualifying_separator),\n        default_extension_(default_extension) {}\n  virtual ~BaseGenerator() {}\n\n  // No copy/assign.\n  BaseGenerator& operator=(const BaseGenerator&);\n  BaseGenerator(const BaseGenerator&);\n\n  std::string NamespaceDir(const Namespace& ns,\n                           const bool dasherize = false) const;\n\n  static const char* FlatBuffersGeneratedWarning();\n\n  static std::string FullNamespace(const char* separator, const Namespace& ns);\n\n  static std::string LastNamespacePart(const Namespace& ns);\n\n  // tracks the current namespace for early exit in WrapInNameSpace\n  // c++, java and csharp returns a different namespace from\n  // the following default (no early exit, always fully qualify),\n  // which works for js and php\n  virtual const Namespace* CurrentNameSpace() const { return nullptr; }\n\n  // Ensure that a type is prefixed with its namespace even within\n  // its own namespace to avoid conflict between generated method\n  // names and similarly named classes or structs\n  std::string WrapInNameSpace(const Namespace* ns,\n                              const std::string& name) const;\n\n  std::string WrapInNameSpace(const Definition& def,\n                              const std::string& suffix = \"\") const;\n\n  std::string GetNameSpace(const Definition& def) const;\n\n  const Parser& parser_;\n  const std::string& path_;\n  const std::string& file_name_;\n  const std::string qualifying_start_;\n  const std::string qualifying_separator_;\n  const std::string default_extension_;\n};\n\nstruct CommentConfig {\n  const char* first_line;\n  const char* content_line_prefix;\n  const char* last_line;\n};\n\nextern void GenComment(const std::vector& dc,\n                       std::string* code_ptr, const CommentConfig* config,\n                       const char* prefix = \"\");\n\nclass FloatConstantGenerator {\n public:\n  virtual ~FloatConstantGenerator() {}\n  std::string GenFloatConstant(const FieldDef& field) const;\n\n private:\n  virtual std::string Value(double v, const std::string& src) const = 0;\n  virtual std::string Inf(double v) const = 0;\n  virtual std::string NaN(double v) const = 0;\n\n  virtual std::string Value(float v, const std::string& src) const = 0;\n  virtual std::string Inf(float v) const = 0;\n  virtual std::string NaN(float v) const = 0;\n\n  template \n  std::string GenFloatConstantImpl(const FieldDef& field) const;\n};\n\nclass SimpleFloatConstantGenerator : public FloatConstantGenerator {\n public:\n  SimpleFloatConstantGenerator(const char* nan_number,\n                               const char* pos_inf_number,\n                               const char* neg_inf_number);\n\n private:\n  std::string Value(double v,\n                    const std::string& src) const FLATBUFFERS_OVERRIDE;\n  std::string Inf(double v) const FLATBUFFERS_OVERRIDE;\n  std::string NaN(double v) const FLATBUFFERS_OVERRIDE;\n\n  std::string Value(float v, const std::string& src) const FLATBUFFERS_OVERRIDE;\n  std::string Inf(float v) const FLATBUFFERS_OVERRIDE;\n  std::string NaN(float v) const FLATBUFFERS_OVERRIDE;\n\n  const std::string nan_number_;\n  const std::string pos_inf_number_;\n  const std::string neg_inf_number_;\n};\n\n// C++, C#, Java like generator.\nclass TypedFloatConstantGenerator : public FloatConstantGenerator {\n public:\n  TypedFloatConstantGenerator(const char* double_prefix,\n                              const char* single_prefix, const char* nan_number,\n                              const char* pos_inf_number,\n                              const char* neg_inf_number = \"\");\n\n private:\n  std::string Value(double v,\n                    const std::string& src) const FLATBUFFERS_OVERRIDE;\n  std::string Inf(double v) const FLATBUFFERS_OVERRIDE;\n\n  std::string NaN(double v) const FLATBUFFERS_OVERRIDE;\n\n  std::string Value(float v, const std::string& src) const FLATBUFFERS_OVERRIDE;\n  std::string Inf(float v) const FLATBUFFERS_OVERRIDE;\n  std::string NaN(float v) const FLATBUFFERS_OVERRIDE;\n\n  std::string MakeNaN(const std::string& prefix) const;\n  std::string MakeInf(bool neg, const std::string& prefix) const;\n\n  const std::string double_prefix_;\n  const std::string single_prefix_;\n  const std::string nan_number_;\n  const std::string pos_inf_number_;\n  const std::string neg_inf_number_;\n};\n\nstd::string JavaCSharpMakeRule(const bool java, const Parser& parser,\n                               const std::string& path,\n                               const std::string& file_name);\n\n}  // namespace flatbuffers\n\n#endif  // FLATBUFFERS_CODE_GENERATORS_H_\n"
  },
  {
    "path": "include/flatbuffers/default_allocator.h",
    "content": "/*\n * Copyright 2021 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef FLATBUFFERS_DEFAULT_ALLOCATOR_H_\n#define FLATBUFFERS_DEFAULT_ALLOCATOR_H_\n\n#include \"flatbuffers/allocator.h\"\n#include \"flatbuffers/base.h\"\n\nnamespace flatbuffers {\n\n// DefaultAllocator uses new/delete to allocate memory regions\nclass DefaultAllocator : public Allocator {\n public:\n  uint8_t* allocate(size_t size) FLATBUFFERS_OVERRIDE {\n    return new uint8_t[size];\n  }\n\n  void deallocate(uint8_t* p, size_t) FLATBUFFERS_OVERRIDE { delete[] p; }\n\n  static void dealloc(void* p, size_t) { delete[] static_cast(p); }\n};\n\n// These functions allow for a null allocator to mean use the default allocator,\n// as used by DetachedBuffer and vector_downward below.\n// This is to avoid having a statically or dynamically allocated default\n// allocator, or having to move it between the classes that may own it.\ninline uint8_t* Allocate(Allocator* allocator, size_t size) {\n  return allocator ? allocator->allocate(size)\n                   : DefaultAllocator().allocate(size);\n}\n\ninline void Deallocate(Allocator* allocator, uint8_t* p, size_t size) {\n  if (allocator)\n    allocator->deallocate(p, size);\n  else\n    DefaultAllocator().deallocate(p, size);\n}\n\ninline uint8_t* ReallocateDownward(Allocator* allocator, uint8_t* old_p,\n                                   size_t old_size, size_t new_size,\n                                   size_t in_use_back, size_t in_use_front) {\n  return allocator ? allocator->reallocate_downward(old_p, old_size, new_size,\n                                                    in_use_back, in_use_front)\n                   : DefaultAllocator().reallocate_downward(\n                         old_p, old_size, new_size, in_use_back, in_use_front);\n}\n\n}  // namespace flatbuffers\n\n#endif  // FLATBUFFERS_DEFAULT_ALLOCATOR_H_\n"
  },
  {
    "path": "include/flatbuffers/detached_buffer.h",
    "content": "/*\n * Copyright 2021 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef FLATBUFFERS_DETACHED_BUFFER_H_\n#define FLATBUFFERS_DETACHED_BUFFER_H_\n\n#include \"flatbuffers/allocator.h\"\n#include \"flatbuffers/base.h\"\n#include \"flatbuffers/default_allocator.h\"\n\nnamespace flatbuffers {\n\n// DetachedBuffer is a finished flatbuffer memory region, detached from its\n// builder. The original memory region and allocator are also stored so that\n// the DetachedBuffer can manage the memory lifetime.\nclass DetachedBuffer {\n public:\n  DetachedBuffer()\n      : allocator_(nullptr),\n        own_allocator_(false),\n        buf_(nullptr),\n        reserved_(0),\n        cur_(nullptr),\n        size_(0) {}\n\n  DetachedBuffer(Allocator* allocator, bool own_allocator, uint8_t* buf,\n                 size_t reserved, uint8_t* cur, size_t sz)\n      : allocator_(allocator),\n        own_allocator_(own_allocator),\n        buf_(buf),\n        reserved_(reserved),\n        cur_(cur),\n        size_(sz) {}\n\n  DetachedBuffer(DetachedBuffer&& other) noexcept\n      : allocator_(other.allocator_),\n        own_allocator_(other.own_allocator_),\n        buf_(other.buf_),\n        reserved_(other.reserved_),\n        cur_(other.cur_),\n        size_(other.size_) {\n    other.reset();\n  }\n\n  DetachedBuffer& operator=(DetachedBuffer&& other) noexcept {\n    if (this == &other) return *this;\n\n    destroy();\n\n    allocator_ = other.allocator_;\n    own_allocator_ = other.own_allocator_;\n    buf_ = other.buf_;\n    reserved_ = other.reserved_;\n    cur_ = other.cur_;\n    size_ = other.size_;\n\n    other.reset();\n\n    return *this;\n  }\n\n  ~DetachedBuffer() { destroy(); }\n\n  const uint8_t* data() const { return cur_; }\n\n  uint8_t* data() { return cur_; }\n\n  size_t size() const { return size_; }\n\n  uint8_t* begin() { return data(); }\n  const uint8_t* begin() const { return data(); }\n  uint8_t* end() { return data() + size(); }\n  const uint8_t* end() const { return data() + size(); }\n\n  // These may change access mode, leave these at end of public section\n  FLATBUFFERS_DELETE_FUNC(DetachedBuffer(const DetachedBuffer& other));\n  FLATBUFFERS_DELETE_FUNC(\n      DetachedBuffer& operator=(const DetachedBuffer& other));\n\n protected:\n  Allocator* allocator_;\n  bool own_allocator_;\n  uint8_t* buf_;\n  size_t reserved_;\n  uint8_t* cur_;\n  size_t size_;\n\n  inline void destroy() {\n    if (buf_) Deallocate(allocator_, buf_, reserved_);\n    if (own_allocator_ && allocator_) {\n      delete allocator_;\n    }\n    reset();\n  }\n\n  inline void reset() {\n    allocator_ = nullptr;\n    own_allocator_ = false;\n    buf_ = nullptr;\n    reserved_ = 0;\n    cur_ = nullptr;\n    size_ = 0;\n  }\n};\n\n}  // namespace flatbuffers\n\n#endif  // FLATBUFFERS_DETACHED_BUFFER_H_\n"
  },
  {
    "path": "include/flatbuffers/file_manager.h",
    "content": "/*\n * Copyright 2023 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef FLATBUFFERS_FILE_MANAGER_H_\n#define FLATBUFFERS_FILE_MANAGER_H_\n\n#include \n#include \n#include \n\nnamespace flatbuffers {\n\n// A File interface to write data to file by default or\n// save only file names\nclass FileSaver {\n public:\n  FileSaver() = default;\n  virtual ~FileSaver() = default;\n\n  virtual bool SaveFile(const char* name, const char* buf, size_t len,\n                        bool binary) = 0;\n\n  bool SaveFile(const char* name, const std::string& buf, bool binary) {\n    return SaveFile(name, buf.c_str(), buf.size(), binary);\n  }\n\n  virtual void Finish() {}\n\n private:\n  // Copying is not supported.\n  FileSaver(const FileSaver&) = delete;\n  FileSaver& operator=(const FileSaver&) = delete;\n  // Rule of 5\n  FileSaver(FileSaver&&) = default;\n  FileSaver& operator=(FileSaver&&) = default;\n};\n\nclass RealFileSaver final : public FileSaver {\n public:\n  bool SaveFile(const char* name, const char* buf, size_t len,\n                bool binary) final;\n};\n\nclass FileNameSaver final : public FileSaver {\n public:\n  bool SaveFile(const char* name, const char* buf, size_t len,\n                bool binary) final;\n\n  void Finish() final;\n\n private:\n  std::set file_names_{};\n};\n\n}  // namespace flatbuffers\n\n#endif  // FLATBUFFERS_FILE_MANAGER_H_\n"
  },
  {
    "path": "include/flatbuffers/flatbuffer_builder.h",
    "content": "/*\n * Copyright 2021 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef FLATBUFFERS_FLATBUFFER_BUILDER_H_\n#define FLATBUFFERS_FLATBUFFER_BUILDER_H_\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"flatbuffers/allocator.h\"\n#include \"flatbuffers/array.h\"\n#include \"flatbuffers/base.h\"\n#include \"flatbuffers/buffer.h\"\n#include \"flatbuffers/buffer_ref.h\"\n#include \"flatbuffers/default_allocator.h\"\n#include \"flatbuffers/detached_buffer.h\"\n#include \"flatbuffers/stl_emulation.h\"\n#include \"flatbuffers/string.h\"\n#include \"flatbuffers/struct.h\"\n#include \"flatbuffers/table.h\"\n#include \"flatbuffers/vector.h\"\n#include \"flatbuffers/vector_downward.h\"\n#include \"flatbuffers/verifier.h\"\n\nnamespace flatbuffers {\n\n// Converts a Field ID to a virtual table offset.\ninline voffset_t FieldIndexToOffset(voffset_t field_id) {\n  // Should correspond to what EndTable() below builds up.\n  const voffset_t fixed_fields =\n      2 * sizeof(voffset_t);  // Vtable size and Object Size.\n  size_t offset = fixed_fields + field_id * sizeof(voffset_t);\n  FLATBUFFERS_ASSERT(offset < std::numeric_limits::max());\n  return static_cast(offset);\n}\n\ntemplate >\nconst T* data(const std::vector& v) {\n  // Eventually the returned pointer gets passed down to memcpy, so\n  // we need it to be non-null to avoid undefined behavior.\n  static uint8_t t;\n  return v.empty() ? reinterpret_cast(&t) : &v.front();\n}\ntemplate >\nT* data(std::vector& v) {\n  // Eventually the returned pointer gets passed down to memcpy, so\n  // we need it to be non-null to avoid undefined behavior.\n  static uint8_t t;\n  return v.empty() ? reinterpret_cast(&t) : &v.front();\n}\n\n/// @addtogroup flatbuffers_cpp_api\n/// @{\n/// @class FlatBufferBuilder\n/// @brief Helper class to hold data needed in creation of a FlatBuffer.\n/// To serialize data, you typically call one of the `Create*()` functions in\n/// the generated code, which in turn call a sequence of `StartTable`/\n/// `PushElement`/`AddElement`/`EndTable`, or the builtin `CreateString`/\n/// `CreateVector` functions. Do this is depth-first order to build up a tree to\n/// the root. `Finish()` wraps up the buffer ready for transport.\ntemplate \nclass FlatBufferBuilderImpl {\n public:\n  // This switches the size type of the builder, based on if its 64-bit aware\n  // (uoffset64_t) or not (uoffset_t).\n  typedef\n      typename std::conditional::type SizeT;\n\n  /// @brief Default constructor for FlatBufferBuilder.\n  /// @param[in] initial_size The initial size of the buffer, in bytes. Defaults\n  /// to `1024`.\n  /// @param[in] allocator An `Allocator` to use. If null will use\n  /// `DefaultAllocator`.\n  /// @param[in] own_allocator Whether the builder/vector should own the\n  /// allocator. Defaults to / `false`.\n  /// @param[in] buffer_minalign Force the buffer to be aligned to the given\n  /// minimum alignment upon reallocation. Only needed if you intend to store\n  /// types with custom alignment AND you wish to read the buffer in-place\n  /// directly after creation.\n  explicit FlatBufferBuilderImpl(\n      size_t initial_size = 1024, Allocator* allocator = nullptr,\n      bool own_allocator = false,\n      size_t buffer_minalign = AlignOf())\n      : buf_(initial_size, allocator, own_allocator, buffer_minalign,\n             static_cast(Is64Aware ? FLATBUFFERS_MAX_64_BUFFER_SIZE\n                                          : FLATBUFFERS_MAX_BUFFER_SIZE)),\n        num_field_loc(0),\n        max_voffset_(0),\n        length_of_64_bit_region_(0),\n        nested(false),\n        finished(false),\n        minalign_(1),\n        force_defaults_(false),\n        dedup_vtables_(true),\n        string_pool(nullptr) {\n    EndianCheck();\n  }\n\n  /// @brief Move constructor for FlatBufferBuilder.\n  FlatBufferBuilderImpl(FlatBufferBuilderImpl&& other) noexcept\n      : buf_(1024, nullptr, false, AlignOf(),\n             static_cast(Is64Aware ? FLATBUFFERS_MAX_64_BUFFER_SIZE\n                                          : FLATBUFFERS_MAX_BUFFER_SIZE)),\n        num_field_loc(0),\n        max_voffset_(0),\n        length_of_64_bit_region_(0),\n        nested(false),\n        finished(false),\n        minalign_(1),\n        force_defaults_(false),\n        dedup_vtables_(true),\n        string_pool(nullptr) {\n    EndianCheck();\n    // Default construct and swap idiom.\n    // Lack of delegating constructors in vs2010 makes it more verbose than\n    // needed.\n    Swap(other);\n  }\n\n  /// @brief Move assignment operator for FlatBufferBuilder.\n  FlatBufferBuilderImpl& operator=(FlatBufferBuilderImpl&& other) noexcept {\n    // Move construct a temporary and swap idiom\n    FlatBufferBuilderImpl temp(std::move(other));\n    Swap(temp);\n    return *this;\n  }\n\n  void Swap(FlatBufferBuilderImpl& other) {\n    using std::swap;\n    buf_.swap(other.buf_);\n    swap(num_field_loc, other.num_field_loc);\n    swap(max_voffset_, other.max_voffset_);\n    swap(length_of_64_bit_region_, other.length_of_64_bit_region_);\n    swap(nested, other.nested);\n    swap(finished, other.finished);\n    swap(minalign_, other.minalign_);\n    swap(force_defaults_, other.force_defaults_);\n    swap(dedup_vtables_, other.dedup_vtables_);\n    swap(string_pool, other.string_pool);\n  }\n\n  ~FlatBufferBuilderImpl() {\n    if (string_pool) delete string_pool;\n  }\n\n  void Reset() {\n    Clear();       // clear builder state\n    buf_.reset();  // deallocate buffer\n  }\n\n  /// @brief Reset all the state in this FlatBufferBuilder so it can be reused\n  /// to construct another buffer.\n  void Clear() {\n    ClearOffsets();\n    buf_.clear();\n    nested = false;\n    finished = false;\n    minalign_ = 1;\n    length_of_64_bit_region_ = 0;\n    if (string_pool) string_pool->clear();\n  }\n\n  /// @brief The current size of the serialized buffer, counting from the end.\n  /// @return Returns an `SizeT` with the current size of the buffer.\n  SizeT GetSize() const { return buf_.size(); }\n\n  /// @brief The current size of the serialized buffer relative to the end of\n  /// the 32-bit region.\n  /// @return Returns an `uoffset_t` with the current size of the buffer.\n  template \n  // Only enable this method for the 64-bit builder, as only that builder is\n  // concerned with the 32/64-bit boundary, and should be the one to bare any\n  // run time costs.\n  typename std::enable_if::type GetSizeRelative32BitRegion()\n      const {\n    //[32-bit region][64-bit region]\n    //         [XXXXXXXXXXXXXXXXXXX] GetSize()\n    //               [YYYYYYYYYYYYY] length_of_64_bit_region_\n    //         [ZZZZ]                return size\n    return static_cast(GetSize() - length_of_64_bit_region_);\n  }\n\n  template \n  // Only enable this method for the 32-bit builder.\n  typename std::enable_if::type GetSizeRelative32BitRegion()\n      const {\n    return static_cast(GetSize());\n  }\n\n  /// @brief Get the serialized buffer (after you call `Finish()`).\n  /// @return Returns an `uint8_t` pointer to the FlatBuffer data inside the\n  /// buffer.\n  uint8_t* GetBufferPointer() const {\n    Finished();\n    return buf_.data();\n  }\n\n  /// @brief Get the serialized buffer (after you call `Finish()`) as a span.\n  /// @return Returns a constructed flatbuffers::span that is a view over the\n  /// FlatBuffer data inside the buffer.\n  flatbuffers::span GetBufferSpan() const {\n    Finished();\n    return flatbuffers::span(buf_.data(), buf_.size());\n  }\n\n  /// @brief Get a pointer to an unfinished buffer.\n  /// @return Returns a `uint8_t` pointer to the unfinished buffer.\n  uint8_t* GetCurrentBufferPointer() const { return buf_.data(); }\n\n  /// @brief Get the released DetachedBuffer.\n  /// @return A `DetachedBuffer` that owns the buffer and its allocator.\n  DetachedBuffer Release() {\n    Finished();\n    DetachedBuffer buffer = buf_.release();\n    Clear();\n    return buffer;\n  }\n\n  /// @brief Get the released pointer to the serialized buffer.\n  /// @param size The size of the memory block containing\n  /// the serialized `FlatBuffer`.\n  /// @param offset The offset from the released pointer where the finished\n  /// `FlatBuffer` starts.\n  /// @return A raw pointer to the start of the memory block containing\n  /// the serialized `FlatBuffer`.\n  /// @remark If the allocator is owned, it gets deleted when the destructor is\n  /// called.\n  uint8_t* ReleaseRaw(size_t& size, size_t& offset) {\n    Finished();\n    uint8_t* raw = buf_.release_raw(size, offset);\n    Clear();\n    return raw;\n  }\n\n  /// @brief get the minimum alignment this buffer needs to be accessed\n  /// properly. This is only known once all elements have been written (after\n  /// you call Finish()). You can use this information if you need to embed\n  /// a FlatBuffer in some other buffer, such that you can later read it\n  /// without first having to copy it into its own buffer.\n  size_t GetBufferMinAlignment() const {\n    Finished();\n    return minalign_;\n  }\n\n  /// @cond FLATBUFFERS_INTERNAL\n  void Finished() const {\n    // If you get this assert, you're attempting to get access a buffer\n    // which hasn't been finished yet. Be sure to call\n    // FlatBufferBuilder::Finish with your root table.\n    // If you really need to access an unfinished buffer, call\n    // GetCurrentBufferPointer instead.\n    FLATBUFFERS_ASSERT(finished);\n  }\n  /// @endcond\n\n  /// @brief In order to save space, fields that are set to their default value\n  /// don't get serialized into the buffer.\n  /// @param[in] fd When set to `true`, always serializes default values that\n  /// are set. Optional fields which are not set explicitly, will still not be\n  /// serialized.\n  void ForceDefaults(bool fd) { force_defaults_ = fd; }\n\n  /// @brief By default vtables are deduped in order to save space.\n  /// @param[in] dedup When set to `true`, dedup vtables.\n  void DedupVtables(bool dedup) { dedup_vtables_ = dedup; }\n\n  /// @cond FLATBUFFERS_INTERNAL\n  void Pad(size_t num_bytes) { buf_.fill(num_bytes); }\n\n  void TrackMinAlign(size_t elem_size) {\n    if (elem_size > minalign_) minalign_ = elem_size;\n  }\n\n  void Align(size_t elem_size) {\n    TrackMinAlign(elem_size);\n    buf_.fill(PaddingBytes(buf_.size(), elem_size));\n  }\n\n  void PushFlatBuffer(const uint8_t* bytes, size_t size) {\n    PushBytes(bytes, size);\n    finished = true;\n  }\n\n  void PushBytes(const uint8_t* bytes, size_t size) { buf_.push(bytes, size); }\n\n  void PopBytes(size_t amount) { buf_.pop(amount); }\n\n  template \n  void AssertScalarT() {\n    // The code assumes power of 2 sizes and endian-swap-ability.\n    static_assert(flatbuffers::is_scalar::value, \"T must be a scalar type\");\n  }\n\n  // Write a single aligned scalar to the buffer\n  template \n  ReturnT PushElement(T element) {\n    AssertScalarT();\n    Align(sizeof(T));\n    buf_.push_small(EndianScalar(element));\n    return CalculateOffset();\n  }\n\n  template  class OffsetT = Offset>\n  uoffset_t PushElement(OffsetT off) {\n    // Special case for offsets: see ReferTo below.\n    return PushElement(ReferTo(off.o));\n  }\n\n  // When writing fields, we track where they are, so we can create correct\n  // vtables later.\n  void TrackField(voffset_t field, uoffset_t off) {\n    FieldLoc fl = {off, field};\n    buf_.scratch_push_small(fl);\n    num_field_loc++;\n    if (field > max_voffset_) {\n      max_voffset_ = field;\n    }\n  }\n\n  // Like PushElement, but additionally tracks the field this represents.\n  template \n  void AddElement(voffset_t field, T e, T def) {\n    // We don't serialize values equal to the default.\n    if (IsTheSameAs(e, def) && !force_defaults_) return;\n    TrackField(field, PushElement(e));\n  }\n\n  template \n  void AddElement(voffset_t field, T e) {\n    TrackField(field, PushElement(e));\n  }\n\n  template \n  void AddOffset(voffset_t field, Offset off) {\n    if (off.IsNull()) return;  // Don't store.\n    AddElement(field, ReferTo(off.o), static_cast(0));\n  }\n\n  template \n  void AddOffset(voffset_t field, Offset64 off) {\n    if (off.IsNull()) return;  // Don't store.\n    AddElement(field, ReferTo(off.o), static_cast(0));\n  }\n\n  template \n  void AddStruct(voffset_t field, const T* structptr) {\n    if (!structptr) return;  // Default, don't store.\n    Align(AlignOf());\n    buf_.push_small(*structptr);\n    TrackField(field, CalculateOffset());\n  }\n\n  void AddStructOffset(voffset_t field, uoffset_t off) {\n    TrackField(field, off);\n  }\n\n  // Offsets initially are relative to the end of the buffer (downwards).\n  // This function converts them to be relative to the current location\n  // in the buffer (when stored here), pointing upwards.\n  uoffset_t ReferTo(uoffset_t off) {\n    // Align to ensure GetSizeRelative32BitRegion() below is correct.\n    Align(sizeof(uoffset_t));\n    // 32-bit offsets are relative to the tail of the 32-bit region of the\n    // buffer. For most cases (without 64-bit entities) this is equivalent to\n    // size of the whole buffer (e.g. GetSize())\n    return ReferTo(off, GetSizeRelative32BitRegion());\n  }\n\n  uoffset64_t ReferTo(uoffset64_t off) {\n    // Align to ensure GetSize() below is correct.\n    Align(sizeof(uoffset64_t));\n    // 64-bit offsets are relative to tail of the whole buffer\n    return ReferTo(off, GetSize());\n  }\n\n  template \n  T ReferTo(const T off, const T2 size) {\n    FLATBUFFERS_ASSERT(off && off <= size);\n    return size - off + static_cast(sizeof(T));\n  }\n\n  template \n  T ReferTo(const T off, const T size) {\n    FLATBUFFERS_ASSERT(off && off <= size);\n    return size - off + static_cast(sizeof(T));\n  }\n\n  void NotNested() {\n    // If you hit this, you're trying to construct a Table/Vector/String\n    // during the construction of its parent table (between the MyTableBuilder\n    // and table.Finish().\n    // Move the creation of these sub-objects to above the MyTableBuilder to\n    // not get this assert.\n    // Ignoring this assert may appear to work in simple cases, but the reason\n    // it is here is that storing objects in-line may cause vtable offsets\n    // to not fit anymore. It also leads to vtable duplication.\n    FLATBUFFERS_ASSERT(!nested);\n    // If you hit this, fields were added outside the scope of a table.\n    FLATBUFFERS_ASSERT(!num_field_loc);\n  }\n\n  // From generated code (or from the parser), we call StartTable/EndTable\n  // with a sequence of AddElement calls in between.\n  uoffset_t StartTable() {\n    NotNested();\n    nested = true;\n    return GetSizeRelative32BitRegion();\n  }\n\n  // This finishes one serialized object by generating the vtable if it's a\n  // table, comparing it against existing vtables, and writing the\n  // resulting vtable offset.\n  uoffset_t EndTable(uoffset_t start) {\n    // If you get this assert, a corresponding StartTable wasn't called.\n    FLATBUFFERS_ASSERT(nested);\n    // Write the vtable offset, which is the start of any Table.\n    // We fill its value later.\n    // This is relative to the end of the 32-bit region.\n    const uoffset_t vtable_offset_loc =\n        static_cast(PushElement(0));\n    // Write a vtable, which consists entirely of voffset_t elements.\n    // It starts with the number of offsets, followed by a type id, followed\n    // by the offsets themselves. In reverse:\n    // Include space for the last offset and ensure empty tables have a\n    // minimum size.\n    max_voffset_ =\n        (std::max)(static_cast(max_voffset_ + sizeof(voffset_t)),\n                   FieldIndexToOffset(0));\n    buf_.fill_big(max_voffset_);\n    const uoffset_t table_object_size = vtable_offset_loc - start;\n    // Vtable use 16bit offsets.\n    FLATBUFFERS_ASSERT(table_object_size < 0x10000);\n    WriteScalar(buf_.data() + sizeof(voffset_t),\n                           static_cast(table_object_size));\n    WriteScalar(buf_.data(), max_voffset_);\n    // Write the offsets into the table\n    for (auto it = buf_.scratch_end() - num_field_loc * sizeof(FieldLoc);\n         it < buf_.scratch_end(); it += sizeof(FieldLoc)) {\n      auto field_location = reinterpret_cast(it);\n      const voffset_t pos =\n          static_cast(vtable_offset_loc - field_location->off);\n      // If this asserts, it means you've set a field twice.\n      FLATBUFFERS_ASSERT(\n          !ReadScalar(buf_.data() + field_location->id));\n      WriteScalar(buf_.data() + field_location->id, pos);\n    }\n    ClearOffsets();\n    auto vt1 = reinterpret_cast(buf_.data());\n    auto vt1_size = ReadScalar(vt1);\n    auto vt_use = GetSizeRelative32BitRegion();\n    // See if we already have generated a vtable with this exact same\n    // layout before. If so, make it point to the old one, remove this one.\n    if (dedup_vtables_) {\n      for (auto it = buf_.scratch_data(); it < buf_.scratch_end();\n           it += sizeof(uoffset_t)) {\n        auto vt_offset_ptr = reinterpret_cast(it);\n        auto vt2 = reinterpret_cast(\n            buf_.data_at(*vt_offset_ptr + length_of_64_bit_region_));\n        auto vt2_size = ReadScalar(vt2);\n        if (vt1_size != vt2_size || 0 != memcmp(vt2, vt1, vt1_size)) continue;\n        vt_use = *vt_offset_ptr;\n        buf_.pop(GetSizeRelative32BitRegion() - vtable_offset_loc);\n        break;\n      }\n    }\n    // If this is a new vtable, remember it.\n    if (vt_use == GetSizeRelative32BitRegion()) {\n      buf_.scratch_push_small(vt_use);\n    }\n    // Fill the vtable offset we created above.\n    // The offset points from the beginning of the object to where the vtable is\n    // stored.\n    // Offsets default direction is downward in memory for future format\n    // flexibility (storing all vtables at the start of the file).\n    WriteScalar(buf_.data_at(vtable_offset_loc + length_of_64_bit_region_),\n                static_cast(vt_use) -\n                    static_cast(vtable_offset_loc));\n    nested = false;\n    return vtable_offset_loc;\n  }\n\n  FLATBUFFERS_ATTRIBUTE([[deprecated(\"call the version above instead\")]])\n  uoffset_t EndTable(uoffset_t start, voffset_t /*numfields*/) {\n    return EndTable(start);\n  }\n\n  // This checks a required field has been set in a given table that has\n  // just been constructed.\n  template \n  void Required(Offset table, voffset_t field) {\n    auto table_ptr = reinterpret_cast(buf_.data_at(table.o));\n    bool ok = table_ptr->GetOptionalFieldOffset(field) != 0;\n    // If this fails, the caller will show what field needs to be set.\n    FLATBUFFERS_ASSERT(ok);\n    (void)ok;\n  }\n\n  uoffset_t StartStruct(size_t alignment) {\n    Align(alignment);\n    return GetSizeRelative32BitRegion();\n  }\n\n  uoffset_t EndStruct() { return GetSizeRelative32BitRegion(); }\n\n  void ClearOffsets() {\n    buf_.scratch_pop(num_field_loc * sizeof(FieldLoc));\n    num_field_loc = 0;\n    max_voffset_ = 0;\n  }\n\n  // Aligns such that when \"len\" bytes are written, an object can be written\n  // after it (forward in the buffer) with \"alignment\" without padding.\n  void PreAlign(size_t len, size_t alignment) {\n    if (len == 0) return;\n    TrackMinAlign(alignment);\n    buf_.fill(PaddingBytes(GetSize() + len, alignment));\n  }\n\n  // Aligns such than when \"len\" bytes are written, an object of type `AlignT`\n  // can be written after it (forward in the buffer) without padding.\n  template \n  void PreAlign(size_t len) {\n    AssertScalarT();\n    PreAlign(len, AlignOf());\n  }\n  /// @endcond\n\n  /// @brief Store a string in the buffer, which can contain any binary data.\n  /// @param[in] str A const char pointer to the data to be stored as a string.\n  /// @param[in] len The number of bytes that should be stored from `str`.\n  /// @return Returns the offset in the buffer where the string starts.\n  template