forked from BigfootDev/flatbuffers
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 dependabot[bot]
|
400711102f |
+13
-13
@@ -42,7 +42,7 @@ jobs:
|
||||
chmod +x flatc
|
||||
./flatc --version
|
||||
- name: upload build artifacts
|
||||
uses: actions/upload-artifact@v4
|
||||
uses: actions/upload-artifact@v7
|
||||
with:
|
||||
name: Linux flatc binary ${{ matrix.cxx }}
|
||||
path: flatc
|
||||
@@ -137,7 +137,7 @@ jobs:
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- name: Add msbuild to PATH
|
||||
uses: microsoft/setup-msbuild@v2
|
||||
uses: microsoft/setup-msbuild@v3
|
||||
- name: cmake
|
||||
run: >
|
||||
cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release
|
||||
@@ -162,7 +162,7 @@ jobs:
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- name: Add msbuild to PATH
|
||||
uses: microsoft/setup-msbuild@v2
|
||||
uses: microsoft/setup-msbuild@v3
|
||||
- name: cmake
|
||||
run: cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_CPP17=ON -DFLATBUFFERS_STRICT_MODE=ON .
|
||||
- name: build
|
||||
@@ -170,7 +170,7 @@ jobs:
|
||||
- name: test
|
||||
run: Release\flattests.exe
|
||||
- name: upload build artifacts
|
||||
uses: actions/upload-artifact@v4
|
||||
uses: actions/upload-artifact@v7
|
||||
with:
|
||||
name: Windows flatc binary
|
||||
path: Release\flatc.exe
|
||||
@@ -191,7 +191,7 @@ jobs:
|
||||
|
||||
build-dotnet-windows:
|
||||
name: Build .NET Windows
|
||||
runs-on: windows-2022-64core
|
||||
runs-on: windows-2022
|
||||
strategy:
|
||||
matrix:
|
||||
configuration: [
|
||||
@@ -246,7 +246,7 @@ jobs:
|
||||
chmod +x Release/flatc
|
||||
Release/flatc --version
|
||||
- name: upload build artifacts
|
||||
uses: actions/upload-artifact@v4
|
||||
uses: actions/upload-artifact@v7
|
||||
with:
|
||||
name: Mac flatc binary Intel
|
||||
path: Release/flatc
|
||||
@@ -289,7 +289,7 @@ jobs:
|
||||
chmod +x Release/flatc
|
||||
Release/flatc --version
|
||||
- name: upload build artifacts
|
||||
uses: actions/upload-artifact@v4
|
||||
uses: actions/upload-artifact@v7
|
||||
with:
|
||||
name: Mac flatc binary Universal
|
||||
path: Release/flatc
|
||||
@@ -314,7 +314,7 @@ jobs:
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- name: set up Java
|
||||
uses: actions/setup-java@v4
|
||||
uses: actions/setup-java@v5
|
||||
with:
|
||||
distribution: temurin
|
||||
java-version: 17
|
||||
@@ -350,7 +350,7 @@ jobs:
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- name: Add msbuild to PATH
|
||||
uses: microsoft/setup-msbuild@v2
|
||||
uses: microsoft/setup-msbuild@v3
|
||||
- name: cmake
|
||||
run: cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_CPP17=ON -DFLATBUFFERS_STRICT_MODE=ON .
|
||||
- name: build
|
||||
@@ -373,7 +373,7 @@ jobs:
|
||||
- name: Run benchmarks
|
||||
run: ./flatbenchmark --benchmark_repetitions=5 --benchmark_display_aggregates_only=true --benchmark_out_format=console --benchmark_out=benchmarks/results_${{matrix.cxx}}
|
||||
- name: Upload benchmarks results
|
||||
uses: actions/upload-artifact@v4
|
||||
uses: actions/upload-artifact@v7
|
||||
with:
|
||||
name: Linux flatbenchmark results ${{matrix.cxx}}
|
||||
path: benchmarks/results_${{matrix.cxx}}
|
||||
@@ -394,7 +394,7 @@ jobs:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v6
|
||||
- name: set up Java
|
||||
uses: actions/setup-java@v4
|
||||
uses: actions/setup-java@v5
|
||||
with:
|
||||
distribution: temurin
|
||||
java-version: 17
|
||||
@@ -417,7 +417,7 @@ jobs:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v6
|
||||
- name: set up Java
|
||||
uses: actions/setup-java@v4
|
||||
uses: actions/setup-java@v5
|
||||
with:
|
||||
distribution: temurin
|
||||
java-version: 17
|
||||
@@ -446,7 +446,7 @@ jobs:
|
||||
|
||||
build-rust-windows:
|
||||
name: Build Rust Windows
|
||||
runs-on: windows-2022-64core
|
||||
runs-on: windows-2022
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- name: test
|
||||
|
||||
@@ -21,11 +21,11 @@ jobs:
|
||||
run: |
|
||||
git config user.name github-actions[bot]
|
||||
git config user.email 41898282+github-actions[bot]@users.noreply.github.com
|
||||
- uses: actions/setup-python@v5
|
||||
- uses: actions/setup-python@v6
|
||||
with:
|
||||
python-version: 3.x
|
||||
- run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_ENV
|
||||
- uses: actions/cache@v4
|
||||
- uses: actions/cache@v5
|
||||
with:
|
||||
key: mkdocs-material-${{ env.cache_id }}
|
||||
path: .cache
|
||||
|
||||
@@ -27,7 +27,7 @@ jobs:
|
||||
language: c++
|
||||
fuzz-seconds: 60
|
||||
- name: Upload Crash
|
||||
uses: actions/upload-artifact@v4
|
||||
uses: actions/upload-artifact@v7
|
||||
if: failure() && steps.build.outcome == 'success'
|
||||
with:
|
||||
name: artifacts
|
||||
|
||||
@@ -13,7 +13,7 @@ jobs:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: actions/setup-node@v3
|
||||
- uses: actions/setup-node@v6
|
||||
with:
|
||||
node-version: '20.x'
|
||||
registry-url: 'https://registry.npmjs.org'
|
||||
@@ -30,7 +30,7 @@ jobs:
|
||||
working-directory: ./python
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- uses: actions/setup-python@v4
|
||||
- uses: actions/setup-python@v6
|
||||
with:
|
||||
python-version: '3.10'
|
||||
|
||||
|
||||
+1
-11
@@ -238,15 +238,8 @@ set(FlatBuffers_Tests_SRCS
|
||||
tests/util_test.cpp
|
||||
tests/vector_table_naked_ptr_test.h
|
||||
tests/vector_table_naked_ptr_test.cpp
|
||||
tests/test_vector_type.h
|
||||
tests/cpp_vector_type_test.h
|
||||
tests/cpp_vector_type_test.cpp
|
||||
tests/native_type_test_impl.h
|
||||
tests/native_type_test_impl.cpp
|
||||
tests/bigfoot_ref_test_impl.h
|
||||
tests/bigfoot_ref_test_impl.cpp
|
||||
tests/required_table_default_test.h
|
||||
tests/required_table_default_test.cpp
|
||||
tests/alignment_test.h
|
||||
tests/alignment_test.cpp
|
||||
tests/64bit/offset64_test.h
|
||||
@@ -555,21 +548,18 @@ if(FLATBUFFERS_BUILD_TESTS)
|
||||
# The flattest target needs some generated files
|
||||
SET(FLATC_OPT_COMP --cpp --gen-compare --gen-mutable --gen-object-api --reflect-names)
|
||||
SET(FLATC_OPT_SCOPED_ENUMS ${FLATC_OPT_COMP};--scoped-enums)
|
||||
SET(FLATC_OPT_CPP_VECTOR_TYPE ${FLATC_OPT_COMP};--cpp-include;test_vector_type.h;--cpp-vector-type;::flatbuffers::tests::CustomVector)
|
||||
|
||||
compile_schema_for_test(tests/alignment_test.fbs "${FLATC_OPT_COMP}")
|
||||
compile_schema_for_test_fbsh(tests/default_vectors_strings_test.fbs "${FLATC_OPT_COMP}")
|
||||
compile_schema_for_test(tests/arrays_test.fbs "${FLATC_OPT_SCOPED_ENUMS}")
|
||||
compile_schema_for_test(tests/native_inline_table_test.fbs "${FLATC_OPT_COMP}")
|
||||
compile_schema_for_test(tests/native_type_test.fbs "${FLATC_OPT_COMP}")
|
||||
compile_schema_for_test(tests/bigfoot_ref_test.fbs "${FLATC_OPT_COMP}")
|
||||
compile_schema_for_test(tests/required_table_default_test.fbs "${FLATC_OPT_COMP}")
|
||||
compile_schema_for_test(tests/key_field/key_field_sample.fbs "${FLATC_OPT_COMP}")
|
||||
compile_schema_for_test(tests/64bit/test_64bit.fbs "${FLATC_OPT_COMP};--bfbs-gen-embed")
|
||||
compile_schema_for_test(tests/64bit/evolution/v1.fbs "${FLATC_OPT_COMP}")
|
||||
compile_schema_for_test(tests/64bit/evolution/v2.fbs "${FLATC_OPT_COMP}")
|
||||
compile_schema_for_test(tests/union_underlying_type_test.fbs "${FLATC_OPT_SCOPED_ENUMS}")
|
||||
compile_schema_for_test(tests/cpp_vector_type.fbs "${FLATC_OPT_CPP_VECTOR_TYPE}")
|
||||
compile_schema_for_test(tests/cross_namespace_pack_test.fbs "${FLATC_OPT_COMP}")
|
||||
|
||||
if(FLATBUFFERS_CODE_SANITIZE)
|
||||
add_fsanitize_to_target(flattests ${FLATBUFFERS_CODE_SANITIZE})
|
||||
|
||||
+2
-5
@@ -23,7 +23,7 @@ bazel_dep(
|
||||
)
|
||||
bazel_dep(
|
||||
name = "grpc",
|
||||
version = "1.70.1",
|
||||
version = "1.76.0",
|
||||
repo_name = "com_github_grpc_grpc",
|
||||
)
|
||||
bazel_dep(
|
||||
@@ -49,7 +49,7 @@ bazel_dep(
|
||||
)
|
||||
bazel_dep(
|
||||
name = "rules_swift",
|
||||
version = "2.1.1",
|
||||
version = "3.1.2",
|
||||
max_compatibility_level = 3,
|
||||
repo_name = "build_bazel_rules_swift",
|
||||
)
|
||||
@@ -63,9 +63,6 @@ npm.npm_translate_lock(
|
||||
name = "flatbuffers_npm",
|
||||
npmrc = "//:.npmrc",
|
||||
pnpm_lock = "//ts:pnpm-lock.yaml",
|
||||
# Override the Bazel package where pnpm-lock.yaml is located and link
|
||||
# to the specified package instead.
|
||||
root_package = "ts",
|
||||
verify_node_modules_ignored = "//:.bazelignore",
|
||||
)
|
||||
use_repo(npm, "flatbuffers_npm")
|
||||
|
||||
@@ -1,174 +0,0 @@
|
||||
/*
|
||||
* Copyright 2024 Google Inc. All rights reserved.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
import Benchmark
|
||||
import FlexBuffers
|
||||
import Foundation
|
||||
|
||||
let benchmarks = {
|
||||
let data = {
|
||||
var array = [8888.88, 8888.88]
|
||||
var data = Data()
|
||||
array.withUnsafeBytes { ptr in
|
||||
data.append(contentsOf: ptr)
|
||||
}
|
||||
return data
|
||||
}()
|
||||
let ints: [Int32] = Array(repeating: 42, count: 100)
|
||||
let str10 = (0...9).map { _ -> String in "x" }.joined()
|
||||
let str100 = (0...99).map { _ -> String in "x" }.joined()
|
||||
|
||||
// A representative map: 50 keyed scalars, a keyed string and a keyed vector
|
||||
// of 100 scalars. Used for the realistic decode benchmarks.
|
||||
let mapBuffer: ByteBuffer = {
|
||||
var fbx = FlexBuffersWriter(initialSize: 1 << 16)
|
||||
fbx.map {
|
||||
for i in 0..<50 { $0.add(int: i, key: "i\(i)") }
|
||||
$0.add(string: "hello world", key: "s")
|
||||
$0.vector(key: "v") { v in
|
||||
for x in 0..<100 { v.add(int: x) }
|
||||
}
|
||||
}
|
||||
fbx.finish()
|
||||
return fbx.sizedByteBuffer
|
||||
}()
|
||||
|
||||
let metrics: [BenchmarkMetric] = [
|
||||
.cpuTotal,
|
||||
.wallClock,
|
||||
.mallocCountTotal,
|
||||
.releaseCount,
|
||||
.peakMemoryResident,
|
||||
]
|
||||
let maxIterations = 1_000_000
|
||||
let maxDuration: Duration = .seconds(3)
|
||||
let megaConfiguration: Benchmark.Configuration = .init(
|
||||
metrics: metrics,
|
||||
warmupIterations: 1,
|
||||
scalingFactor: .mega,
|
||||
maxDuration: maxDuration,
|
||||
maxIterations: maxIterations)
|
||||
|
||||
Benchmark.defaultConfiguration = megaConfiguration
|
||||
|
||||
// Decode (read path)
|
||||
|
||||
// Raw scalar read: isolates `read<T: BitwiseCopyable>` and the `let` blob.
|
||||
Benchmark("Reading Doubles") { benchmark in
|
||||
let byteBuffer = ByteBuffer(data: data)
|
||||
benchmark.startMeasurement()
|
||||
for _ in benchmark.scaledIterations {
|
||||
blackHole(byteBuffer.read(def: Double.self, position: 0))
|
||||
}
|
||||
benchmark.stopMeasurement()
|
||||
}
|
||||
|
||||
// Realistic decode: resolve root map and read a keyed scalar.
|
||||
Benchmark("Decode Map Scalar") { benchmark in
|
||||
benchmark.startMeasurement()
|
||||
for _ in benchmark.scaledIterations {
|
||||
let map = try! getRoot(buffer: mapBuffer)!.map!
|
||||
blackHole(map["i25"]?.int)
|
||||
}
|
||||
benchmark.stopMeasurement()
|
||||
}
|
||||
|
||||
// Realistic decode: resolve root map and read a keyed string.
|
||||
Benchmark("Decode Map String") { benchmark in
|
||||
benchmark.startMeasurement()
|
||||
for _ in benchmark.scaledIterations {
|
||||
let map = try! getRoot(buffer: mapBuffer)!.map!
|
||||
blackHole(map["s"]?.string())
|
||||
}
|
||||
benchmark.stopMeasurement()
|
||||
}
|
||||
|
||||
// Realistic decode: resolve a nested vector and sum its scalars.
|
||||
Benchmark("Decode Vector") { benchmark in
|
||||
benchmark.startMeasurement()
|
||||
for _ in benchmark.scaledIterations {
|
||||
let map = try! getRoot(buffer: mapBuffer)!.map!
|
||||
let vector = map["v"]!.vector!
|
||||
var sum: Int64 = 0
|
||||
for i in 0..<vector.count {
|
||||
sum &+= vector[i]?.int ?? 0
|
||||
}
|
||||
blackHole(sum)
|
||||
}
|
||||
benchmark.stopMeasurement()
|
||||
}
|
||||
|
||||
// Encode (write path)
|
||||
// Writers are reused with `reset(keepingCapacity:)` so per-iteration
|
||||
// allocation does not dominate and mask the write-path cost (which is what
|
||||
// the `@exclusivity(unchecked)` storage pointer affects).
|
||||
|
||||
Benchmark("Strings 10") { benchmark in
|
||||
var fbx = FlexBuffersWriter(initialSize: 1 << 20)
|
||||
benchmark.startMeasurement()
|
||||
for _ in benchmark.scaledIterations {
|
||||
fbx.add(string: str10)
|
||||
fbx.finish()
|
||||
blackHole(fbx.sizedByteBuffer)
|
||||
fbx.reset(keepingCapacity: true)
|
||||
}
|
||||
benchmark.stopMeasurement()
|
||||
}
|
||||
|
||||
Benchmark("Strings 100") { benchmark in
|
||||
var fbx = FlexBuffersWriter(initialSize: 1 << 20)
|
||||
benchmark.startMeasurement()
|
||||
for _ in benchmark.scaledIterations {
|
||||
fbx.add(string: str100)
|
||||
fbx.finish()
|
||||
blackHole(fbx.sizedByteBuffer)
|
||||
fbx.reset(keepingCapacity: true)
|
||||
}
|
||||
benchmark.stopMeasurement()
|
||||
}
|
||||
|
||||
Benchmark("Encoding Vector Of Ints") { benchmark in
|
||||
var fbx = FlexBuffersWriter(initialSize: 1 << 20)
|
||||
benchmark.startMeasurement()
|
||||
for _ in benchmark.scaledIterations {
|
||||
fbx.vector {
|
||||
$0.create(vector: ints)
|
||||
}
|
||||
fbx.finish()
|
||||
blackHole(fbx.sizedByteBuffer)
|
||||
fbx.reset(keepingCapacity: true)
|
||||
}
|
||||
benchmark.stopMeasurement()
|
||||
}
|
||||
|
||||
Benchmark("Encoding Map") { benchmark in
|
||||
var fbx = FlexBuffersWriter(initialSize: 1 << 20)
|
||||
benchmark.startMeasurement()
|
||||
for _ in benchmark.scaledIterations {
|
||||
fbx.map {
|
||||
for i in 0..<50 { $0.add(int: i, key: "i\(i)") }
|
||||
$0.add(string: "hello world", key: "s")
|
||||
$0.vector(key: "v") { v in
|
||||
for x in 0..<100 { v.add(int: x) }
|
||||
}
|
||||
}
|
||||
fbx.finish()
|
||||
blackHole(fbx.sizedByteBuffer)
|
||||
fbx.reset(keepingCapacity: true)
|
||||
}
|
||||
benchmark.stopMeasurement()
|
||||
}
|
||||
}
|
||||
@@ -5,7 +5,7 @@ import 'types.dart';
|
||||
|
||||
/// The main builder class for creation of a FlexBuffer.
|
||||
class Builder {
|
||||
final ByteData _buffer;
|
||||
ByteData _buffer;
|
||||
List<_StackValue> _stack = [];
|
||||
List<_StackPointer> _stackPointers = [];
|
||||
int _offset = 0;
|
||||
@@ -506,6 +506,7 @@ class Builder {
|
||||
if (prevSize < size) {
|
||||
final newBuf = ByteData(size);
|
||||
newBuf.buffer.asUint8List().setAll(0, _buffer.buffer.asUint8List());
|
||||
_buffer = newBuf;
|
||||
}
|
||||
return newOffset;
|
||||
}
|
||||
|
||||
@@ -318,6 +318,21 @@ void main() {
|
||||
1,
|
||||
]);
|
||||
}
|
||||
{
|
||||
// Default buffer is 2048 bytes, add 2300 bytes of strings that force it
|
||||
// to grow.
|
||||
final s1 = 'A' * 1000;
|
||||
final s2 = 'B' * 800;
|
||||
final s3 = 'C' * 500;
|
||||
|
||||
var flx = Builder()
|
||||
..startVector()
|
||||
..addString(s1)
|
||||
..addString(s2)
|
||||
..addString(s3)
|
||||
..end();
|
||||
expect(flx.finish().length, 2323);
|
||||
}
|
||||
});
|
||||
|
||||
test('build map', () {
|
||||
|
||||
@@ -168,12 +168,6 @@ list of `FILES...`.
|
||||
std::string from Flatbuffers, but (char* + length). This allows efficient
|
||||
construction of custom string types, including zero-copy construction.
|
||||
|
||||
- `--cpp-vector-type T` : Set object API vector type (default std::vector).
|
||||
T must be a template taking a single element type argument and support
|
||||
resize(), reserve(), size(), data(), operator[], emplace_back() and
|
||||
begin()/end(), matching the subset of std::vector's interface generated
|
||||
code relies on.
|
||||
|
||||
- `--no-cpp-direct-copy` : Don't generate direct copy methods for C++
|
||||
object-based API.
|
||||
|
||||
|
||||
@@ -242,42 +242,6 @@ provide the following functions to aide in the serialization process:
|
||||
}
|
||||
```
|
||||
|
||||
- `bigfoot_ref_wrapper("type")` (on a struct) together with `bigfoot_ref("type")`
|
||||
(on a field of that struct type): Bigfoot-specific sugar for a
|
||||
UUID-addressed reference to another native type. `bigfoot_ref_wrapper`
|
||||
marks a struct as a reference-wrapper template (e.g. Bigfoot's
|
||||
`HardReference`/`SoftReference`); `bigfoot_ref` on a field of that type
|
||||
names the referenced native type, e.g. `bigfoot_ref: "::Bigfoot::AssetA"`
|
||||
on a `HardReference`-typed field with `bigfoot_ref_wrapper:
|
||||
"::Bigfoot::HardReference"` produces the field's native type
|
||||
`::Bigfoot::HardReference<::Bigfoot::AssetA>` (auto-deriving a
|
||||
`native_type_pack_name` of `HardReferenceAssetA`, same short-name
|
||||
convention as `native_type_pack_name`). Unlike a hand-written
|
||||
`native_type`, `bigfoot_ref` also emits, directly into the generated
|
||||
header:
|
||||
- a forward declaration of the referenced type (so the referencing
|
||||
schema's generated header never needs that type's real definition -
|
||||
only the wrapper template's constructor and a `GetUUID()` accessor
|
||||
are used, and those don't require the referenced type to be
|
||||
complete), and
|
||||
- `inline` `Pack<Name>`/`UnPack<Name>` definitions for it (so no
|
||||
hand-written implementation is required anywhere).
|
||||
|
||||
```cpp
|
||||
struct HardReference (bigfoot_ref_wrapper: "::Bigfoot::HardReference") {
|
||||
uuid: UUID;
|
||||
}
|
||||
|
||||
table AssetB {
|
||||
ref_a: HardReference (bigfoot_ref: "::Bigfoot::AssetA");
|
||||
}
|
||||
```
|
||||
|
||||
is enough on its own - no forward declaration of `::Bigfoot::AssetA` and
|
||||
no `flatbuffers::Pack/UnPackHardReferenceAssetA` implementation need to
|
||||
be written by hand. `bigfoot_ref` is only valid on fields whose type is a
|
||||
struct (or vector of structs) that declares `bigfoot_ref_wrapper`.
|
||||
|
||||
- `native_type("type")` (on a table): Tables can also be represented with
|
||||
native types. For example, the following schema:
|
||||
|
||||
@@ -373,27 +337,6 @@ constructor in the following format: `custom_str_class(const char *, size_t)`.
|
||||
Please note that the character array is not guaranteed to be NULL terminated,
|
||||
you should always use the provided size to determine end of string.
|
||||
|
||||
## Using different vector type
|
||||
|
||||
By default the object tree's vector fields are built out of `std::vector`,
|
||||
but you can influence this either globally (using the `--cpp-vector-type`
|
||||
argument to `flatc`) or per field using the `cpp_vector_type` attribute, to
|
||||
use any other vector-like template type (e.g. `eastl::vector`).
|
||||
|
||||
The type must be a template taking a single element type argument
|
||||
(`my_vector<T>`), and must support the following member functions:
|
||||
`resize()`, `reserve()`, `size()`, `data()`, `operator[]`, `emplace_back()`,
|
||||
and `begin()`/`end()`. This matches the subset of `std::vector`'s interface
|
||||
that generated code relies on.
|
||||
|
||||
Note that unlike `std::vector<bool>`, the custom vector type must not use a
|
||||
bit-packed specialization for `bool` elements, since generated code accesses
|
||||
`data()` as a contiguous `bool` array.
|
||||
|
||||
As with custom string types, the header defining the custom vector type is
|
||||
not automatically included; use `--cpp-include` to add the necessary
|
||||
`#include`.
|
||||
|
||||
## Reflection (& Resizing)
|
||||
|
||||
There is experimental support for reflection in FlatBuffers, allowing you to
|
||||
|
||||
@@ -205,6 +205,47 @@ And example of usage, for the time being, can be found in
|
||||
- Safe getters in [SafeBuffer](https://docs.rs/flatbuffers-reflection/latest/flatbuffers_reflection/struct.SafeBuffer.html),
|
||||
which does verification when constructed so you can use it for any data source
|
||||
|
||||
## Buffer pre allocation in a latency-sensitive context
|
||||
|
||||
In latency-sensitive applications, dynamic memory allocations can introduce unpredictable latency spikes. The `FlatBufferBuilder` internally uses several `Vec`s that may reallocate during serialization:
|
||||
|
||||
- The backing buffer for the FlatBuffer data
|
||||
- `field_locs` for tracking field locations within tables
|
||||
- `written_vtable_revpos` for deduplicating vtables
|
||||
- `strings_pool` for shared string interning
|
||||
|
||||
To avoid allocations during serialization, you can preallocate all internal vectors upfront using the `with_internal_capacity` constructor:
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.rs}
|
||||
// Preallocate: 1KB buffer, 8 field locations, 16 vtables, 32 shared strings
|
||||
let mut builder = FlatBufferBuilder::with_internal_capacity(1024, 8, 16, 32);
|
||||
|
||||
// All subsequent operations will not allocate (if capacities are sufficient)
|
||||
let name = builder.create_shared_string("MyMonster");
|
||||
// ... build your FlatBuffer ...
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
There are three variants available:
|
||||
|
||||
- `with_internal_capacity(size, field_locs, vtables, strings)` - Creates a new builder with all capacities preallocated
|
||||
- `from_vec_with_internal_capacity(buffer, field_locs, vtables, strings)` - Reuses an existing `Vec<u8>` as the backing buffer
|
||||
- `new_in_with_internal_capacity(allocator, field_locs, vtables, strings)` - Uses a custom `Allocator` with preallocated internal vecs
|
||||
|
||||
When combined with `reset()`, you can reuse the same builder across multiple serializations without any allocations after the initial setup:
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.rs}
|
||||
let mut builder = FlatBufferBuilder::with_internal_capacity(1024, 8, 16, 32);
|
||||
|
||||
loop {
|
||||
// Build a FlatBuffer (allocation-free if capacities are sufficient)
|
||||
let data = build_message(&mut builder);
|
||||
send(data);
|
||||
|
||||
// Reset for reuse - clears state but retains allocated capacity
|
||||
builder.reset();
|
||||
}
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
## Useful tools created by others
|
||||
|
||||
* [flatc-rust](https://github.com/frol/flatc-rust) - FlatBuffers compiler
|
||||
|
||||
@@ -427,9 +427,6 @@ Current understood attributes:
|
||||
it won't be accessible anymore by newer code. Note that if you deprecate a
|
||||
field that was previous required, old code may fail to validate new data (when
|
||||
using the optional verifier).
|
||||
|
||||
### `required`
|
||||
|
||||
- `required` (on a non-scalar table field): this field must always be set. By
|
||||
default, fields do not need to be present in the binary. This is desirable, as
|
||||
it helps with forwards/backwards compatibility, and flexibility of data
|
||||
|
||||
@@ -26,7 +26,7 @@ Simple mutation | Yes | Yes | Yes | Yes | No | No
|
||||
Reflection | Yes | No | No | No | No | No | No | Basic | No | No | No | No | No
|
||||
Buffer verifier | Yes | No | No | No | No | No | No | Yes | No | No | No | No | Yes
|
||||
Native Object API | Yes | No | Yes | Yes | Yes | Yes | Yes | No | No | Yes | No | No | Yes
|
||||
Optional Scalars | Yes | Yes | Yes | No | No | Yes | Yes | Yes | No | No | Yes | Yes | Yes
|
||||
Optional Scalars | Yes | Yes | Yes | Yes | No | Yes | Yes | Yes | No | No | Yes | Yes | Yes
|
||||
Flexbuffers | Yes | Yes | ? | ? | ? | ? | ? | ? | ? | ? | ? | Yes | Yes
|
||||
Testing: basic | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | ? | Yes | Yes | Yes | Yes
|
||||
Testing: fuzz | Yes | No | No | Yes | Yes | No | No | No | ? | No | No | Yes | No
|
||||
|
||||
+293
-268
@@ -1,297 +1,322 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
// @generated
|
||||
|
||||
extern crate alloc;
|
||||
|
||||
#[allow(unused_imports, dead_code)]
|
||||
pub mod flatbuffers {
|
||||
extern crate alloc;
|
||||
|
||||
extern crate alloc;
|
||||
#[allow(unused_imports, dead_code)]
|
||||
pub mod goldens {
|
||||
#[allow(unused_imports, dead_code)]
|
||||
pub mod goldens {
|
||||
extern crate alloc;
|
||||
|
||||
extern crate alloc;
|
||||
pub enum GalaxyOffset {}
|
||||
|
||||
pub enum GalaxyOffset {}
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
pub struct Galaxy<'a> {
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
}
|
||||
|
||||
pub struct Galaxy<'a> {
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
}
|
||||
impl<'a> ::flatbuffers::Follow<'a> for Galaxy<'a> {
|
||||
type Inner = Galaxy<'a>;
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for Galaxy<'a> {
|
||||
type Inner = Galaxy<'a>;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Galaxy<'a> {
|
||||
pub const VT_NUM_STARS: ::flatbuffers::VOffsetT = 4;
|
||||
impl<'a> Galaxy<'a> {
|
||||
pub const VT_NUM_STARS: ::flatbuffers::VOffsetT = 4;
|
||||
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
Galaxy { _tab: table }
|
||||
}
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args GalaxyArgs
|
||||
) -> ::flatbuffers::WIPOffset<Galaxy<'bldr>> {
|
||||
let mut builder = GalaxyBuilder::new(_fbb);
|
||||
builder.add_num_stars(args.num_stars);
|
||||
builder.finish()
|
||||
}
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
Galaxy { _tab: table }
|
||||
}
|
||||
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args GalaxyArgs
|
||||
) -> ::flatbuffers::WIPOffset<Galaxy<'bldr>> {
|
||||
let mut builder = GalaxyBuilder::new(_fbb);
|
||||
builder.add_num_stars(args.num_stars);
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
|
||||
#[inline]
|
||||
pub fn num_stars(&self) -> i64 {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<i64>(Galaxy::VT_NUM_STARS, Some(0)).unwrap()}
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
pub fn num_stars(&self) -> i64 {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<i64>(Galaxy::VT_NUM_STARS, Some(0)).unwrap()}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Verifiable for Galaxy<'_> {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<i64>("num_stars", Self::VT_NUM_STARS, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
pub struct GalaxyArgs {
|
||||
pub num_stars: i64,
|
||||
}
|
||||
impl<'a> Default for GalaxyArgs {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
GalaxyArgs {
|
||||
num_stars: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
impl ::flatbuffers::Verifiable for Galaxy<'_> {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<i64>("num_stars", Self::VT_NUM_STARS, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub struct GalaxyBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
}
|
||||
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GalaxyBuilder<'a, 'b, A> {
|
||||
#[inline]
|
||||
pub fn add_num_stars(&mut self, num_stars: i64) {
|
||||
self.fbb_.push_slot::<i64>(Galaxy::VT_NUM_STARS, num_stars, 0);
|
||||
}
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> GalaxyBuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
GalaxyBuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<Galaxy<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
pub struct GalaxyArgs {
|
||||
pub num_stars: i64,
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for Galaxy<'_> {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("Galaxy");
|
||||
ds.field("num_stars", &self.num_stars());
|
||||
ds.finish()
|
||||
}
|
||||
}
|
||||
pub enum UniverseOffset {}
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
impl<'a> Default for GalaxyArgs {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
GalaxyArgs {
|
||||
num_stars: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Universe<'a> {
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
}
|
||||
pub struct GalaxyBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for Universe<'a> {
|
||||
type Inner = Universe<'a>;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
}
|
||||
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GalaxyBuilder<'a, 'b, A> {
|
||||
#[inline]
|
||||
pub fn add_num_stars(&mut self, num_stars: i64) {
|
||||
self.fbb_.push_slot::<i64>(Galaxy::VT_NUM_STARS, num_stars, 0);
|
||||
}
|
||||
|
||||
impl<'a> Universe<'a> {
|
||||
pub const VT_AGE: ::flatbuffers::VOffsetT = 4;
|
||||
pub const VT_GALAXIES: ::flatbuffers::VOffsetT = 6;
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> GalaxyBuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
GalaxyBuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
Universe { _tab: table }
|
||||
}
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args UniverseArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<Universe<'bldr>> {
|
||||
let mut builder = UniverseBuilder::new(_fbb);
|
||||
builder.add_age(args.age);
|
||||
if let Some(x) = args.galaxies { builder.add_galaxies(x); }
|
||||
builder.finish()
|
||||
}
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<Galaxy<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for Galaxy<'_> {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("Galaxy");
|
||||
ds.field("num_stars", &self.num_stars());
|
||||
ds.finish()
|
||||
}
|
||||
}
|
||||
|
||||
pub enum UniverseOffset {}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
pub struct Universe<'a> {
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for Universe<'a> {
|
||||
type Inner = Universe<'a>;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Universe<'a> {
|
||||
pub const VT_AGE: ::flatbuffers::VOffsetT = 4;
|
||||
pub const VT_GALAXIES: ::flatbuffers::VOffsetT = 6;
|
||||
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
Universe { _tab: table }
|
||||
}
|
||||
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args UniverseArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<Universe<'bldr>> {
|
||||
let mut builder = UniverseBuilder::new(_fbb);
|
||||
builder.add_age(args.age);
|
||||
if let Some(x) = args.galaxies { builder.add_galaxies(x); }
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
|
||||
#[inline]
|
||||
pub fn age(&self) -> f64 {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<f64>(Universe::VT_AGE, Some(0.0)).unwrap()}
|
||||
}
|
||||
#[inline]
|
||||
pub fn galaxies(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy<'a>>>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy>>>>(Universe::VT_GALAXIES, None)}
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
pub fn age(&self) -> f64 {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<f64>(Universe::VT_AGE, Some(0.0)).unwrap()}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Verifiable for Universe<'_> {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<f64>("age", Self::VT_AGE, false)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Galaxy>>>>("galaxies", Self::VT_GALAXIES, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
pub struct UniverseArgs<'a> {
|
||||
pub age: f64,
|
||||
pub galaxies: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy<'a>>>>>,
|
||||
}
|
||||
impl<'a> Default for UniverseArgs<'a> {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
UniverseArgs {
|
||||
age: 0.0,
|
||||
galaxies: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
pub fn galaxies(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy<'a>>>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy>>>>(Universe::VT_GALAXIES, None)}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct UniverseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
}
|
||||
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UniverseBuilder<'a, 'b, A> {
|
||||
#[inline]
|
||||
pub fn add_age(&mut self, age: f64) {
|
||||
self.fbb_.push_slot::<f64>(Universe::VT_AGE, age, 0.0);
|
||||
}
|
||||
#[inline]
|
||||
pub fn add_galaxies(&mut self, galaxies: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Galaxy<'b >>>>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Universe::VT_GALAXIES, galaxies);
|
||||
}
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> UniverseBuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
UniverseBuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<Universe<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
impl ::flatbuffers::Verifiable for Universe<'_> {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<f64>("age", Self::VT_AGE, false)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Galaxy>>>>("galaxies", Self::VT_GALAXIES, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for Universe<'_> {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("Universe");
|
||||
ds.field("age", &self.age());
|
||||
ds.field("galaxies", &self.galaxies());
|
||||
ds.finish()
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
/// Verifies that a buffer of bytes contains a `Universe`
|
||||
/// and returns it.
|
||||
/// Note that verification is still experimental and may not
|
||||
/// catch every error, or be maximally performant. For the
|
||||
/// previous, unchecked, behavior use
|
||||
/// `root_as_universe_unchecked`.
|
||||
pub fn root_as_universe(buf: &[u8]) -> Result<Universe<'_>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::root::<Universe>(buf)
|
||||
}
|
||||
#[inline]
|
||||
/// Verifies that a buffer of bytes contains a size prefixed
|
||||
/// `Universe` and returns it.
|
||||
/// Note that verification is still experimental and may not
|
||||
/// catch every error, or be maximally performant. For the
|
||||
/// previous, unchecked, behavior use
|
||||
/// `size_prefixed_root_as_universe_unchecked`.
|
||||
pub fn size_prefixed_root_as_universe(buf: &[u8]) -> Result<Universe<'_>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::size_prefixed_root::<Universe>(buf)
|
||||
}
|
||||
#[inline]
|
||||
/// Verifies, with the given options, that a buffer of bytes
|
||||
/// contains a `Universe` and returns it.
|
||||
/// Note that verification is still experimental and may not
|
||||
/// catch every error, or be maximally performant. For the
|
||||
/// previous, unchecked, behavior use
|
||||
/// `root_as_universe_unchecked`.
|
||||
pub fn root_as_universe_with_opts<'b, 'o>(
|
||||
opts: &'o ::flatbuffers::VerifierOptions,
|
||||
buf: &'b [u8],
|
||||
) -> Result<Universe<'b>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::root_with_opts::<Universe<'b>>(opts, buf)
|
||||
}
|
||||
#[inline]
|
||||
/// Verifies, with the given verifier options, that a buffer of
|
||||
/// bytes contains a size prefixed `Universe` and returns
|
||||
/// it. Note that verification is still experimental and may not
|
||||
/// catch every error, or be maximally performant. For the
|
||||
/// previous, unchecked, behavior use
|
||||
/// `root_as_universe_unchecked`.
|
||||
pub fn size_prefixed_root_as_universe_with_opts<'b, 'o>(
|
||||
opts: &'o ::flatbuffers::VerifierOptions,
|
||||
buf: &'b [u8],
|
||||
) -> Result<Universe<'b>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::size_prefixed_root_with_opts::<Universe<'b>>(opts, buf)
|
||||
}
|
||||
#[inline]
|
||||
/// Assumes, without verification, that a buffer of bytes contains a Universe and returns it.
|
||||
/// # Safety
|
||||
/// Callers must trust the given bytes do indeed contain a valid `Universe`.
|
||||
pub unsafe fn root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> {
|
||||
unsafe { ::flatbuffers::root_unchecked::<Universe>(buf) }
|
||||
}
|
||||
#[inline]
|
||||
/// Assumes, without verification, that a buffer of bytes contains a size prefixed Universe and returns it.
|
||||
/// # Safety
|
||||
/// Callers must trust the given bytes do indeed contain a valid size prefixed `Universe`.
|
||||
pub unsafe fn size_prefixed_root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> {
|
||||
unsafe { ::flatbuffers::size_prefixed_root_unchecked::<Universe>(buf) }
|
||||
}
|
||||
#[inline]
|
||||
pub fn finish_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
|
||||
fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
root: ::flatbuffers::WIPOffset<Universe<'a>>) {
|
||||
fbb.finish(root, None);
|
||||
}
|
||||
pub struct UniverseArgs<'a> {
|
||||
pub age: f64,
|
||||
pub galaxies: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy<'a>>>>>,
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn finish_size_prefixed_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset<Universe<'a>>) {
|
||||
fbb.finish_size_prefixed(root, None);
|
||||
}
|
||||
} // pub mod goldens
|
||||
} // pub mod flatbuffers
|
||||
impl<'a> Default for UniverseArgs<'a> {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
UniverseArgs {
|
||||
age: 0.0,
|
||||
galaxies: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct UniverseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
}
|
||||
|
||||
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UniverseBuilder<'a, 'b, A> {
|
||||
#[inline]
|
||||
pub fn add_age(&mut self, age: f64) {
|
||||
self.fbb_.push_slot::<f64>(Universe::VT_AGE, age, 0.0);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn add_galaxies(&mut self, galaxies: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Galaxy<'b >>>>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Universe::VT_GALAXIES, galaxies);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> UniverseBuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
UniverseBuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<Universe<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for Universe<'_> {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("Universe");
|
||||
ds.field("age", &self.age());
|
||||
ds.field("galaxies", &self.galaxies());
|
||||
ds.finish()
|
||||
}
|
||||
}
|
||||
|
||||
/// Verifies that a buffer of bytes contains a `Universe`
|
||||
/// and returns it.
|
||||
/// Note that verification is still experimental and may not
|
||||
/// catch every error, or be maximally performant. For the
|
||||
/// previous, unchecked, behavior use
|
||||
/// `root_as_universe_unchecked`.
|
||||
#[inline]
|
||||
pub fn root_as_universe(buf: &[u8]) -> Result<Universe<'_>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::root::<Universe>(buf)
|
||||
}
|
||||
|
||||
/// Verifies that a buffer of bytes contains a size prefixed
|
||||
/// `Universe` and returns it.
|
||||
/// Note that verification is still experimental and may not
|
||||
/// catch every error, or be maximally performant. For the
|
||||
/// previous, unchecked, behavior use
|
||||
/// `size_prefixed_root_as_universe_unchecked`.
|
||||
#[inline]
|
||||
pub fn size_prefixed_root_as_universe(buf: &[u8]) -> Result<Universe<'_>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::size_prefixed_root::<Universe>(buf)
|
||||
}
|
||||
|
||||
/// Verifies, with the given options, that a buffer of bytes
|
||||
/// contains a `Universe` and returns it.
|
||||
/// Note that verification is still experimental and may not
|
||||
/// catch every error, or be maximally performant. For the
|
||||
/// previous, unchecked, behavior use
|
||||
/// `root_as_universe_unchecked`.
|
||||
#[inline]
|
||||
pub fn root_as_universe_with_opts<'b, 'o>(
|
||||
opts: &'o ::flatbuffers::VerifierOptions,
|
||||
buf: &'b [u8],
|
||||
) -> Result<Universe<'b>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::root_with_opts::<Universe<'b>>(opts, buf)
|
||||
}
|
||||
|
||||
/// Verifies, with the given verifier options, that a buffer of
|
||||
/// bytes contains a size prefixed `Universe` and returns
|
||||
/// it. Note that verification is still experimental and may not
|
||||
/// catch every error, or be maximally performant. For the
|
||||
/// previous, unchecked, behavior use
|
||||
/// `root_as_universe_unchecked`.
|
||||
#[inline]
|
||||
pub fn size_prefixed_root_as_universe_with_opts<'b, 'o>(
|
||||
opts: &'o ::flatbuffers::VerifierOptions,
|
||||
buf: &'b [u8],
|
||||
) -> Result<Universe<'b>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::size_prefixed_root_with_opts::<Universe<'b>>(opts, buf)
|
||||
}
|
||||
|
||||
/// Assumes, without verification, that a buffer of bytes contains a Universe and returns it.
|
||||
/// # Safety
|
||||
/// Callers must trust the given bytes do indeed contain a valid `Universe`.
|
||||
#[inline]
|
||||
pub unsafe fn root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> {
|
||||
unsafe { ::flatbuffers::root_unchecked::<Universe>(buf) }
|
||||
}
|
||||
|
||||
/// Assumes, without verification, that a buffer of bytes contains a size prefixed Universe and returns it.
|
||||
/// # Safety
|
||||
/// Callers must trust the given bytes do indeed contain a valid size prefixed `Universe`.
|
||||
#[inline]
|
||||
pub unsafe fn size_prefixed_root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> {
|
||||
unsafe { ::flatbuffers::size_prefixed_root_unchecked::<Universe>(buf) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn finish_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
|
||||
fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
root: ::flatbuffers::WIPOffset<Universe<'a>>
|
||||
) {
|
||||
fbb.finish(root, None);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn finish_size_prefixed_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
|
||||
fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
root: ::flatbuffers::WIPOffset<Universe<'a>>
|
||||
) {
|
||||
fbb.finish_size_prefixed(root, None);
|
||||
}
|
||||
} // pub mod goldens
|
||||
} // pub mod flatbuffers
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
import * as flatbuffers from 'flatbuffers';
|
||||
|
||||
import { Galaxy } from '../../flatbuffers/goldens/galaxy.js';
|
||||
import { Galaxy } from './galaxy.js';
|
||||
|
||||
|
||||
export class Universe {
|
||||
|
||||
@@ -1,16 +0,0 @@
|
||||
namespace models;
|
||||
|
||||
table HelloResponse {
|
||||
message:string;
|
||||
}
|
||||
|
||||
table HelloRequest {
|
||||
name:string;
|
||||
}
|
||||
|
||||
rpc_service Greeter {
|
||||
Get(HelloRequest):HelloResponse;
|
||||
Collect(HelloRequest):HelloResponse (streaming: "client");
|
||||
Expand(HelloRequest):HelloResponse (streaming: "server");
|
||||
Update(HelloRequest):HelloResponse (streaming: "bidi");
|
||||
}
|
||||
@@ -1,28 +0,0 @@
|
||||
/*
|
||||
* Copyright 2024 Google Inc. All rights reserved.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
import ArgumentParser
|
||||
|
||||
let port = 3000
|
||||
|
||||
@main
|
||||
struct GreeterCommand: AsyncParsableCommand {
|
||||
static let configuration = CommandConfiguration(
|
||||
commandName: "greeter",
|
||||
abstract: "A multi-tool to run an echo server and execute RPCs against it.",
|
||||
subcommands: [ServerCommand.self, ClientCommand.self])
|
||||
}
|
||||
|
||||
@@ -1,121 +0,0 @@
|
||||
/*
|
||||
* Copyright 2024 Google Inc. All rights reserved.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
import FlatBuffers
|
||||
import GRPCCore
|
||||
import Models
|
||||
|
||||
struct GreeterService: models_Greeter.SimpleServiceProtocol {
|
||||
func Get(
|
||||
request: GRPCMessage<models_HelloResponse>,
|
||||
context: GRPCCore
|
||||
.ServerContext) async throws -> GRPCMessage<models_HelloResponse>
|
||||
{
|
||||
let model = try request.decode()
|
||||
print("## GreeterService.Get: \(model.message)")
|
||||
|
||||
var builder = FlatBufferBuilder(initialSize: 128)
|
||||
let off = builder.create(string: "Hello \(model.message ?? "Unknown")")
|
||||
let root = models_HelloResponse.createHelloResponse(
|
||||
&builder,
|
||||
messageOffset: off)
|
||||
builder.finish(offset: root)
|
||||
return try GRPCMessage<models_HelloResponse>(builder: &builder)
|
||||
}
|
||||
|
||||
func Collect(
|
||||
request: GRPCCore.RPCAsyncSequence<
|
||||
GRPCMessage<models_HelloResponse>,
|
||||
any Swift.Error
|
||||
>,
|
||||
context: GRPCCore
|
||||
.ServerContext) async throws -> GRPCMessage<models_HelloResponse>
|
||||
{
|
||||
let messages: [String] = try await request
|
||||
.reduce(into: []) { array, message in
|
||||
let model = try message.decode()
|
||||
return array.append(model.message ?? "Unknown")
|
||||
}
|
||||
|
||||
let joined = messages.joined(separator: ", ")
|
||||
print("## GreeterService.Collect: \(joined)")
|
||||
|
||||
var builder = FlatBufferBuilder(initialSize: 128)
|
||||
let off = builder.create(string: "Hello \(joined)")
|
||||
let root = models_HelloResponse.createHelloResponse(
|
||||
&builder,
|
||||
messageOffset: off)
|
||||
builder.finish(offset: root)
|
||||
return try GRPCMessage<models_HelloResponse>(builder: &builder)
|
||||
}
|
||||
|
||||
func Expand(
|
||||
request: GRPCMessage<models_HelloResponse>,
|
||||
response: GRPCCore.RPCWriter<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext) async throws
|
||||
{
|
||||
|
||||
let model = try request.decode()
|
||||
print("## GreeterService.Expand: \(model.message)")
|
||||
|
||||
let message = model.message ?? "Unknown"
|
||||
let stream = AsyncThrowingStream<
|
||||
GRPCMessage<models_HelloResponse>,
|
||||
Error
|
||||
> { continuation in
|
||||
var builder = FlatBufferBuilder(initialSize: 128)
|
||||
for char in message {
|
||||
let off = builder.create(string: "\(char)")
|
||||
let root = models_HelloResponse.createHelloResponse(
|
||||
&builder,
|
||||
messageOffset: off)
|
||||
builder.finish(offset: root)
|
||||
|
||||
do {
|
||||
continuation
|
||||
.yield(try GRPCMessage<models_HelloResponse>(builder: &builder))
|
||||
} catch {
|
||||
continuation.finish(throwing: error)
|
||||
}
|
||||
}
|
||||
|
||||
continuation.finish()
|
||||
}
|
||||
try await response.write(contentsOf: stream)
|
||||
}
|
||||
|
||||
func Update(
|
||||
request: GRPCCore.RPCAsyncSequence<
|
||||
GRPCMessage<models_HelloResponse>,
|
||||
any Swift.Error
|
||||
>,
|
||||
response: GRPCCore.RPCWriter<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext) async throws
|
||||
{
|
||||
for try await message in request {
|
||||
let model = try message.decode()
|
||||
print("## GreeterService.Update: \(model.message)")
|
||||
var builder = FlatBufferBuilder(initialSize: 128)
|
||||
let off = builder.create(string: "Hello \(model.message ?? "Unknown")")
|
||||
let root = models_HelloResponse.createHelloResponse(
|
||||
&builder,
|
||||
messageOffset: off)
|
||||
builder.finish(offset: root)
|
||||
try await response
|
||||
.write(try GRPCMessage<models_HelloResponse>(builder: &builder))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,140 +0,0 @@
|
||||
/*
|
||||
* Copyright 2024 Google Inc. All rights reserved.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
import ArgumentParser
|
||||
import FlatBuffers
|
||||
import GRPCCore
|
||||
import GRPCNIOTransportHTTP2
|
||||
import Models
|
||||
|
||||
enum ClientRequest: String, ExpressibleByArgument {
|
||||
case get, expand, collect, update
|
||||
}
|
||||
|
||||
struct ClientCommand: AsyncParsableCommand {
|
||||
static let configuration = CommandConfiguration(
|
||||
commandName: "client")
|
||||
|
||||
@Option(help: "Name to send to the server")
|
||||
var name: String
|
||||
|
||||
@Option(help: "request type")
|
||||
var request: ClientRequest
|
||||
|
||||
func run() async throws {
|
||||
try await withGRPCClient(
|
||||
transport: .http2NIOPosix(
|
||||
target: .dns(host: "localhost", port: port),
|
||||
transportSecurity: .plaintext))
|
||||
{
|
||||
let client = models_Greeter.Client(wrapping: $0)
|
||||
|
||||
switch request {
|
||||
case .get: try await get(client: client)
|
||||
case .expand: try await expand(client: client)
|
||||
case .collect: try await collect(client: client)
|
||||
case .update: try await update(client: client)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func get(
|
||||
client: models_Greeter
|
||||
.Client<HTTP2ClientTransport.Posix>) async throws
|
||||
{
|
||||
for _ in 0..<3 {
|
||||
var builder = FlatBufferBuilder(initialSize: 64)
|
||||
let off = builder.create(string: name)
|
||||
let root = models_HelloRequest.createHelloRequest(
|
||||
&builder,
|
||||
nameOffset: off)
|
||||
builder.finish(offset: root)
|
||||
|
||||
let response = try await client
|
||||
.Get(GRPCMessage(builder: &builder))
|
||||
let message = try? response.decode().message
|
||||
print("get message: \(message ?? "nil")")
|
||||
}
|
||||
}
|
||||
|
||||
func expand(
|
||||
client: models_Greeter
|
||||
.Client<HTTP2ClientTransport.Posix>) async throws
|
||||
{
|
||||
for _ in 0..<3 {
|
||||
var builder = FlatBufferBuilder(initialSize: 64)
|
||||
let off = builder.create(string: name)
|
||||
let root = models_HelloRequest.createHelloRequest(
|
||||
&builder,
|
||||
nameOffset: off)
|
||||
builder.finish(offset: root)
|
||||
try await client.Expand(GRPCMessage(builder: &builder)) { response in
|
||||
for try await message in response.messages {
|
||||
let message = try? message.decode().message
|
||||
print("expand message: \(message ?? "nil")")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func collect(
|
||||
client: models_Greeter
|
||||
.Client<HTTP2ClientTransport.Posix>) async throws
|
||||
{
|
||||
for _ in 0..<3 {
|
||||
let response = try await client.Collect { writer in
|
||||
for part in name {
|
||||
print("collect sending: \(part)")
|
||||
var builder = FlatBufferBuilder(initialSize: 64)
|
||||
let off = builder.create(string: String(part))
|
||||
let root = models_HelloRequest.createHelloRequest(
|
||||
&builder,
|
||||
nameOffset: off)
|
||||
builder.finish(offset: root)
|
||||
try await writer.write(GRPCMessage(builder: &builder))
|
||||
}
|
||||
}
|
||||
|
||||
let message = try response.decode().message
|
||||
print("collect message: \(message ?? "nil")")
|
||||
}
|
||||
}
|
||||
|
||||
func update(
|
||||
client: models_Greeter
|
||||
.Client<HTTP2ClientTransport.Posix>) async throws
|
||||
{
|
||||
for _ in 0..<3 {
|
||||
try await client.Update { writer in
|
||||
for part in name {
|
||||
print("update sending: \(part)")
|
||||
var builder = FlatBufferBuilder(initialSize: 64)
|
||||
let off = builder.create(string: String(part))
|
||||
let root = models_HelloRequest.createHelloRequest(
|
||||
&builder,
|
||||
nameOffset: off)
|
||||
builder.finish(offset: root)
|
||||
try await writer.write(GRPCMessage(builder: &builder))
|
||||
}
|
||||
} onResponse: { response in
|
||||
for try await message in response.messages {
|
||||
let message = try message.decode().message
|
||||
print("collect message: \(message ?? "nil")")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
/*
|
||||
* Copyright 2024 Google Inc. All rights reserved.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
import ArgumentParser
|
||||
import GRPCCore
|
||||
import GRPCNIOTransportHTTP2
|
||||
|
||||
struct ServerCommand: AsyncParsableCommand {
|
||||
static let configuration = CommandConfiguration(
|
||||
commandName: "serve")
|
||||
|
||||
func run() async throws {
|
||||
let server = GRPCServer(
|
||||
transport: .http2NIOPosix(
|
||||
address: .ipv4(host: "127.0.0.1", port: port),
|
||||
transportSecurity: .plaintext),
|
||||
services: [GreeterService()])
|
||||
|
||||
try await withThrowingDiscardingTaskGroup { group in
|
||||
group.addTask { try await server.serve() }
|
||||
if let address = try await server.listeningAddress {
|
||||
print("Echo listening on \(address)")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -17,16 +17,14 @@ public struct models_HelloReply: FlatBufferTable, FlatbuffersVectorInitializable
|
||||
private init(_ t: Table) { _accessor = t }
|
||||
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
|
||||
|
||||
private enum VTOFFSET: VOffset {
|
||||
case message = 4
|
||||
var v: Int32 { Int32(self.rawValue) }
|
||||
var p: VOffset { self.rawValue }
|
||||
private struct VT {
|
||||
static let message: VOffset = 4
|
||||
}
|
||||
|
||||
public var message: String? { let o = _accessor.offset(VTOFFSET.message.v); return o == 0 ? nil : _accessor.string(at: o) }
|
||||
public var messageSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.message.v) }
|
||||
public var message: String? { let o = _accessor.offset(VT.message); return o == 0 ? nil : _accessor.string(at: o) }
|
||||
public var messageSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.message) }
|
||||
public static func startHelloReply(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
|
||||
public static func add(message: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: message, at: VTOFFSET.message.p) }
|
||||
public static func add(message: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: message, at: VT.message) }
|
||||
public static func endHelloReply(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
|
||||
public static func createHelloReply(
|
||||
_ fbb: inout FlatBufferBuilder,
|
||||
@@ -39,16 +37,16 @@ public struct models_HelloReply: FlatBufferTable, FlatbuffersVectorInitializable
|
||||
|
||||
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
|
||||
var _v = try verifier.visitTable(at: position)
|
||||
try _v.visit(field: VTOFFSET.message.p, fieldName: "message", required: false, type: ForwardOffset<String>.self)
|
||||
try _v.visit(field: VT.message, fieldName: "message", required: false, type: ForwardOffset<String>.self)
|
||||
_v.finish()
|
||||
}
|
||||
}
|
||||
|
||||
extension models_HelloReply: Encodable {
|
||||
|
||||
enum CodingKeys: String, CodingKey {
|
||||
case message = "message"
|
||||
}
|
||||
|
||||
public func encode(to encoder: Encoder) throws {
|
||||
var container = encoder.container(keyedBy: CodingKeys.self)
|
||||
try container.encodeIfPresent(message, forKey: .message)
|
||||
@@ -64,16 +62,14 @@ public struct models_HelloRequest: FlatBufferTable, FlatbuffersVectorInitializab
|
||||
private init(_ t: Table) { _accessor = t }
|
||||
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
|
||||
|
||||
private enum VTOFFSET: VOffset {
|
||||
case name = 4
|
||||
var v: Int32 { Int32(self.rawValue) }
|
||||
var p: VOffset { self.rawValue }
|
||||
private struct VT {
|
||||
static let name: VOffset = 4
|
||||
}
|
||||
|
||||
public var name: String? { let o = _accessor.offset(VTOFFSET.name.v); return o == 0 ? nil : _accessor.string(at: o) }
|
||||
public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.name.v) }
|
||||
public var name: String? { let o = _accessor.offset(VT.name); return o == 0 ? nil : _accessor.string(at: o) }
|
||||
public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.name) }
|
||||
public static func startHelloRequest(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
|
||||
public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VTOFFSET.name.p) }
|
||||
public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VT.name) }
|
||||
public static func endHelloRequest(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
|
||||
public static func createHelloRequest(
|
||||
_ fbb: inout FlatBufferBuilder,
|
||||
@@ -86,16 +82,16 @@ public struct models_HelloRequest: FlatBufferTable, FlatbuffersVectorInitializab
|
||||
|
||||
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
|
||||
var _v = try verifier.visitTable(at: position)
|
||||
try _v.visit(field: VTOFFSET.name.p, fieldName: "name", required: false, type: ForwardOffset<String>.self)
|
||||
try _v.visit(field: VT.name, fieldName: "name", required: false, type: ForwardOffset<String>.self)
|
||||
_v.finish()
|
||||
}
|
||||
}
|
||||
|
||||
extension models_HelloRequest: Encodable {
|
||||
|
||||
enum CodingKeys: String, CodingKey {
|
||||
case name = "name"
|
||||
}
|
||||
|
||||
public func encode(to encoder: Encoder) throws {
|
||||
var container = encoder.container(keyedBy: CodingKeys.self)
|
||||
try container.encodeIfPresent(name, forKey: .name)
|
||||
|
||||
@@ -1,572 +0,0 @@
|
||||
// Generated GRPC code for FlatBuffers swift!
|
||||
/// The following code is generated by the Flatbuffers library which might not be in sync with grpc-swift
|
||||
/// in case of an issue please open github issue, though it would be maintained
|
||||
|
||||
// swiftlint:disable all
|
||||
// swiftformat:disable all
|
||||
|
||||
#if !os(Windows) && compiler(>=6.0)
|
||||
import FlatBuffers
|
||||
import Foundation
|
||||
import GRPCCore
|
||||
import GRPCNIOTransportCore
|
||||
|
||||
|
||||
/// Usage: instantiate models.GreeterServiceClient, then call methods of this protocol to make API calls.
|
||||
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
|
||||
extension FlatBuffersMessageSerializer: MessageSerializer {
|
||||
public func serialize<Bytes>(_ message: Message) throws -> Bytes where Bytes : GRPCCore.GRPCContiguousBytes {
|
||||
do {
|
||||
return try self.serialize(message: message) { GRPCNIOTransportBytes($0) } as! Bytes
|
||||
} catch let error {
|
||||
throw RPCError(
|
||||
code: .invalidArgument,
|
||||
message: "Can't serialize message",
|
||||
cause: error
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
|
||||
extension FlatBuffersMessageDeserializer: MessageDeserializer {
|
||||
public func deserialize<Bytes>(_ serializedMessageBytes: Bytes) throws -> Message where Bytes : GRPCCore.GRPCContiguousBytes {
|
||||
do {
|
||||
return try serializedMessageBytes.withUnsafeBytes {
|
||||
try self.deserialize(pointer: $0)
|
||||
}
|
||||
} catch let error {
|
||||
throw RPCError(
|
||||
code: .invalidArgument,
|
||||
message: "Can't Decode message of type \(Message.self)",
|
||||
cause: error
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
|
||||
public enum models_Greeter: Sendable {
|
||||
public static let descriptor = GRPCCore.ServiceDescriptor(fullyQualifiedService: "models.Greeter")
|
||||
public enum Method: Sendable {
|
||||
public enum Get: Sendable {
|
||||
public typealias Input = FlatBufferBuilder
|
||||
public typealias Output = models_HelloResponse
|
||||
public static let descriptor = GRPCCore.MethodDescriptor(
|
||||
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "models.Greeter"),
|
||||
method: "Get"
|
||||
)
|
||||
}
|
||||
public enum Collect: Sendable {
|
||||
public typealias Input = FlatBufferBuilder
|
||||
public typealias Output = models_HelloResponse
|
||||
public static let descriptor = GRPCCore.MethodDescriptor(
|
||||
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "models.Greeter"),
|
||||
method: "Collect"
|
||||
)
|
||||
}
|
||||
public enum Expand: Sendable {
|
||||
public typealias Input = FlatBufferBuilder
|
||||
public typealias Output = models_HelloResponse
|
||||
public static let descriptor = GRPCCore.MethodDescriptor(
|
||||
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "models.Greeter"),
|
||||
method: "Expand"
|
||||
)
|
||||
}
|
||||
public enum Update: Sendable {
|
||||
public typealias Input = FlatBufferBuilder
|
||||
public typealias Output = models_HelloResponse
|
||||
public static let descriptor = GRPCCore.MethodDescriptor(
|
||||
service: GRPCCore.ServiceDescriptor(fullyQualifiedService: "models.Greeter"),
|
||||
method: "Update"
|
||||
)
|
||||
}
|
||||
public static let descriptors: [GRPCCore.MethodDescriptor] = [
|
||||
Get.descriptor,
|
||||
Collect.descriptor,
|
||||
Expand.descriptor,
|
||||
Update.descriptor,
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
|
||||
extension GRPCCore.ServiceDescriptor {
|
||||
public static let models_Greeter = GRPCCore.ServiceDescriptor(fullyQualifiedService: "models.Greeter")
|
||||
}
|
||||
|
||||
// MARK: models.Greeter Server
|
||||
|
||||
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
|
||||
extension models_Greeter {
|
||||
public protocol StreamingServiceProtocol: GRPCCore.RegistrableRPCService {
|
||||
func Get(
|
||||
request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>
|
||||
|
||||
func Collect(
|
||||
request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>
|
||||
|
||||
func Expand(
|
||||
request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>
|
||||
|
||||
func Update(
|
||||
request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>
|
||||
|
||||
}
|
||||
|
||||
public protocol ServiceProtocol: models_Greeter.StreamingServiceProtocol {
|
||||
func Get(
|
||||
request: GRPCCore.ServerRequest<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws -> GRPCCore.ServerResponse<GRPCMessage<models_HelloResponse>>
|
||||
|
||||
func Collect(
|
||||
request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws -> GRPCCore.ServerResponse<GRPCMessage<models_HelloResponse>>
|
||||
|
||||
func Expand(
|
||||
request: GRPCCore.ServerRequest<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>
|
||||
|
||||
func Update(
|
||||
request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>
|
||||
|
||||
}
|
||||
|
||||
public protocol SimpleServiceProtocol: models_Greeter.ServiceProtocol {
|
||||
func Get(
|
||||
request: GRPCMessage<models_HelloResponse>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws -> GRPCMessage<models_HelloResponse>
|
||||
|
||||
func Collect(
|
||||
request: GRPCCore.RPCAsyncSequence<GRPCMessage<models_HelloResponse>, any Swift.Error>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws -> GRPCMessage<models_HelloResponse>
|
||||
|
||||
func Expand(
|
||||
request: GRPCMessage<models_HelloResponse>,
|
||||
response: GRPCCore.RPCWriter<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws
|
||||
|
||||
func Update(
|
||||
request: GRPCCore.RPCAsyncSequence<GRPCMessage<models_HelloResponse>, any Swift.Error>,
|
||||
response: GRPCCore.RPCWriter<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
|
||||
extension models_Greeter.StreamingServiceProtocol {
|
||||
public func registerMethods<Transport>(with router: inout GRPCCore.RPCRouter<Transport>) where Transport: GRPCCore.ServerTransport {
|
||||
router.registerHandler(
|
||||
forMethod: models_Greeter.Method.Get.descriptor,
|
||||
deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
|
||||
serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
|
||||
handler: { request, context in
|
||||
try await self.Get(
|
||||
request: request,
|
||||
context: context
|
||||
)
|
||||
}
|
||||
)
|
||||
router.registerHandler(
|
||||
forMethod: models_Greeter.Method.Collect.descriptor,
|
||||
deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
|
||||
serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
|
||||
handler: { request, context in
|
||||
try await self.Collect(
|
||||
request: request,
|
||||
context: context
|
||||
)
|
||||
}
|
||||
)
|
||||
router.registerHandler(
|
||||
forMethod: models_Greeter.Method.Expand.descriptor,
|
||||
deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
|
||||
serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
|
||||
handler: { request, context in
|
||||
try await self.Expand(
|
||||
request: request,
|
||||
context: context
|
||||
)
|
||||
}
|
||||
)
|
||||
router.registerHandler(
|
||||
forMethod: models_Greeter.Method.Update.descriptor,
|
||||
deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
|
||||
serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
|
||||
handler: { request, context in
|
||||
try await self.Update(
|
||||
request: request,
|
||||
context: context
|
||||
)
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
|
||||
extension models_Greeter.ServiceProtocol {
|
||||
public func Get(
|
||||
request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>> {
|
||||
let response = try await self.Get(
|
||||
request: GRPCCore.ServerRequest(stream: request),
|
||||
context: context
|
||||
)
|
||||
return GRPCCore.StreamingServerResponse(single: response)
|
||||
}
|
||||
public func Collect(
|
||||
request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>> {
|
||||
let response = try await self.Collect(
|
||||
request: request,
|
||||
context: context
|
||||
)
|
||||
return GRPCCore.StreamingServerResponse(single: response)
|
||||
}
|
||||
public func Expand(
|
||||
request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>> {
|
||||
let response = try await self.Expand(
|
||||
request: GRPCCore.ServerRequest(stream: request),
|
||||
context: context
|
||||
)
|
||||
return response
|
||||
}
|
||||
}
|
||||
|
||||
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
|
||||
extension models_Greeter.SimpleServiceProtocol {
|
||||
public func Get(
|
||||
request: GRPCCore.ServerRequest<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws -> GRPCCore.ServerResponse<GRPCMessage<models_HelloResponse>> {
|
||||
return GRPCCore.ServerResponse<GRPCMessage<models_HelloResponse>>(
|
||||
message: try await self.Get(
|
||||
request: request.message,
|
||||
context: context
|
||||
),
|
||||
metadata: [:]
|
||||
)
|
||||
}
|
||||
public func Collect(
|
||||
request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws -> GRPCCore.ServerResponse<GRPCMessage<models_HelloResponse>> {
|
||||
return GRPCCore.ServerResponse<GRPCMessage<models_HelloResponse>>(
|
||||
message: try await self.Collect(
|
||||
request: request.messages,
|
||||
context: context
|
||||
),
|
||||
metadata: [:]
|
||||
)
|
||||
}
|
||||
public func Expand(
|
||||
request: GRPCCore.ServerRequest<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>> {
|
||||
return GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>(
|
||||
metadata: [:],
|
||||
producer: { writer in
|
||||
try await self.Expand(
|
||||
request: request.message,
|
||||
response: writer,
|
||||
context: context
|
||||
)
|
||||
return [:]
|
||||
}
|
||||
)
|
||||
}
|
||||
public func Update(
|
||||
request: GRPCCore.StreamingServerRequest<GRPCMessage<models_HelloResponse>>,
|
||||
context: GRPCCore.ServerContext
|
||||
) async throws -> GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>> {
|
||||
return GRPCCore.StreamingServerResponse<GRPCMessage<models_HelloResponse>>(
|
||||
metadata: [:],
|
||||
producer: { writer in
|
||||
try await self.Update(
|
||||
request: request.messages,
|
||||
response: writer,
|
||||
context: context
|
||||
)
|
||||
return [:]
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// MARK: models.Greeter Client
|
||||
|
||||
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
|
||||
extension models_Greeter {
|
||||
public protocol ClientProtocol: Sendable {
|
||||
func Get<Result>(
|
||||
request: GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>,
|
||||
serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
|
||||
deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
|
||||
options: GRPCCore.CallOptions,
|
||||
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
|
||||
) async throws -> Result where Result: Sendable
|
||||
|
||||
func Collect<Result>(
|
||||
request: GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>,
|
||||
serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
|
||||
deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
|
||||
options: GRPCCore.CallOptions,
|
||||
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
|
||||
) async throws -> Result where Result: Sendable
|
||||
|
||||
func Expand<Result>(
|
||||
request: GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>,
|
||||
serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
|
||||
deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
|
||||
options: GRPCCore.CallOptions,
|
||||
onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
|
||||
) async throws -> Result where Result: Sendable
|
||||
|
||||
func Update<Result>(
|
||||
request: GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>,
|
||||
serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
|
||||
deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
|
||||
options: GRPCCore.CallOptions,
|
||||
onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
|
||||
) async throws -> Result where Result: Sendable
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
|
||||
extension models_Greeter {
|
||||
public struct Client<Transport>: ClientProtocol where Transport: GRPCCore.ClientTransport {
|
||||
private let client: GRPCCore.GRPCClient<Transport>
|
||||
|
||||
public init(wrapping client: GRPCCore.GRPCClient<Transport>) {
|
||||
self.client = client
|
||||
}
|
||||
|
||||
public func Get<Result>(
|
||||
request: GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>,
|
||||
serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
|
||||
deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
|
||||
options: GRPCCore.CallOptions = .defaults,
|
||||
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result = { response in try response.message }
|
||||
) async throws -> Result where Result: Sendable {
|
||||
try await self.client.unary(
|
||||
request: request,
|
||||
descriptor: models_Greeter.Method.Get.descriptor,
|
||||
serializer: serializer,
|
||||
deserializer: deserializer,
|
||||
options: options,
|
||||
onResponse: handleResponse
|
||||
)
|
||||
}
|
||||
|
||||
public func Collect<Result>(
|
||||
request: GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>,
|
||||
serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
|
||||
deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
|
||||
options: GRPCCore.CallOptions = .defaults,
|
||||
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result = { response in try response.message }
|
||||
) async throws -> Result where Result: Sendable {
|
||||
try await self.client.clientStreaming(
|
||||
request: request,
|
||||
descriptor: models_Greeter.Method.Collect.descriptor,
|
||||
serializer: serializer,
|
||||
deserializer: deserializer,
|
||||
options: options,
|
||||
onResponse: handleResponse
|
||||
)
|
||||
}
|
||||
|
||||
public func Expand<Result>(
|
||||
request: GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>,
|
||||
serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
|
||||
deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
|
||||
options: GRPCCore.CallOptions = .defaults,
|
||||
onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
|
||||
) async throws -> Result where Result: Sendable {
|
||||
try await self.client.serverStreaming(
|
||||
request: request,
|
||||
descriptor: models_Greeter.Method.Expand.descriptor,
|
||||
serializer: serializer,
|
||||
deserializer: deserializer,
|
||||
options: options,
|
||||
onResponse: handleResponse
|
||||
)
|
||||
}
|
||||
|
||||
public func Update<Result>(
|
||||
request: GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>,
|
||||
serializer: some GRPCCore.MessageSerializer<GRPCMessage<models_HelloResponse>>,
|
||||
deserializer: some GRPCCore.MessageDeserializer<GRPCMessage<models_HelloResponse>>,
|
||||
options: GRPCCore.CallOptions = .defaults,
|
||||
onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
|
||||
) async throws -> Result where Result: Sendable {
|
||||
try await self.client.bidirectionalStreaming(
|
||||
request: request,
|
||||
descriptor: models_Greeter.Method.Update.descriptor,
|
||||
serializer: serializer,
|
||||
deserializer: deserializer,
|
||||
options: options,
|
||||
onResponse: handleResponse
|
||||
)
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
|
||||
extension models_Greeter.ClientProtocol {
|
||||
public func Get<Result>(
|
||||
request: GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>,
|
||||
options: GRPCCore.CallOptions = .defaults,
|
||||
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result = { response in try response.message }
|
||||
) async throws -> Result where Result: Sendable {
|
||||
try await self.Get(
|
||||
request: request,
|
||||
serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
|
||||
deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
|
||||
options: options,
|
||||
onResponse: handleResponse
|
||||
)
|
||||
}
|
||||
|
||||
public func Collect<Result>(
|
||||
request: GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>,
|
||||
options: GRPCCore.CallOptions = .defaults,
|
||||
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result = { response in try response.message }
|
||||
) async throws -> Result where Result: Sendable {
|
||||
try await self.Collect(
|
||||
request: request,
|
||||
serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
|
||||
deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
|
||||
options: options,
|
||||
onResponse: handleResponse
|
||||
)
|
||||
}
|
||||
|
||||
public func Expand<Result>(
|
||||
request: GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>,
|
||||
options: GRPCCore.CallOptions = .defaults,
|
||||
onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
|
||||
) async throws -> Result where Result: Sendable {
|
||||
try await self.Expand(
|
||||
request: request,
|
||||
serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
|
||||
deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
|
||||
options: options,
|
||||
onResponse: handleResponse
|
||||
)
|
||||
}
|
||||
|
||||
public func Update<Result>(
|
||||
request: GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>,
|
||||
options: GRPCCore.CallOptions = .defaults,
|
||||
onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
|
||||
) async throws -> Result where Result: Sendable {
|
||||
try await self.Update(
|
||||
request: request,
|
||||
serializer: FlatBuffersMessageSerializer<GRPCMessage<models_HelloResponse>>(),
|
||||
deserializer: FlatBuffersMessageDeserializer<GRPCMessage<models_HelloResponse>>(),
|
||||
options: options,
|
||||
onResponse: handleResponse
|
||||
)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
|
||||
extension models_Greeter.ClientProtocol {
|
||||
public func Get<Result>(
|
||||
_ message: GRPCMessage<models_HelloResponse>,
|
||||
metadata: GRPCCore.Metadata = [:],
|
||||
options: GRPCCore.CallOptions = .defaults,
|
||||
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result = { try $0.message }
|
||||
) async throws -> Result where Result: Sendable {
|
||||
let request = GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>(
|
||||
message: message,
|
||||
metadata: metadata
|
||||
)
|
||||
return try await self.Get(
|
||||
request: request,
|
||||
options: options,
|
||||
onResponse: handleResponse
|
||||
)
|
||||
}
|
||||
|
||||
public func Collect<Result>(
|
||||
metadata: GRPCCore.Metadata = [:],
|
||||
options: GRPCCore.CallOptions = .defaults,
|
||||
requestProducer producer: @Sendable @escaping (GRPCCore.RPCWriter<GRPCMessage<models_HelloResponse>>) async throws -> Void,
|
||||
onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result = { try $0.message }
|
||||
) async throws -> Result where Result: Sendable {
|
||||
let request = GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>(
|
||||
metadata: metadata,
|
||||
producer: producer
|
||||
)
|
||||
return try await self.Collect(
|
||||
request: request,
|
||||
options: options,
|
||||
onResponse: handleResponse
|
||||
)
|
||||
}
|
||||
|
||||
public func Expand<Result>(
|
||||
_ message: GRPCMessage<models_HelloResponse>,
|
||||
metadata: GRPCCore.Metadata = [:],
|
||||
options: GRPCCore.CallOptions = .defaults,
|
||||
onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
|
||||
) async throws -> Result where Result: Sendable {
|
||||
let request = GRPCCore.ClientRequest<GRPCMessage<models_HelloResponse>>(
|
||||
message: message,
|
||||
metadata: metadata
|
||||
)
|
||||
return try await self.Expand(
|
||||
request: request,
|
||||
options: options,
|
||||
onResponse: handleResponse
|
||||
)
|
||||
}
|
||||
|
||||
public func Update<Result>(
|
||||
metadata: GRPCCore.Metadata = [:],
|
||||
options: GRPCCore.CallOptions = .defaults,
|
||||
requestProducer producer: @Sendable @escaping (GRPCCore.RPCWriter<GRPCMessage<models_HelloResponse>>) async throws -> Void,
|
||||
onResponse handleResponse: @Sendable @escaping (GRPCCore.StreamingClientResponse<GRPCMessage<models_HelloResponse>>) async throws -> Result
|
||||
) async throws -> Result where Result: Sendable {
|
||||
let request = GRPCCore.StreamingClientRequest<GRPCMessage<models_HelloResponse>>(
|
||||
metadata: metadata,
|
||||
producer: producer
|
||||
)
|
||||
return try await self.Update(
|
||||
request: request,
|
||||
options: options,
|
||||
onResponse: handleResponse
|
||||
)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,100 +0,0 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
// swiftlint:disable all
|
||||
// swiftformat:disable all
|
||||
|
||||
#if canImport(Common)
|
||||
import Common
|
||||
#endif
|
||||
|
||||
import FlatBuffers
|
||||
|
||||
public struct models_HelloResponse: FlatBufferVerifiableTable, FlatbuffersVectorInitializable {
|
||||
|
||||
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
||||
public var __buffer: ByteBuffer! { return _accessor.bb }
|
||||
private var _accessor: Table
|
||||
|
||||
private init(_ t: Table) { _accessor = t }
|
||||
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
|
||||
|
||||
private struct VT {
|
||||
static let message: VOffset = 4
|
||||
}
|
||||
|
||||
public var message: String? { let o = _accessor.offset(VT.message); return o == 0 ? nil : _accessor.string(at: o) }
|
||||
public var messageSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.message) }
|
||||
public static func startHelloResponse(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
|
||||
public static func add(message: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: message, at: VT.message) }
|
||||
public static func endHelloResponse(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
|
||||
public static func createHelloResponse(
|
||||
_ fbb: inout FlatBufferBuilder,
|
||||
messageOffset message: Offset = Offset()
|
||||
) -> Offset {
|
||||
let __start = models_HelloResponse.startHelloResponse(&fbb)
|
||||
models_HelloResponse.add(message: message, &fbb)
|
||||
return models_HelloResponse.endHelloResponse(&fbb, start: __start)
|
||||
}
|
||||
|
||||
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
|
||||
var _v = try verifier.visitTable(at: position)
|
||||
try _v.visit(field: VT.message, fieldName: "message", required: false, type: ForwardOffset<String>.self)
|
||||
_v.finish()
|
||||
}
|
||||
}
|
||||
|
||||
extension models_HelloResponse: Encodable {
|
||||
enum CodingKeys: String, CodingKey {
|
||||
case message = "message"
|
||||
}
|
||||
|
||||
public func encode(to encoder: Encoder) throws {
|
||||
var container = encoder.container(keyedBy: CodingKeys.self)
|
||||
try container.encodeIfPresent(message, forKey: .message)
|
||||
}
|
||||
}
|
||||
|
||||
public struct models_HelloRequest: FlatBufferVerifiableTable, FlatbuffersVectorInitializable {
|
||||
|
||||
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
||||
public var __buffer: ByteBuffer! { return _accessor.bb }
|
||||
private var _accessor: Table
|
||||
|
||||
private init(_ t: Table) { _accessor = t }
|
||||
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
|
||||
|
||||
private struct VT {
|
||||
static let name: VOffset = 4
|
||||
}
|
||||
|
||||
public var name: String? { let o = _accessor.offset(VT.name); return o == 0 ? nil : _accessor.string(at: o) }
|
||||
public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.name) }
|
||||
public static func startHelloRequest(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
|
||||
public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VT.name) }
|
||||
public static func endHelloRequest(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
|
||||
public static func createHelloRequest(
|
||||
_ fbb: inout FlatBufferBuilder,
|
||||
nameOffset name: Offset = Offset()
|
||||
) -> Offset {
|
||||
let __start = models_HelloRequest.startHelloRequest(&fbb)
|
||||
models_HelloRequest.add(name: name, &fbb)
|
||||
return models_HelloRequest.endHelloRequest(&fbb, start: __start)
|
||||
}
|
||||
|
||||
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
|
||||
var _v = try verifier.visitTable(at: position)
|
||||
try _v.visit(field: VT.name, fieldName: "name", required: false, type: ForwardOffset<String>.self)
|
||||
_v.finish()
|
||||
}
|
||||
}
|
||||
|
||||
extension models_HelloRequest: Encodable {
|
||||
enum CodingKeys: String, CodingKey {
|
||||
case name = "name"
|
||||
}
|
||||
|
||||
public func encode(to encoder: Encoder) throws {
|
||||
var container = encoder.container(keyedBy: CodingKeys.self)
|
||||
try container.encodeIfPresent(name, forKey: .name)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -142,19 +142,6 @@
|
||||
#define FLATBUFFERS_VERSION_MAJOR 25
|
||||
#define FLATBUFFERS_VERSION_MINOR 12
|
||||
#define FLATBUFFERS_VERSION_REVISION 19
|
||||
|
||||
// Identifies this header as Bigfoot's fork of flatbuffers, and versions the
|
||||
// fork's own generated-code-affecting changes independently of the upstream
|
||||
// FLATBUFFERS_VERSION_* triplet above (which just tracks the upstream
|
||||
// version this fork is based on, and would still match an unforked, stock
|
||||
// flatbuffers install of the same version). Generated headers assert on
|
||||
// this - see GenFlatbuffersVersionCheck() in idl_gen_cpp.cpp - so building
|
||||
// Bigfoot-generated code against stock flatbuffers, or a differently
|
||||
// versioned Bigfoot fork, fails to compile immediately instead of silently
|
||||
// miscompiling. Bump this whenever a change here affects what generated
|
||||
// code assumes about this header (e.g. adding bigfoot_ref/bigfoot_ref_wrapper).
|
||||
#define FLATBUFFERS_BIGFOOT_VERSION 1
|
||||
|
||||
#define FLATBUFFERS_STRING_EXPAND(X) #X
|
||||
#define FLATBUFFERS_STRING(X) FLATBUFFERS_STRING_EXPAND(X)
|
||||
namespace flatbuffers {
|
||||
|
||||
@@ -677,7 +677,6 @@ struct IDLOptions {
|
||||
std::string cpp_object_api_pointer_type;
|
||||
std::string cpp_object_api_string_type;
|
||||
bool cpp_object_api_string_flexible_constructor;
|
||||
std::string cpp_object_api_vector_type;
|
||||
CaseStyle cpp_object_api_field_case_style;
|
||||
bool cpp_direct_copy;
|
||||
bool gen_nullable;
|
||||
@@ -1013,13 +1012,10 @@ class Parser : public ParserState {
|
||||
known_attributes_["cpp_ptr_type_get"] = true;
|
||||
known_attributes_["cpp_str_type"] = true;
|
||||
known_attributes_["cpp_str_flex_ctor"] = true;
|
||||
known_attributes_["cpp_vector_type"] = true;
|
||||
known_attributes_["native_inline"] = true;
|
||||
known_attributes_["native_custom_alloc"] = true;
|
||||
known_attributes_["native_type"] = true;
|
||||
known_attributes_["native_type_pack_name"] = true;
|
||||
known_attributes_["bigfoot_ref_wrapper"] = true;
|
||||
known_attributes_["bigfoot_ref"] = true;
|
||||
known_attributes_["native_default"] = true;
|
||||
known_attributes_["flexbuffer"] = true;
|
||||
known_attributes_["private"] = true;
|
||||
|
||||
@@ -30,50 +30,52 @@ namespace flatbuffers {
|
||||
|
||||
// ------------------------- GETTERS -------------------------
|
||||
|
||||
inline bool IsScalar(reflection::BaseType t) {
|
||||
constexpr bool IsScalar(reflection::BaseType t) {
|
||||
return t >= reflection::UType && t <= reflection::Double;
|
||||
}
|
||||
inline bool IsInteger(reflection::BaseType t) {
|
||||
constexpr bool IsInteger(reflection::BaseType t) {
|
||||
return t >= reflection::UType && t <= reflection::ULong;
|
||||
}
|
||||
inline bool IsFloat(reflection::BaseType t) {
|
||||
constexpr bool IsFloat(reflection::BaseType t) {
|
||||
return t == reflection::Float || t == reflection::Double;
|
||||
}
|
||||
inline bool IsLong(reflection::BaseType t) {
|
||||
constexpr bool IsLong(reflection::BaseType t) {
|
||||
return t == reflection::Long || t == reflection::ULong;
|
||||
}
|
||||
|
||||
// Size of a basic type, don't use with structs.
|
||||
inline size_t GetTypeSize(reflection::BaseType base_type) {
|
||||
// This needs to correspond to the BaseType enum.
|
||||
static size_t sizes[] = {
|
||||
0, // None
|
||||
1, // UType
|
||||
1, // Bool
|
||||
1, // Byte
|
||||
1, // UByte
|
||||
2, // Short
|
||||
2, // UShort
|
||||
4, // Int
|
||||
4, // UInt
|
||||
8, // Long
|
||||
8, // ULong
|
||||
4, // Float
|
||||
8, // Double
|
||||
4, // String
|
||||
4, // Vector
|
||||
4, // Obj
|
||||
4, // Union
|
||||
0, // Array. Only used in structs. 0 was chosen to prevent out-of-bounds
|
||||
// errors.
|
||||
8, // Vector64
|
||||
// This needs to correspond to the BaseType enum.
|
||||
constexpr size_t kBaseTypeSize[] = {
|
||||
0, // None
|
||||
1, // UType
|
||||
1, // Bool
|
||||
1, // Byte
|
||||
1, // UByte
|
||||
2, // Short
|
||||
2, // UShort
|
||||
4, // Int
|
||||
4, // UInt
|
||||
8, // Long
|
||||
8, // ULong
|
||||
4, // Float
|
||||
8, // Double
|
||||
4, // String
|
||||
4, // Vector
|
||||
4, // Obj
|
||||
4, // Union
|
||||
0, // Array. Only used in structs. 0 was chosen to prevent out-of-bounds
|
||||
// errors.
|
||||
8, // Vector64
|
||||
|
||||
0 // MaxBaseType. This must be kept the last entry in this array.
|
||||
};
|
||||
static_assert(sizeof(sizes) / sizeof(size_t) == reflection::MaxBaseType + 1,
|
||||
"Size of sizes[] array does not match the count of BaseType "
|
||||
"enum values.");
|
||||
return sizes[base_type];
|
||||
0 // MaxBaseType. This must be kept the last entry in this array.
|
||||
};
|
||||
static_assert(sizeof(kBaseTypeSize) / sizeof(size_t) ==
|
||||
reflection::MaxBaseType + 1,
|
||||
"Size of sizes[] array does not match the count of BaseType "
|
||||
"enum values.");
|
||||
|
||||
// Size of a basic type, don't use with structs.
|
||||
constexpr size_t GetTypeSize(reflection::BaseType base_type) {
|
||||
return kBaseTypeSize[base_type];
|
||||
}
|
||||
|
||||
// Same as above, but now correctly returns the size of a struct if
|
||||
@@ -420,7 +422,7 @@ pointer_inside_vector<T, U> piv(T* ptr, std::vector<U>& vec) {
|
||||
return pointer_inside_vector<T, U>(ptr, vec);
|
||||
}
|
||||
|
||||
inline const char* UnionTypeFieldSuffix() { return "_type"; }
|
||||
constexpr const char* UnionTypeFieldSuffix() { return "_type"; }
|
||||
|
||||
// Helper to figure out the actual table type a union refers to.
|
||||
inline const reflection::Object& GetUnionType(
|
||||
|
||||
@@ -438,8 +438,7 @@ namespace Google.FlatBuffers
|
||||
if (off > Offset)
|
||||
throw new ArgumentException();
|
||||
|
||||
if (off != 0)
|
||||
off = Offset - off + sizeof(int);
|
||||
off = Offset - off + sizeof(int);
|
||||
PutInt(off);
|
||||
}
|
||||
|
||||
|
||||
@@ -65,11 +65,7 @@ namespace Google.FlatBuffers
|
||||
// Create a .NET String from UTF-8 data stored inside the flatbuffer.
|
||||
public string __string(int offset)
|
||||
{
|
||||
int stringOffset = bb.GetInt(offset);
|
||||
if (stringOffset == 0)
|
||||
return null;
|
||||
|
||||
offset += stringOffset;
|
||||
offset += bb.GetInt(offset);
|
||||
var len = bb.GetInt(offset);
|
||||
var startPos = offset + sizeof(int);
|
||||
return bb.GetStringUTF8(startPos, len);
|
||||
|
||||
Generated
+19
-19
@@ -343,8 +343,8 @@ packages:
|
||||
engines: {node: '>=0.4.0'}
|
||||
hasBin: true
|
||||
|
||||
ajv@6.12.6:
|
||||
resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
|
||||
ajv@6.14.0:
|
||||
resolution: {integrity: sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==}
|
||||
|
||||
ansi-styles@4.3.0:
|
||||
resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
|
||||
@@ -483,8 +483,8 @@ packages:
|
||||
resolution: {integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==}
|
||||
engines: {node: '>=16'}
|
||||
|
||||
flatted@3.3.1:
|
||||
resolution: {integrity: sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw==}
|
||||
flatted@3.4.2:
|
||||
resolution: {integrity: sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==}
|
||||
|
||||
glob-parent@5.1.2:
|
||||
resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
|
||||
@@ -571,11 +571,11 @@ packages:
|
||||
resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}
|
||||
engines: {node: '>=8.6'}
|
||||
|
||||
minimatch@3.1.2:
|
||||
resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
|
||||
minimatch@3.1.5:
|
||||
resolution: {integrity: sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==}
|
||||
|
||||
minimatch@9.0.5:
|
||||
resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==}
|
||||
minimatch@9.0.9:
|
||||
resolution: {integrity: sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==}
|
||||
engines: {node: '>=16 || 14 >=14.17'}
|
||||
|
||||
ms@2.1.3:
|
||||
@@ -793,7 +793,7 @@ snapshots:
|
||||
dependencies:
|
||||
'@eslint/object-schema': 2.1.6
|
||||
debug: 4.3.7
|
||||
minimatch: 3.1.2
|
||||
minimatch: 3.1.5
|
||||
transitivePeerDependencies:
|
||||
- supports-color
|
||||
|
||||
@@ -809,14 +809,14 @@ snapshots:
|
||||
|
||||
'@eslint/eslintrc@3.3.1':
|
||||
dependencies:
|
||||
ajv: 6.12.6
|
||||
ajv: 6.14.0
|
||||
debug: 4.3.7
|
||||
espree: 10.4.0
|
||||
globals: 14.0.0
|
||||
ignore: 5.3.2
|
||||
import-fresh: 3.3.0
|
||||
js-yaml: 4.1.1
|
||||
minimatch: 3.1.2
|
||||
minimatch: 3.1.5
|
||||
strip-json-comments: 3.1.1
|
||||
transitivePeerDependencies:
|
||||
- supports-color
|
||||
@@ -932,7 +932,7 @@ snapshots:
|
||||
debug: 4.3.7
|
||||
fast-glob: 3.3.2
|
||||
is-glob: 4.0.3
|
||||
minimatch: 9.0.5
|
||||
minimatch: 9.0.9
|
||||
semver: 7.6.3
|
||||
ts-api-utils: 2.1.0(typescript@5.8.3)
|
||||
typescript: 5.8.3
|
||||
@@ -961,7 +961,7 @@ snapshots:
|
||||
|
||||
acorn@8.15.0: {}
|
||||
|
||||
ajv@6.12.6:
|
||||
ajv@6.14.0:
|
||||
dependencies:
|
||||
fast-deep-equal: 3.1.3
|
||||
fast-json-stable-stringify: 2.1.0
|
||||
@@ -1070,7 +1070,7 @@ snapshots:
|
||||
'@humanwhocodes/retry': 0.4.3
|
||||
'@types/estree': 1.0.8
|
||||
'@types/json-schema': 7.0.15
|
||||
ajv: 6.12.6
|
||||
ajv: 6.14.0
|
||||
chalk: 4.1.2
|
||||
cross-spawn: 7.0.6
|
||||
debug: 4.3.7
|
||||
@@ -1089,7 +1089,7 @@ snapshots:
|
||||
is-glob: 4.0.3
|
||||
json-stable-stringify-without-jsonify: 1.0.1
|
||||
lodash.merge: 4.6.2
|
||||
minimatch: 3.1.2
|
||||
minimatch: 3.1.5
|
||||
natural-compare: 1.4.0
|
||||
optionator: 0.9.4
|
||||
transitivePeerDependencies:
|
||||
@@ -1146,10 +1146,10 @@ snapshots:
|
||||
|
||||
flat-cache@4.0.1:
|
||||
dependencies:
|
||||
flatted: 3.3.1
|
||||
flatted: 3.4.2
|
||||
keyv: 4.5.4
|
||||
|
||||
flatted@3.3.1: {}
|
||||
flatted@3.4.2: {}
|
||||
|
||||
glob-parent@5.1.2:
|
||||
dependencies:
|
||||
@@ -1218,11 +1218,11 @@ snapshots:
|
||||
braces: 3.0.3
|
||||
picomatch: 2.3.1
|
||||
|
||||
minimatch@3.1.2:
|
||||
minimatch@3.1.5:
|
||||
dependencies:
|
||||
brace-expansion: 1.1.12
|
||||
|
||||
minimatch@9.0.5:
|
||||
minimatch@9.0.9:
|
||||
dependencies:
|
||||
brace-expansion: 2.0.2
|
||||
|
||||
|
||||
@@ -1,2 +0,0 @@
|
||||
packages:
|
||||
- tests/ts
|
||||
@@ -159,7 +159,7 @@ def EnumCreateValuesVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateValuesVector(builder, data):
|
||||
EnumCreateValuesVector(builder, data)
|
||||
return EnumCreateValuesVector(builder, data)
|
||||
|
||||
def EnumAddIsUnion(builder, isUnion):
|
||||
builder.PrependBoolSlot(2, isUnion, 0)
|
||||
@@ -189,7 +189,7 @@ def EnumCreateAttributesVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateAttributesVector(builder, data):
|
||||
EnumCreateAttributesVector(builder, data)
|
||||
return EnumCreateAttributesVector(builder, data)
|
||||
|
||||
def EnumAddDocumentation(builder, documentation):
|
||||
builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
|
||||
@@ -207,7 +207,7 @@ def EnumCreateDocumentationVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateDocumentationVector(builder, data):
|
||||
EnumCreateDocumentationVector(builder, data)
|
||||
return EnumCreateDocumentationVector(builder, data)
|
||||
|
||||
def EnumAddDeclarationFile(builder, declarationFile):
|
||||
builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)
|
||||
|
||||
@@ -138,7 +138,7 @@ def EnumValCreateDocumentationVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateDocumentationVector(builder, data):
|
||||
EnumValCreateDocumentationVector(builder, data)
|
||||
return EnumValCreateDocumentationVector(builder, data)
|
||||
|
||||
def EnumValAddAttributes(builder, attributes):
|
||||
builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
|
||||
@@ -156,7 +156,7 @@ def EnumValCreateAttributesVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateAttributesVector(builder, data):
|
||||
EnumValCreateAttributesVector(builder, data)
|
||||
return EnumValCreateAttributesVector(builder, data)
|
||||
|
||||
def EnumValEnd(builder):
|
||||
return builder.EndObject()
|
||||
|
||||
@@ -239,7 +239,7 @@ def FieldCreateAttributesVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateAttributesVector(builder, data):
|
||||
FieldCreateAttributesVector(builder, data)
|
||||
return FieldCreateAttributesVector(builder, data)
|
||||
|
||||
def FieldAddDocumentation(builder, documentation):
|
||||
builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
|
||||
@@ -257,7 +257,7 @@ def FieldCreateDocumentationVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateDocumentationVector(builder, data):
|
||||
FieldCreateDocumentationVector(builder, data)
|
||||
return FieldCreateDocumentationVector(builder, data)
|
||||
|
||||
def FieldAddOptional(builder, optional):
|
||||
builder.PrependBoolSlot(11, optional, 0)
|
||||
|
||||
@@ -162,7 +162,7 @@ def ObjectCreateFieldsVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateFieldsVector(builder, data):
|
||||
ObjectCreateFieldsVector(builder, data)
|
||||
return ObjectCreateFieldsVector(builder, data)
|
||||
|
||||
def ObjectAddIsStruct(builder, isStruct):
|
||||
builder.PrependBoolSlot(2, isStruct, 0)
|
||||
@@ -198,7 +198,7 @@ def ObjectCreateAttributesVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateAttributesVector(builder, data):
|
||||
ObjectCreateAttributesVector(builder, data)
|
||||
return ObjectCreateAttributesVector(builder, data)
|
||||
|
||||
def ObjectAddDocumentation(builder, documentation):
|
||||
builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
|
||||
@@ -216,7 +216,7 @@ def ObjectCreateDocumentationVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateDocumentationVector(builder, data):
|
||||
ObjectCreateDocumentationVector(builder, data)
|
||||
return ObjectCreateDocumentationVector(builder, data)
|
||||
|
||||
def ObjectAddDeclarationFile(builder, declarationFile):
|
||||
builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)
|
||||
|
||||
@@ -142,7 +142,7 @@ def RPCCallCreateAttributesVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateAttributesVector(builder, data):
|
||||
RPCCallCreateAttributesVector(builder, data)
|
||||
return RPCCallCreateAttributesVector(builder, data)
|
||||
|
||||
def RPCCallAddDocumentation(builder, documentation):
|
||||
builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
|
||||
@@ -160,7 +160,7 @@ def RPCCallCreateDocumentationVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateDocumentationVector(builder, data):
|
||||
RPCCallCreateDocumentationVector(builder, data)
|
||||
return RPCCallCreateDocumentationVector(builder, data)
|
||||
|
||||
def RPCCallEnd(builder):
|
||||
return builder.EndObject()
|
||||
|
||||
@@ -184,7 +184,7 @@ def SchemaCreateObjectsVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateObjectsVector(builder, data):
|
||||
SchemaCreateObjectsVector(builder, data)
|
||||
return SchemaCreateObjectsVector(builder, data)
|
||||
|
||||
def SchemaAddEnums(builder, enums):
|
||||
builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(enums), 0)
|
||||
@@ -202,7 +202,7 @@ def SchemaCreateEnumsVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateEnumsVector(builder, data):
|
||||
SchemaCreateEnumsVector(builder, data)
|
||||
return SchemaCreateEnumsVector(builder, data)
|
||||
|
||||
def SchemaAddFileIdent(builder, fileIdent):
|
||||
builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(fileIdent), 0)
|
||||
@@ -238,7 +238,7 @@ def SchemaCreateServicesVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateServicesVector(builder, data):
|
||||
SchemaCreateServicesVector(builder, data)
|
||||
return SchemaCreateServicesVector(builder, data)
|
||||
|
||||
def SchemaAddAdvancedFeatures(builder, advancedFeatures):
|
||||
builder.PrependUint64Slot(6, advancedFeatures, 0)
|
||||
@@ -262,7 +262,7 @@ def SchemaCreateFbsFilesVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateFbsFilesVector(builder, data):
|
||||
SchemaCreateFbsFilesVector(builder, data)
|
||||
return SchemaCreateFbsFilesVector(builder, data)
|
||||
|
||||
def SchemaEnd(builder):
|
||||
return builder.EndObject()
|
||||
|
||||
@@ -88,7 +88,7 @@ def SchemaFileCreateIncludedFilenamesVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateIncludedFilenamesVector(builder, data):
|
||||
SchemaFileCreateIncludedFilenamesVector(builder, data)
|
||||
return SchemaFileCreateIncludedFilenamesVector(builder, data)
|
||||
|
||||
def SchemaFileEnd(builder):
|
||||
return builder.EndObject()
|
||||
|
||||
@@ -141,7 +141,7 @@ def ServiceCreateCallsVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateCallsVector(builder, data):
|
||||
ServiceCreateCallsVector(builder, data)
|
||||
return ServiceCreateCallsVector(builder, data)
|
||||
|
||||
def ServiceAddAttributes(builder, attributes):
|
||||
builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
|
||||
@@ -159,7 +159,7 @@ def ServiceCreateAttributesVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateAttributesVector(builder, data):
|
||||
ServiceCreateAttributesVector(builder, data)
|
||||
return ServiceCreateAttributesVector(builder, data)
|
||||
|
||||
def ServiceAddDocumentation(builder, documentation):
|
||||
builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
|
||||
@@ -177,7 +177,7 @@ def ServiceCreateDocumentationVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateDocumentationVector(builder, data):
|
||||
ServiceCreateDocumentationVector(builder, data)
|
||||
return ServiceCreateDocumentationVector(builder, data)
|
||||
|
||||
def ServiceAddDeclarationFile(builder, declarationFile):
|
||||
builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)
|
||||
|
||||
+1
-5
@@ -1,6 +1,2 @@
|
||||
[bdist_wheel]
|
||||
universal=1
|
||||
|
||||
[metadata]
|
||||
license_files =
|
||||
../LICENSE
|
||||
license_files = LICENSE
|
||||
|
||||
@@ -32,10 +32,8 @@ setup(
|
||||
description='The FlatBuffers serialization format for Python',
|
||||
classifiers=[
|
||||
'Intended Audience :: Developers',
|
||||
'License :: OSI Approved :: Apache Software License',
|
||||
'Operating System :: OS Independent',
|
||||
'Programming Language :: Python',
|
||||
'Programming Language :: Python :: 2',
|
||||
'Programming Language :: Python :: 3',
|
||||
'Topic :: Software Development :: Libraries :: Python Modules',
|
||||
],
|
||||
|
||||
+202
-13
@@ -24,6 +24,9 @@ use core::marker::PhantomData;
|
||||
use core::ops::{Add, AddAssign, Deref, DerefMut, Index, IndexMut, Sub, SubAssign};
|
||||
use core::ptr::write_bytes;
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::endian_scalar::emplace_scalar;
|
||||
use crate::primitives::*;
|
||||
use crate::push::{Push, PushAlignment};
|
||||
@@ -139,6 +142,9 @@ pub struct FlatBufferBuilder<'fbb, A: Allocator = DefaultAllocator> {
|
||||
|
||||
min_align: usize,
|
||||
force_defaults: bool,
|
||||
#[cfg(feature = "std")]
|
||||
strings_pool: HashMap<String, WIPOffset<&'fbb str>>,
|
||||
#[cfg(not(feature = "std"))]
|
||||
strings_pool: Vec<WIPOffset<&'fbb str>>,
|
||||
|
||||
_phantom: PhantomData<&'fbb ()>,
|
||||
@@ -160,6 +166,60 @@ impl<'fbb> FlatBufferBuilder<'fbb, DefaultAllocator> {
|
||||
pub fn with_capacity(size: usize) -> Self {
|
||||
Self::from_vec(vec![0; size])
|
||||
}
|
||||
/// Create a FlatBufferBuilder that is ready for writing, with a
|
||||
/// ready-to-use capacity of the provided size and preallocated internal vecs.
|
||||
///
|
||||
/// The maximum valid value for `size` is `FLATBUFFERS_MAX_BUFFER_SIZE`.
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `size` - The initial capacity of the backing buffer in bytes.
|
||||
/// * `field_locs_capacity` - Preallocated capacity for the field locations vec.
|
||||
/// * `written_vtable_revpos_capacity` - Preallocated capacity for the written vtable reverse positions vec.
|
||||
/// * `strings_pool_capacity` - Preallocated capacity for the shared strings pool vec.
|
||||
pub fn with_internal_capacity(
|
||||
size: usize,
|
||||
field_locs_capacity: usize,
|
||||
written_vtable_revpos_capacity: usize,
|
||||
strings_pool_capacity: usize,
|
||||
) -> Self {
|
||||
Self::from_vec_with_internal_capacity(
|
||||
vec![0; size],
|
||||
field_locs_capacity,
|
||||
written_vtable_revpos_capacity,
|
||||
strings_pool_capacity,
|
||||
)
|
||||
}
|
||||
/// Create a FlatBufferBuilder that is ready for writing, reusing
|
||||
/// an existing vector and preallocated internal vecs.
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `buffer` - An existing `Vec<u8>` to reuse as the backing buffer.
|
||||
/// * `field_locs_capacity` - Preallocated capacity for the field locations vec.
|
||||
/// * `written_vtable_revpos_capacity` - Preallocated capacity for the written vtable reverse positions vec.
|
||||
/// * `strings_pool_capacity` - Preallocated capacity for the shared strings pool vec.
|
||||
pub fn from_vec_with_internal_capacity(
|
||||
buffer: Vec<u8>,
|
||||
field_locs_capacity: usize,
|
||||
written_vtable_revpos_capacity: usize,
|
||||
strings_pool_capacity: usize,
|
||||
) -> Self {
|
||||
// we need to check the size here because we create the backing buffer
|
||||
// directly, bypassing the typical way of using grow_allocator:
|
||||
assert!(
|
||||
buffer.len() <= FLATBUFFERS_MAX_BUFFER_SIZE,
|
||||
"cannot initialize buffer bigger than 2 gigabytes"
|
||||
);
|
||||
let allocator = DefaultAllocator::from_vec(buffer);
|
||||
Self::new_in_with_internal_capacity(
|
||||
allocator,
|
||||
field_locs_capacity,
|
||||
written_vtable_revpos_capacity,
|
||||
strings_pool_capacity,
|
||||
)
|
||||
}
|
||||
|
||||
/// Create a FlatBufferBuilder that is ready for writing, reusing
|
||||
/// an existing vector.
|
||||
pub fn from_vec(buffer: Vec<u8>) -> Self {
|
||||
@@ -197,12 +257,52 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
|
||||
|
||||
min_align: 0,
|
||||
force_defaults: false,
|
||||
#[cfg(feature = "std")]
|
||||
strings_pool: HashMap::new(),
|
||||
#[cfg(not(feature = "std"))]
|
||||
strings_pool: Vec::new(),
|
||||
|
||||
_phantom: PhantomData,
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a [`FlatBufferBuilder`] that is ready for writing with a custom [`Allocator`]
|
||||
/// and preallocated internal vecs.
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `allocator` - A custom [`Allocator`] to use as the backing buffer.
|
||||
/// * `field_locs_capacity` - Preallocated capacity for the field locations vec.
|
||||
/// * `written_vtable_revpos_capacity` - Preallocated capacity for the written vtable reverse positions vec.
|
||||
/// * `strings_pool_capacity` - Preallocated capacity for the shared strings pool vec.
|
||||
pub fn new_in_with_internal_capacity(
|
||||
allocator: A,
|
||||
field_locs_capacity: usize,
|
||||
written_vtable_revpos_capacity: usize,
|
||||
strings_pool_capacity: usize,
|
||||
) -> Self {
|
||||
let head = ReverseIndex::end();
|
||||
FlatBufferBuilder {
|
||||
allocator,
|
||||
head,
|
||||
|
||||
field_locs: Vec::with_capacity(field_locs_capacity),
|
||||
written_vtable_revpos: Vec::with_capacity(written_vtable_revpos_capacity),
|
||||
|
||||
nested: false,
|
||||
finished: false,
|
||||
|
||||
min_align: 0,
|
||||
force_defaults: false,
|
||||
#[cfg(feature = "std")]
|
||||
strings_pool: HashMap::with_capacity(strings_pool_capacity),
|
||||
#[cfg(not(feature = "std"))]
|
||||
strings_pool: Vec::with_capacity(strings_pool_capacity),
|
||||
|
||||
_phantom: PhantomData,
|
||||
}
|
||||
}
|
||||
|
||||
/// Destroy the [`FlatBufferBuilder`], returning its [`Allocator`] and the index
|
||||
/// into it that represents the start of valid data.
|
||||
pub fn collapse_in(self) -> (A, usize) {
|
||||
@@ -223,7 +323,9 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
|
||||
/// new object.
|
||||
pub fn reset(&mut self) {
|
||||
// memset only the part of the buffer that could be dirty:
|
||||
self.allocator[self.head.range_to_end()].iter_mut().for_each(|x| *x = 0);
|
||||
self.allocator[self.head.range_to_end()]
|
||||
.iter_mut()
|
||||
.for_each(|x| *x = 0);
|
||||
|
||||
self.head = ReverseIndex::end();
|
||||
self.written_vtable_revpos.clear();
|
||||
@@ -343,6 +445,31 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
|
||||
WIPOffset::new(o.value())
|
||||
}
|
||||
|
||||
/// Create a utf8 string, and de-duplicate if already created.
|
||||
///
|
||||
/// Uses a HashMap to track previously written strings, providing O(1)
|
||||
/// amortized lookup and insertion.
|
||||
#[cfg(feature = "std")]
|
||||
#[inline]
|
||||
pub fn create_shared_string<'a: 'b, 'b>(&'a mut self, s: &'b str) -> WIPOffset<&'fbb str> {
|
||||
self.assert_not_nested(
|
||||
"create_shared_string can not be called when a table or vector is under construction",
|
||||
);
|
||||
|
||||
if let Some(&offset) = self.strings_pool.get(s) {
|
||||
return offset;
|
||||
}
|
||||
|
||||
let address = WIPOffset::new(self.create_byte_string(s.as_bytes()).value());
|
||||
self.strings_pool.insert(s.to_owned(), address);
|
||||
address
|
||||
}
|
||||
|
||||
/// Create a utf8 string, and de-duplicate if already created.
|
||||
///
|
||||
/// Uses a sorted Vec with binary search to track previously written
|
||||
/// strings when in `no_std` mode.
|
||||
#[cfg(not(feature = "std"))]
|
||||
#[inline]
|
||||
pub fn create_shared_string<'a: 'b, 'b>(&'a mut self, s: &'b str) -> WIPOffset<&'fbb str> {
|
||||
self.assert_not_nested(
|
||||
@@ -355,19 +482,15 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
|
||||
|
||||
let found = self.strings_pool.binary_search_by(|offset| {
|
||||
let ptr = offset.value() as usize;
|
||||
// Gets The pointer to the size of the string
|
||||
let str_memory = &buf[buf.len() - ptr..];
|
||||
// Gets the size of the written string from buffer
|
||||
let size =
|
||||
u32::from_le_bytes([str_memory[0], str_memory[1], str_memory[2], str_memory[3]])
|
||||
as usize;
|
||||
// Size of the string size
|
||||
let string_size: usize = 4;
|
||||
// Fetches actual string bytes from index of string after string size
|
||||
// to the size of string plus string size
|
||||
let iter = str_memory[string_size..size + string_size].iter();
|
||||
// Compares bytes of fetched string and current writable string
|
||||
iter.cloned().cmp(s.bytes())
|
||||
let size = u32::from_le_bytes([
|
||||
str_memory[0],
|
||||
str_memory[1],
|
||||
str_memory[2],
|
||||
str_memory[3],
|
||||
]) as usize;
|
||||
let stored = &str_memory[4..4 + size];
|
||||
stored.cmp(s.as_bytes())
|
||||
});
|
||||
|
||||
match found {
|
||||
@@ -931,6 +1054,33 @@ impl<T> IndexMut<ReverseIndexRange> for [T] {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use core::sync::atomic::{AtomicUsize, Ordering};
|
||||
use std::alloc::{GlobalAlloc, Layout, System};
|
||||
|
||||
static ALLOC_COUNT: AtomicUsize = AtomicUsize::new(0);
|
||||
|
||||
struct CountingAllocator;
|
||||
|
||||
unsafe impl GlobalAlloc for CountingAllocator {
|
||||
unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
|
||||
ALLOC_COUNT.fetch_add(1, Ordering::Relaxed);
|
||||
unsafe { System.alloc(layout) }
|
||||
}
|
||||
unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
|
||||
unsafe { System.dealloc(ptr, layout) }
|
||||
}
|
||||
}
|
||||
|
||||
#[global_allocator]
|
||||
static GLOBAL: CountingAllocator = CountingAllocator;
|
||||
|
||||
fn reset_alloc_count() {
|
||||
ALLOC_COUNT.store(0, Ordering::Relaxed);
|
||||
}
|
||||
|
||||
fn alloc_count() -> usize {
|
||||
ALLOC_COUNT.load(Ordering::Relaxed)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reverse_index_test() {
|
||||
@@ -940,4 +1090,43 @@ mod tests {
|
||||
assert_eq!(&buf[idx.range_to(idx + 1)], &[4]);
|
||||
assert_eq!(idx.to_forward_index(&buf), 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn with_internal_capacity_preallocates_vecs() {
|
||||
let mut builder = FlatBufferBuilder::with_internal_capacity(64, 8, 16, 32);
|
||||
|
||||
assert!(builder.allocator.len() >= 64);
|
||||
assert!(builder.field_locs.capacity() >= 8);
|
||||
assert!(builder.written_vtable_revpos.capacity() >= 16);
|
||||
assert!(builder.strings_pool.capacity() >= 32);
|
||||
|
||||
assert!(builder.field_locs.is_empty());
|
||||
assert!(builder.written_vtable_revpos.is_empty());
|
||||
assert!(builder.strings_pool.is_empty());
|
||||
|
||||
// Reset the allocation counter after builder construction
|
||||
reset_alloc_count();
|
||||
|
||||
// Add a shared string and verify it lands in the pool
|
||||
let s1 = builder.create_shared_string("hello");
|
||||
assert_eq!(builder.strings_pool.len(), 1);
|
||||
|
||||
// Adding the same string again should reuse the pooled entry
|
||||
let s2 = builder.create_shared_string("hello");
|
||||
assert_eq!(builder.strings_pool.len(), 1);
|
||||
assert_eq!(s1.value(), s2.value());
|
||||
|
||||
// A different string should add a new entry
|
||||
let _s3 = builder.create_shared_string("world");
|
||||
assert_eq!(builder.strings_pool.len(), 2);
|
||||
|
||||
// With sufficient preallocated capacity, no additional allocations
|
||||
// should have occurred for the internal vecs during the operations above
|
||||
let allocs = alloc_count();
|
||||
assert_eq!(
|
||||
allocs, 0,
|
||||
"expected 0 allocations after builder construction, got {}",
|
||||
allocs
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -107,6 +107,20 @@ impl<'a, T: Follow<'a> + 'a> Vector<'a, T> {
|
||||
key: K,
|
||||
f: fn(&<T as Follow<'a>>::Inner, &K) -> Ordering,
|
||||
) -> Option<T::Inner> {
|
||||
self.lookup_index_by_key(key, f).map(|idx| self.get(idx))
|
||||
}
|
||||
|
||||
/// Binary search by key, returning the index of the matching element.
|
||||
///
|
||||
/// This is similar to `lookup_by_key`, but returns the index of the found
|
||||
/// element rather than the element itself. This is useful when you need
|
||||
/// to reference elements by their position in the vector.
|
||||
#[inline(always)]
|
||||
pub fn lookup_index_by_key<K: Ord>(
|
||||
&self,
|
||||
key: K,
|
||||
f: fn(&<T as Follow<'a>>::Inner, &K) -> Ordering,
|
||||
) -> Option<usize> {
|
||||
if self.is_empty() {
|
||||
return None;
|
||||
}
|
||||
@@ -118,7 +132,7 @@ impl<'a, T: Follow<'a> + 'a> Vector<'a, T> {
|
||||
let mid = (left + right) / 2;
|
||||
let value = self.get(mid);
|
||||
match f(&value, &key) {
|
||||
Ordering::Equal => return Some(value),
|
||||
Ordering::Equal => return Some(mid),
|
||||
Ordering::Less => left = mid + 1,
|
||||
Ordering::Greater => {
|
||||
if mid == 0 {
|
||||
|
||||
@@ -643,7 +643,7 @@ inline ::flatbuffers::Offset<Monster> Monster::Pack(::flatbuffers::FlatBufferBui
|
||||
auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
|
||||
auto _inventory = _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0;
|
||||
auto _color = _o->color;
|
||||
auto _weapons = _o->weapons.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Sample::Weapon>> (_o->weapons.size(), [](size_t i, _VectorArgs *__va) { return CreateWeapon(*__va->__fbb, __va->__o->weapons[i].get(), __va->__rehasher); }, &_va ) : 0;
|
||||
auto _weapons = _o->weapons.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Sample::Weapon>> (_o->weapons.size(), [](size_t i, _VectorArgs *__va) { return MyGame::Sample::CreateWeapon(*__va->__fbb, __va->__o->weapons[i].get(), __va->__rehasher); }, &_va ) : 0;
|
||||
auto _equipped_type = _o->equipped.type;
|
||||
auto _equipped = _o->equipped.Pack(_fbb);
|
||||
auto _path = _o->path.size() ? _fbb.CreateVectorOfStructs(_o->path) : 0;
|
||||
|
||||
@@ -113,12 +113,12 @@ public struct MyGame_Sample_Vec3: NativeStruct, FlatbuffersVectorInitializable,
|
||||
}
|
||||
|
||||
extension MyGame_Sample_Vec3: Encodable {
|
||||
|
||||
enum CodingKeys: String, CodingKey {
|
||||
case x = "x"
|
||||
case y = "y"
|
||||
case z = "z"
|
||||
}
|
||||
|
||||
public func encode(to encoder: Encoder) throws {
|
||||
var container = encoder.container(keyedBy: CodingKeys.self)
|
||||
if x != 0.0 {
|
||||
@@ -170,51 +170,49 @@ public struct MyGame_Sample_Monster: FlatBufferTable, FlatbuffersVectorInitializ
|
||||
private init(_ t: Table) { _accessor = t }
|
||||
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
|
||||
|
||||
private enum VTOFFSET: VOffset {
|
||||
case pos = 4
|
||||
case mana = 6
|
||||
case hp = 8
|
||||
case name = 10
|
||||
case inventory = 14
|
||||
case color = 16
|
||||
case weapons = 18
|
||||
case equippedType = 20
|
||||
case equipped = 22
|
||||
case path = 24
|
||||
var v: Int32 { Int32(self.rawValue) }
|
||||
var p: VOffset { self.rawValue }
|
||||
private struct VT {
|
||||
static let pos: VOffset = 4
|
||||
static let mana: VOffset = 6
|
||||
static let hp: VOffset = 8
|
||||
static let name: VOffset = 10
|
||||
static let inventory: VOffset = 14
|
||||
static let color: VOffset = 16
|
||||
static let weapons: VOffset = 18
|
||||
static let equippedType: VOffset = 20
|
||||
static let equipped: VOffset = 22
|
||||
static let path: VOffset = 24
|
||||
}
|
||||
|
||||
public var pos: MyGame_Sample_Vec3? { let o = _accessor.offset(VTOFFSET.pos.v); return o == 0 ? nil : _accessor.readBuffer(of: MyGame_Sample_Vec3.self, at: o) }
|
||||
public var mutablePos: MyGame_Sample_Vec3_Mutable? { let o = _accessor.offset(VTOFFSET.pos.v); return o == 0 ? nil : MyGame_Sample_Vec3_Mutable(_accessor.bb, o: o + _accessor.position) }
|
||||
public var mana: Int16 { let o = _accessor.offset(VTOFFSET.mana.v); return o == 0 ? 150 : _accessor.readBuffer(of: Int16.self, at: o) }
|
||||
@discardableResult public func mutate(mana: Int16) -> Bool {let o = _accessor.offset(VTOFFSET.mana.v); return _accessor.mutate(mana, index: o) }
|
||||
public var hp: Int16 { let o = _accessor.offset(VTOFFSET.hp.v); return o == 0 ? 100 : _accessor.readBuffer(of: Int16.self, at: o) }
|
||||
@discardableResult public func mutate(hp: Int16) -> Bool {let o = _accessor.offset(VTOFFSET.hp.v); return _accessor.mutate(hp, index: o) }
|
||||
public var name: String? { let o = _accessor.offset(VTOFFSET.name.v); return o == 0 ? nil : _accessor.string(at: o) }
|
||||
public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.name.v) }
|
||||
public var inventory: FlatbufferVector<UInt8> { return _accessor.vector(at: VTOFFSET.inventory.v, byteSize: 1) }
|
||||
public func mutate(inventory: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.inventory.v); return _accessor.directMutate(inventory, index: _accessor.vector(at: o) + index * 1) }
|
||||
public func withUnsafePointerToInventory<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VTOFFSET.inventory.v, body: body) }
|
||||
public var color: MyGame_Sample_Color { let o = _accessor.offset(VTOFFSET.color.v); return o == 0 ? .blue : MyGame_Sample_Color(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .blue }
|
||||
@discardableResult public func mutate(color: MyGame_Sample_Color) -> Bool {let o = _accessor.offset(VTOFFSET.color.v); return _accessor.mutate(color.rawValue, index: o) }
|
||||
public var weapons: FlatbufferVector<MyGame_Sample_Weapon> { return _accessor.vector(at: VTOFFSET.weapons.v, byteSize: 4) }
|
||||
public var equippedType: MyGame_Sample_Equipment { let o = _accessor.offset(VTOFFSET.equippedType.v); return o == 0 ? .none_ : MyGame_Sample_Equipment(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
|
||||
public func equipped<T: FlatbuffersInitializable>(type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.equipped.v); return o == 0 ? nil : _accessor.union(o) }
|
||||
public var path: FlatbufferVector<MyGame_Sample_Vec3> { return _accessor.vector(at: VTOFFSET.path.v, byteSize: 12) }
|
||||
public var mutablePath: FlatbufferVector<MyGame_Sample_Vec3_Mutable> { return _accessor.vector(at: VTOFFSET.path.v, byteSize: 12) }
|
||||
public func withUnsafePointerToPath<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VTOFFSET.path.v, body: body) }
|
||||
public var pos: MyGame_Sample_Vec3? { let o = _accessor.offset(VT.pos); return o == 0 ? nil : _accessor.readBuffer(of: MyGame_Sample_Vec3.self, at: o) }
|
||||
public var mutablePos: MyGame_Sample_Vec3_Mutable? { let o = _accessor.offset(VT.pos); return o == 0 ? nil : MyGame_Sample_Vec3_Mutable(_accessor.bb, o: o + _accessor.position) }
|
||||
public var mana: Int16 { let o = _accessor.offset(VT.mana); return o == 0 ? 150 : _accessor.readBuffer(of: Int16.self, at: o) }
|
||||
@discardableResult public func mutate(mana: Int16) -> Bool {let o = _accessor.offset(VT.mana); return _accessor.mutate(mana, index: o) }
|
||||
public var hp: Int16 { let o = _accessor.offset(VT.hp); return o == 0 ? 100 : _accessor.readBuffer(of: Int16.self, at: o) }
|
||||
@discardableResult public func mutate(hp: Int16) -> Bool {let o = _accessor.offset(VT.hp); return _accessor.mutate(hp, index: o) }
|
||||
public var name: String? { let o = _accessor.offset(VT.name); return o == 0 ? nil : _accessor.string(at: o) }
|
||||
public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.name) }
|
||||
public var inventory: FlatbufferVector<UInt8> { return _accessor.vector(at: VT.inventory, byteSize: 1) }
|
||||
public func mutate(inventory: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VT.inventory); return _accessor.directMutate(inventory, index: _accessor.vector(at: o) + index * 1) }
|
||||
public func withUnsafePointerToInventory<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.inventory, body: body) }
|
||||
public var color: MyGame_Sample_Color { let o = _accessor.offset(VT.color); return o == 0 ? .blue : MyGame_Sample_Color(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .blue }
|
||||
@discardableResult public func mutate(color: MyGame_Sample_Color) -> Bool {let o = _accessor.offset(VT.color); return _accessor.mutate(color.rawValue, index: o) }
|
||||
public var weapons: FlatbufferVector<MyGame_Sample_Weapon> { return _accessor.vector(at: VT.weapons, byteSize: 4) }
|
||||
public var equippedType: MyGame_Sample_Equipment { let o = _accessor.offset(VT.equippedType); return o == 0 ? .none_ : MyGame_Sample_Equipment(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
|
||||
public func equipped<T: FlatbuffersInitializable>(type: T.Type) -> T? { let o = _accessor.offset(VT.equipped); return o == 0 ? nil : _accessor.union(o) }
|
||||
public var path: FlatbufferVector<MyGame_Sample_Vec3> { return _accessor.vector(at: VT.path, byteSize: 12) }
|
||||
public var mutablePath: FlatbufferVector<MyGame_Sample_Vec3_Mutable> { return _accessor.vector(at: VT.path, byteSize: 12) }
|
||||
public func withUnsafePointerToPath<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.path, body: body) }
|
||||
public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 11) }
|
||||
public static func add(pos: MyGame_Sample_Vec3?, _ fbb: inout FlatBufferBuilder) { guard let pos = pos else { return }; fbb.create(struct: pos, position: VTOFFSET.pos.p) }
|
||||
public static func add(mana: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mana, def: 150, at: VTOFFSET.mana.p) }
|
||||
public static func add(hp: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: hp, def: 100, at: VTOFFSET.hp.p) }
|
||||
public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VTOFFSET.name.p) }
|
||||
public static func addVectorOf(inventory: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: inventory, at: VTOFFSET.inventory.p) }
|
||||
public static func add(color: MyGame_Sample_Color, _ fbb: inout FlatBufferBuilder) { fbb.add(element: color.rawValue, def: 2, at: VTOFFSET.color.p) }
|
||||
public static func addVectorOf(weapons: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: weapons, at: VTOFFSET.weapons.p) }
|
||||
public static func add(equippedType: MyGame_Sample_Equipment, _ fbb: inout FlatBufferBuilder) { fbb.add(element: equippedType.rawValue, def: 0, at: VTOFFSET.equippedType.p) }
|
||||
public static func add(equipped: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: equipped, at: VTOFFSET.equipped.p) }
|
||||
public static func addVectorOf(path: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: path, at: VTOFFSET.path.p) }
|
||||
public static func add(pos: MyGame_Sample_Vec3?, _ fbb: inout FlatBufferBuilder) { guard let pos = pos else { return }; fbb.create(struct: pos, position: VT.pos) }
|
||||
public static func add(mana: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mana, def: 150, at: VT.mana) }
|
||||
public static func add(hp: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: hp, def: 100, at: VT.hp) }
|
||||
public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VT.name) }
|
||||
public static func addVectorOf(inventory: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: inventory, at: VT.inventory) }
|
||||
public static func add(color: MyGame_Sample_Color, _ fbb: inout FlatBufferBuilder) { fbb.add(element: color.rawValue, def: 2, at: VT.color) }
|
||||
public static func addVectorOf(weapons: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: weapons, at: VT.weapons) }
|
||||
public static func add(equippedType: MyGame_Sample_Equipment, _ fbb: inout FlatBufferBuilder) { fbb.add(element: equippedType.rawValue, def: 0, at: VT.equippedType) }
|
||||
public static func add(equipped: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: equipped, at: VT.equipped) }
|
||||
public static func addVectorOf(path: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: path, at: VT.path) }
|
||||
public static func startVectorOfPath(_ size: Int, in builder: inout FlatBufferBuilder) {
|
||||
builder.startVector(size * MemoryLayout<MyGame_Sample_Vec3>.size, elementSize: MemoryLayout<MyGame_Sample_Vec3>.alignment)
|
||||
}
|
||||
@@ -293,14 +291,14 @@ public struct MyGame_Sample_Monster: FlatBufferTable, FlatbuffersVectorInitializ
|
||||
|
||||
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
|
||||
var _v = try verifier.visitTable(at: position)
|
||||
try _v.visit(field: VTOFFSET.pos.p, fieldName: "pos", required: false, type: MyGame_Sample_Vec3.self)
|
||||
try _v.visit(field: VTOFFSET.mana.p, fieldName: "mana", required: false, type: Int16.self)
|
||||
try _v.visit(field: VTOFFSET.hp.p, fieldName: "hp", required: false, type: Int16.self)
|
||||
try _v.visit(field: VTOFFSET.name.p, fieldName: "name", required: false, type: ForwardOffset<String>.self)
|
||||
try _v.visit(field: VTOFFSET.inventory.p, fieldName: "inventory", required: false, type: ForwardOffset<Vector<UInt8, UInt8>>.self)
|
||||
try _v.visit(field: VTOFFSET.color.p, fieldName: "color", required: false, type: MyGame_Sample_Color.self)
|
||||
try _v.visit(field: VTOFFSET.weapons.p, fieldName: "weapons", required: false, type: ForwardOffset<Vector<ForwardOffset<MyGame_Sample_Weapon>, MyGame_Sample_Weapon>>.self)
|
||||
try _v.visit(unionKey: VTOFFSET.equippedType.p, unionField: VTOFFSET.equipped.p, unionKeyName: "equippedType", fieldName: "equipped", required: false, completion: { (verifier, key: MyGame_Sample_Equipment, pos) in
|
||||
try _v.visit(field: VT.pos, fieldName: "pos", required: false, type: MyGame_Sample_Vec3.self)
|
||||
try _v.visit(field: VT.mana, fieldName: "mana", required: false, type: Int16.self)
|
||||
try _v.visit(field: VT.hp, fieldName: "hp", required: false, type: Int16.self)
|
||||
try _v.visit(field: VT.name, fieldName: "name", required: false, type: ForwardOffset<String>.self)
|
||||
try _v.visit(field: VT.inventory, fieldName: "inventory", required: false, type: ForwardOffset<Vector<UInt8, UInt8>>.self)
|
||||
try _v.visit(field: VT.color, fieldName: "color", required: false, type: MyGame_Sample_Color.self)
|
||||
try _v.visit(field: VT.weapons, fieldName: "weapons", required: false, type: ForwardOffset<Vector<ForwardOffset<MyGame_Sample_Weapon>, MyGame_Sample_Weapon>>.self)
|
||||
try _v.visit(unionKey: VT.equippedType, unionField: VT.equipped, unionKeyName: "equippedType", fieldName: "equipped", required: false, completion: { (verifier, key: MyGame_Sample_Equipment, pos) in
|
||||
switch key {
|
||||
case .none_:
|
||||
break // NOTE - SWIFT doesnt support none
|
||||
@@ -308,13 +306,12 @@ public struct MyGame_Sample_Monster: FlatBufferTable, FlatbuffersVectorInitializ
|
||||
try ForwardOffset<MyGame_Sample_Weapon>.verify(&verifier, at: pos, of: MyGame_Sample_Weapon.self)
|
||||
}
|
||||
})
|
||||
try _v.visit(field: VTOFFSET.path.p, fieldName: "path", required: false, type: ForwardOffset<Vector<MyGame_Sample_Vec3, MyGame_Sample_Vec3>>.self)
|
||||
try _v.visit(field: VT.path, fieldName: "path", required: false, type: ForwardOffset<Vector<MyGame_Sample_Vec3, MyGame_Sample_Vec3>>.self)
|
||||
_v.finish()
|
||||
}
|
||||
}
|
||||
|
||||
extension MyGame_Sample_Monster: Encodable {
|
||||
|
||||
enum CodingKeys: String, CodingKey {
|
||||
case pos = "pos"
|
||||
case mana = "mana"
|
||||
@@ -327,6 +324,7 @@ extension MyGame_Sample_Monster: Encodable {
|
||||
case equipped = "equipped"
|
||||
case path = "path"
|
||||
}
|
||||
|
||||
public func encode(to encoder: Encoder) throws {
|
||||
var container = encoder.container(keyedBy: CodingKeys.self)
|
||||
try container.encodeIfPresent(pos, forKey: .pos)
|
||||
@@ -411,20 +409,18 @@ public struct MyGame_Sample_Weapon: FlatBufferTable, FlatbuffersVectorInitializa
|
||||
private init(_ t: Table) { _accessor = t }
|
||||
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
|
||||
|
||||
private enum VTOFFSET: VOffset {
|
||||
case name = 4
|
||||
case damage = 6
|
||||
var v: Int32 { Int32(self.rawValue) }
|
||||
var p: VOffset { self.rawValue }
|
||||
private struct VT {
|
||||
static let name: VOffset = 4
|
||||
static let damage: VOffset = 6
|
||||
}
|
||||
|
||||
public var name: String? { let o = _accessor.offset(VTOFFSET.name.v); return o == 0 ? nil : _accessor.string(at: o) }
|
||||
public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.name.v) }
|
||||
public var damage: Int16 { let o = _accessor.offset(VTOFFSET.damage.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int16.self, at: o) }
|
||||
@discardableResult public func mutate(damage: Int16) -> Bool {let o = _accessor.offset(VTOFFSET.damage.v); return _accessor.mutate(damage, index: o) }
|
||||
public var name: String? { let o = _accessor.offset(VT.name); return o == 0 ? nil : _accessor.string(at: o) }
|
||||
public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.name) }
|
||||
public var damage: Int16 { let o = _accessor.offset(VT.damage); return o == 0 ? 0 : _accessor.readBuffer(of: Int16.self, at: o) }
|
||||
@discardableResult public func mutate(damage: Int16) -> Bool {let o = _accessor.offset(VT.damage); return _accessor.mutate(damage, index: o) }
|
||||
public static func startWeapon(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 2) }
|
||||
public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VTOFFSET.name.p) }
|
||||
public static func add(damage: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: damage, def: 0, at: VTOFFSET.damage.p) }
|
||||
public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VT.name) }
|
||||
public static func add(damage: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: damage, def: 0, at: VT.damage) }
|
||||
public static func endWeapon(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
|
||||
public static func createWeapon(
|
||||
_ fbb: inout FlatBufferBuilder,
|
||||
@@ -461,18 +457,18 @@ public struct MyGame_Sample_Weapon: FlatBufferTable, FlatbuffersVectorInitializa
|
||||
|
||||
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
|
||||
var _v = try verifier.visitTable(at: position)
|
||||
try _v.visit(field: VTOFFSET.name.p, fieldName: "name", required: false, type: ForwardOffset<String>.self)
|
||||
try _v.visit(field: VTOFFSET.damage.p, fieldName: "damage", required: false, type: Int16.self)
|
||||
try _v.visit(field: VT.name, fieldName: "name", required: false, type: ForwardOffset<String>.self)
|
||||
try _v.visit(field: VT.damage, fieldName: "damage", required: false, type: Int16.self)
|
||||
_v.finish()
|
||||
}
|
||||
}
|
||||
|
||||
extension MyGame_Sample_Weapon: Encodable {
|
||||
|
||||
enum CodingKeys: String, CodingKey {
|
||||
case name = "name"
|
||||
case damage = "damage"
|
||||
}
|
||||
|
||||
public func encode(to encoder: Encoder) throws {
|
||||
var container = encoder.container(keyedBy: CodingKeys.self)
|
||||
try container.encodeIfPresent(name, forKey: .name)
|
||||
|
||||
@@ -1,18 +1,18 @@
|
||||
// Automatically generated by the Flatbuffers compiler. Do not modify.
|
||||
// @generated
|
||||
pub mod my_game {
|
||||
use super::*;
|
||||
pub mod sample {
|
||||
use super::*;
|
||||
mod color_generated;
|
||||
pub use self::color_generated::*;
|
||||
mod equipment_generated;
|
||||
pub use self::equipment_generated::*;
|
||||
mod vec_3_generated;
|
||||
pub use self::vec_3_generated::*;
|
||||
mod monster_generated;
|
||||
pub use self::monster_generated::*;
|
||||
mod weapon_generated;
|
||||
pub use self::weapon_generated::*;
|
||||
} // sample
|
||||
pub mod sample {
|
||||
use super::*;
|
||||
mod color_generated;
|
||||
pub use self::color_generated::*;
|
||||
mod equipment_generated;
|
||||
pub use self::equipment_generated::*;
|
||||
mod vec_3_generated;
|
||||
pub use self::vec_3_generated::*;
|
||||
mod monster_generated;
|
||||
pub use self::monster_generated::*;
|
||||
mod weapon_generated;
|
||||
pub use self::weapon_generated::*;
|
||||
} // sample
|
||||
} // my_game
|
||||
|
||||
@@ -2,64 +2,73 @@
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
use super::*;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MIN_COLOR: i8 = 0;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MAX_COLOR: i8 = 2;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
#[allow(non_camel_case_types)]
|
||||
pub const ENUM_VALUES_COLOR: [Color; 3] = [
|
||||
Color::Red,
|
||||
Color::Green,
|
||||
Color::Blue,
|
||||
Color::Red,
|
||||
Color::Green,
|
||||
Color::Blue,
|
||||
];
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
|
||||
#[repr(transparent)]
|
||||
pub struct Color(pub i8);
|
||||
|
||||
#[allow(non_upper_case_globals)]
|
||||
impl Color {
|
||||
pub const Red: Self = Self(0);
|
||||
pub const Green: Self = Self(1);
|
||||
pub const Blue: Self = Self(2);
|
||||
pub const Red: Self = Self(0);
|
||||
pub const Green: Self = Self(1);
|
||||
pub const Blue: Self = Self(2);
|
||||
|
||||
pub const ENUM_MIN: i8 = 0;
|
||||
pub const ENUM_MAX: i8 = 2;
|
||||
pub const ENUM_VALUES: &'static [Self] = &[
|
||||
Self::Red,
|
||||
Self::Green,
|
||||
Self::Blue,
|
||||
];
|
||||
/// Returns the variant's name or "" if unknown.
|
||||
pub fn variant_name(self) -> Option<&'static str> {
|
||||
match self {
|
||||
Self::Red => Some("Red"),
|
||||
Self::Green => Some("Green"),
|
||||
Self::Blue => Some("Blue"),
|
||||
_ => None,
|
||||
pub const ENUM_MIN: i8 = 0;
|
||||
pub const ENUM_MAX: i8 = 2;
|
||||
pub const ENUM_VALUES: &'static [Self] = &[
|
||||
Self::Red,
|
||||
Self::Green,
|
||||
Self::Blue,
|
||||
];
|
||||
|
||||
/// Returns the variant's name or "" if unknown.
|
||||
pub fn variant_name(self) -> Option<&'static str> {
|
||||
match self {
|
||||
Self::Red => Some("Red"),
|
||||
Self::Green => Some("Green"),
|
||||
Self::Blue => Some("Blue"),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for Color {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
if let Some(name) = self.variant_name() {
|
||||
f.write_str(name)
|
||||
} else {
|
||||
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
if let Some(name) = self.variant_name() {
|
||||
f.write_str(name)
|
||||
} else {
|
||||
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for Color {
|
||||
type Inner = Self;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
let b = unsafe { ::flatbuffers::read_scalar_at::<i8>(buf, loc) };
|
||||
Self(b)
|
||||
}
|
||||
type Inner = Self;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
let b = unsafe { ::flatbuffers::read_scalar_at::<i8>(buf, loc) };
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Push for Color {
|
||||
type Output = Color;
|
||||
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
unsafe { ::flatbuffers::emplace_scalar::<i8>(dst, self.0) };
|
||||
@@ -67,26 +76,28 @@ impl ::flatbuffers::Push for Color {
|
||||
}
|
||||
|
||||
impl ::flatbuffers::EndianScalar for Color {
|
||||
type Scalar = i8;
|
||||
#[inline]
|
||||
fn to_little_endian(self) -> i8 {
|
||||
self.0.to_le()
|
||||
}
|
||||
#[inline]
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
fn from_little_endian(v: i8) -> Self {
|
||||
let b = i8::from_le(v);
|
||||
Self(b)
|
||||
}
|
||||
type Scalar = i8;
|
||||
|
||||
#[inline]
|
||||
fn to_little_endian(self) -> i8 {
|
||||
self.0.to_le()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
fn from_little_endian(v: i8) -> Self {
|
||||
let b = i8::from_le(v);
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Verifiable for Color {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
i8::run_verifier(v, pos)
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
i8::run_verifier(v, pos)
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for Color {}
|
||||
|
||||
@@ -2,60 +2,69 @@
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
use super::*;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MIN_EQUIPMENT: u8 = 0;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MAX_EQUIPMENT: u8 = 1;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
#[allow(non_camel_case_types)]
|
||||
pub const ENUM_VALUES_EQUIPMENT: [Equipment; 2] = [
|
||||
Equipment::NONE,
|
||||
Equipment::Weapon,
|
||||
Equipment::NONE,
|
||||
Equipment::Weapon,
|
||||
];
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
|
||||
#[repr(transparent)]
|
||||
pub struct Equipment(pub u8);
|
||||
|
||||
#[allow(non_upper_case_globals)]
|
||||
impl Equipment {
|
||||
pub const NONE: Self = Self(0);
|
||||
pub const Weapon: Self = Self(1);
|
||||
pub const NONE: Self = Self(0);
|
||||
pub const Weapon: Self = Self(1);
|
||||
|
||||
pub const ENUM_MIN: u8 = 0;
|
||||
pub const ENUM_MAX: u8 = 1;
|
||||
pub const ENUM_VALUES: &'static [Self] = &[
|
||||
Self::NONE,
|
||||
Self::Weapon,
|
||||
];
|
||||
/// Returns the variant's name or "" if unknown.
|
||||
pub fn variant_name(self) -> Option<&'static str> {
|
||||
match self {
|
||||
Self::NONE => Some("NONE"),
|
||||
Self::Weapon => Some("Weapon"),
|
||||
_ => None,
|
||||
pub const ENUM_MIN: u8 = 0;
|
||||
pub const ENUM_MAX: u8 = 1;
|
||||
pub const ENUM_VALUES: &'static [Self] = &[
|
||||
Self::NONE,
|
||||
Self::Weapon,
|
||||
];
|
||||
|
||||
/// Returns the variant's name or "" if unknown.
|
||||
pub fn variant_name(self) -> Option<&'static str> {
|
||||
match self {
|
||||
Self::NONE => Some("NONE"),
|
||||
Self::Weapon => Some("Weapon"),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for Equipment {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
if let Some(name) = self.variant_name() {
|
||||
f.write_str(name)
|
||||
} else {
|
||||
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
if let Some(name) = self.variant_name() {
|
||||
f.write_str(name)
|
||||
} else {
|
||||
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for Equipment {
|
||||
type Inner = Self;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
|
||||
Self(b)
|
||||
}
|
||||
type Inner = Self;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Push for Equipment {
|
||||
type Output = Equipment;
|
||||
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
|
||||
@@ -63,75 +72,85 @@ impl ::flatbuffers::Push for Equipment {
|
||||
}
|
||||
|
||||
impl ::flatbuffers::EndianScalar for Equipment {
|
||||
type Scalar = u8;
|
||||
#[inline]
|
||||
fn to_little_endian(self) -> u8 {
|
||||
self.0.to_le()
|
||||
}
|
||||
#[inline]
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
fn from_little_endian(v: u8) -> Self {
|
||||
let b = u8::from_le(v);
|
||||
Self(b)
|
||||
}
|
||||
type Scalar = u8;
|
||||
|
||||
#[inline]
|
||||
fn to_little_endian(self) -> u8 {
|
||||
self.0.to_le()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
fn from_little_endian(v: u8) -> Self {
|
||||
let b = u8::from_le(v);
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Verifiable for Equipment {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
u8::run_verifier(v, pos)
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
u8::run_verifier(v, pos)
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for Equipment {}
|
||||
|
||||
pub struct EquipmentUnionTableOffset {}
|
||||
|
||||
#[allow(clippy::upper_case_acronyms)]
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum EquipmentT {
|
||||
NONE,
|
||||
Weapon(alloc::boxed::Box<WeaponT>),
|
||||
NONE,
|
||||
Weapon(alloc::boxed::Box<WeaponT>),
|
||||
}
|
||||
|
||||
impl Default for EquipmentT {
|
||||
fn default() -> Self {
|
||||
Self::NONE
|
||||
}
|
||||
fn default() -> Self {
|
||||
Self::NONE
|
||||
}
|
||||
}
|
||||
|
||||
impl EquipmentT {
|
||||
pub fn equipment_type(&self) -> Equipment {
|
||||
match self {
|
||||
Self::NONE => Equipment::NONE,
|
||||
Self::Weapon(_) => Equipment::Weapon,
|
||||
pub fn equipment_type(&self) -> Equipment {
|
||||
match self {
|
||||
Self::NONE => Equipment::NONE,
|
||||
Self::Weapon(_) => Equipment::Weapon,
|
||||
}
|
||||
}
|
||||
}
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> {
|
||||
match self {
|
||||
Self::NONE => None,
|
||||
Self::Weapon(v) => Some(v.pack(fbb).as_union_value()),
|
||||
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> {
|
||||
match self {
|
||||
Self::NONE => None,
|
||||
Self::Weapon(v) => Some(v.pack(fbb).as_union_value()),
|
||||
}
|
||||
}
|
||||
}
|
||||
/// If the union variant matches, return the owned WeaponT, setting the union to NONE.
|
||||
pub fn take_weapon(&mut self) -> Option<alloc::boxed::Box<WeaponT>> {
|
||||
if let Self::Weapon(_) = self {
|
||||
let v = ::core::mem::replace(self, Self::NONE);
|
||||
if let Self::Weapon(w) = v {
|
||||
Some(w)
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
} else {
|
||||
None
|
||||
|
||||
/// If the union variant matches, return the owned WeaponT, setting the union to NONE.
|
||||
pub fn take_weapon(&mut self) -> Option<alloc::boxed::Box<WeaponT>> {
|
||||
if let Self::Weapon(_) = self {
|
||||
let v = ::core::mem::replace(self, Self::NONE);
|
||||
if let Self::Weapon(w) = v {
|
||||
Some(w)
|
||||
} else {
|
||||
unreachable!()
|
||||
}
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// If the union variant matches, return a reference to the WeaponT.
|
||||
pub fn as_weapon(&self) -> Option<&WeaponT> {
|
||||
if let Self::Weapon(v) = self { Some(v.as_ref()) } else { None }
|
||||
}
|
||||
|
||||
/// If the union variant matches, return a mutable reference to the WeaponT.
|
||||
pub fn as_weapon_mut(&mut self) -> Option<&mut WeaponT> {
|
||||
if let Self::Weapon(v) = self { Some(v.as_mut()) } else { None }
|
||||
}
|
||||
}
|
||||
/// If the union variant matches, return a reference to the WeaponT.
|
||||
pub fn as_weapon(&self) -> Option<&WeaponT> {
|
||||
if let Self::Weapon(v) = self { Some(v.as_ref()) } else { None }
|
||||
}
|
||||
/// If the union variant matches, return a mutable reference to the WeaponT.
|
||||
pub fn as_weapon_mut(&mut self) -> Option<&mut WeaponT> {
|
||||
if let Self::Weapon(v) = self { Some(v.as_mut()) } else { None }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -2,212 +2,225 @@
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
use super::*;
|
||||
pub enum MonsterOffset {}
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
|
||||
pub enum MonsterOffset {}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
pub struct Monster<'a> {
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for Monster<'a> {
|
||||
type Inner = Monster<'a>;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
type Inner = Monster<'a>;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Monster<'a> {
|
||||
pub const VT_POS: ::flatbuffers::VOffsetT = 4;
|
||||
pub const VT_MANA: ::flatbuffers::VOffsetT = 6;
|
||||
pub const VT_HP: ::flatbuffers::VOffsetT = 8;
|
||||
pub const VT_NAME: ::flatbuffers::VOffsetT = 10;
|
||||
pub const VT_INVENTORY: ::flatbuffers::VOffsetT = 14;
|
||||
pub const VT_COLOR: ::flatbuffers::VOffsetT = 16;
|
||||
pub const VT_WEAPONS: ::flatbuffers::VOffsetT = 18;
|
||||
pub const VT_EQUIPPED_TYPE: ::flatbuffers::VOffsetT = 20;
|
||||
pub const VT_EQUIPPED: ::flatbuffers::VOffsetT = 22;
|
||||
pub const VT_PATH: ::flatbuffers::VOffsetT = 24;
|
||||
pub const VT_POS: ::flatbuffers::VOffsetT = 4;
|
||||
pub const VT_MANA: ::flatbuffers::VOffsetT = 6;
|
||||
pub const VT_HP: ::flatbuffers::VOffsetT = 8;
|
||||
pub const VT_NAME: ::flatbuffers::VOffsetT = 10;
|
||||
pub const VT_INVENTORY: ::flatbuffers::VOffsetT = 14;
|
||||
pub const VT_COLOR: ::flatbuffers::VOffsetT = 16;
|
||||
pub const VT_WEAPONS: ::flatbuffers::VOffsetT = 18;
|
||||
pub const VT_EQUIPPED_TYPE: ::flatbuffers::VOffsetT = 20;
|
||||
pub const VT_EQUIPPED: ::flatbuffers::VOffsetT = 22;
|
||||
pub const VT_PATH: ::flatbuffers::VOffsetT = 24;
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.Sample.Monster"
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
Monster { _tab: table }
|
||||
}
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args MonsterArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<Monster<'bldr>> {
|
||||
let mut builder = MonsterBuilder::new(_fbb);
|
||||
if let Some(x) = args.path { builder.add_path(x); }
|
||||
if let Some(x) = args.equipped { builder.add_equipped(x); }
|
||||
if let Some(x) = args.weapons { builder.add_weapons(x); }
|
||||
if let Some(x) = args.inventory { builder.add_inventory(x); }
|
||||
if let Some(x) = args.name { builder.add_name(x); }
|
||||
if let Some(x) = args.pos { builder.add_pos(x); }
|
||||
builder.add_hp(args.hp);
|
||||
builder.add_mana(args.mana);
|
||||
builder.add_equipped_type(args.equipped_type);
|
||||
builder.add_color(args.color);
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> MonsterT {
|
||||
let pos = self.pos().map(|x| {
|
||||
x.unpack()
|
||||
});
|
||||
let mana = self.mana();
|
||||
let hp = self.hp();
|
||||
let name = self.name().map(|x| {
|
||||
alloc::string::ToString::to_string(x)
|
||||
});
|
||||
let inventory = self.inventory().map(|x| {
|
||||
x.into_iter().collect()
|
||||
});
|
||||
let color = self.color();
|
||||
let weapons = self.weapons().map(|x| {
|
||||
x.iter().map(|t| t.unpack()).collect()
|
||||
});
|
||||
let equipped = match self.equipped_type() {
|
||||
Equipment::NONE => EquipmentT::NONE,
|
||||
Equipment::Weapon => EquipmentT::Weapon(alloc::boxed::Box::new(
|
||||
self.equipped_as_weapon()
|
||||
.expect("Invalid union table, expected `Equipment::Weapon`.")
|
||||
.unpack()
|
||||
)),
|
||||
_ => EquipmentT::NONE,
|
||||
};
|
||||
let path = self.path().map(|x| {
|
||||
x.iter().map(|t| t.unpack()).collect()
|
||||
});
|
||||
MonsterT {
|
||||
pos,
|
||||
mana,
|
||||
hp,
|
||||
name,
|
||||
inventory,
|
||||
color,
|
||||
weapons,
|
||||
equipped,
|
||||
path,
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.Sample.Monster"
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn pos(&self) -> Option<&'a Vec3> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<Vec3>(Monster::VT_POS, None)}
|
||||
}
|
||||
#[inline]
|
||||
pub fn mana(&self) -> i16 {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<i16>(Monster::VT_MANA, Some(150)).unwrap()}
|
||||
}
|
||||
#[inline]
|
||||
pub fn hp(&self) -> i16 {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<i16>(Monster::VT_HP, Some(100)).unwrap()}
|
||||
}
|
||||
#[inline]
|
||||
pub fn name(&self) -> Option<&'a str> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Monster::VT_NAME, None)}
|
||||
}
|
||||
#[inline]
|
||||
pub fn inventory(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_INVENTORY, None)}
|
||||
}
|
||||
#[inline]
|
||||
pub fn color(&self) -> Color {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<Color>(Monster::VT_COLOR, Some(Color::Blue)).unwrap()}
|
||||
}
|
||||
#[inline]
|
||||
pub fn weapons(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Weapon<'a>>>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Weapon>>>>(Monster::VT_WEAPONS, None)}
|
||||
}
|
||||
#[inline]
|
||||
pub fn equipped_type(&self) -> Equipment {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<Equipment>(Monster::VT_EQUIPPED_TYPE, Some(Equipment::NONE)).unwrap()}
|
||||
}
|
||||
#[inline]
|
||||
pub fn equipped(&self) -> Option<::flatbuffers::Table<'a>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_EQUIPPED, None)}
|
||||
}
|
||||
#[inline]
|
||||
pub fn path(&self) -> Option<::flatbuffers::Vector<'a, Vec3>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Vec3>>>(Monster::VT_PATH, None)}
|
||||
}
|
||||
#[inline]
|
||||
#[allow(non_snake_case)]
|
||||
pub fn equipped_as_weapon(&self) -> Option<Weapon<'a>> {
|
||||
if self.equipped_type() == Equipment::Weapon {
|
||||
self.equipped().map(|t| {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid union in this slot
|
||||
unsafe { Weapon::init_from_table(t) }
|
||||
})
|
||||
} else {
|
||||
None
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
Monster { _tab: table }
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args MonsterArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<Monster<'bldr>> {
|
||||
let mut builder = MonsterBuilder::new(_fbb);
|
||||
if let Some(x) = args.path { builder.add_path(x); }
|
||||
if let Some(x) = args.equipped { builder.add_equipped(x); }
|
||||
if let Some(x) = args.weapons { builder.add_weapons(x); }
|
||||
if let Some(x) = args.inventory { builder.add_inventory(x); }
|
||||
if let Some(x) = args.name { builder.add_name(x); }
|
||||
if let Some(x) = args.pos { builder.add_pos(x); }
|
||||
builder.add_hp(args.hp);
|
||||
builder.add_mana(args.mana);
|
||||
builder.add_equipped_type(args.equipped_type);
|
||||
builder.add_color(args.color);
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> MonsterT {
|
||||
let pos = self.pos().map(|x| {
|
||||
x.unpack()
|
||||
});
|
||||
let mana = self.mana();
|
||||
let hp = self.hp();
|
||||
let name = self.name().map(|x| {
|
||||
alloc::string::ToString::to_string(x)
|
||||
});
|
||||
let inventory = self.inventory().map(|x| {
|
||||
x.into_iter().collect()
|
||||
});
|
||||
let color = self.color();
|
||||
let weapons = self.weapons().map(|x| {
|
||||
x.iter().map(|t| t.unpack()).collect()
|
||||
});
|
||||
let equipped = match self.equipped_type() {
|
||||
Equipment::NONE => EquipmentT::NONE,
|
||||
Equipment::Weapon => EquipmentT::Weapon(alloc::boxed::Box::new(
|
||||
self.equipped_as_weapon()
|
||||
.expect("Invalid union table, expected `Equipment::Weapon`.")
|
||||
.unpack()
|
||||
)),
|
||||
_ => EquipmentT::NONE,
|
||||
};
|
||||
let path = self.path().map(|x| {
|
||||
x.iter().map(|t| t.unpack()).collect()
|
||||
});
|
||||
MonsterT {
|
||||
pos,
|
||||
mana,
|
||||
hp,
|
||||
name,
|
||||
inventory,
|
||||
color,
|
||||
weapons,
|
||||
equipped,
|
||||
path,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn pos(&self) -> Option<&'a Vec3> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<Vec3>(Monster::VT_POS, None)}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn mana(&self) -> i16 {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<i16>(Monster::VT_MANA, Some(150)).unwrap()}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn hp(&self) -> i16 {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<i16>(Monster::VT_HP, Some(100)).unwrap()}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn name(&self) -> Option<&'a str> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Monster::VT_NAME, None)}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn inventory(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_INVENTORY, None)}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn color(&self) -> Color {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<Color>(Monster::VT_COLOR, Some(Color::Blue)).unwrap()}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn weapons(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Weapon<'a>>>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Weapon>>>>(Monster::VT_WEAPONS, None)}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn equipped_type(&self) -> Equipment {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<Equipment>(Monster::VT_EQUIPPED_TYPE, Some(Equipment::NONE)).unwrap()}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn equipped(&self) -> Option<::flatbuffers::Table<'a>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_EQUIPPED, None)}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn path(&self) -> Option<::flatbuffers::Vector<'a, Vec3>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Vec3>>>(Monster::VT_PATH, None)}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[allow(non_snake_case)]
|
||||
pub fn equipped_as_weapon(&self) -> Option<Weapon<'a>> {
|
||||
if self.equipped_type() == Equipment::Weapon {
|
||||
self.equipped().map(|t| {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid union in this slot
|
||||
unsafe { Weapon::init_from_table(t) }
|
||||
})
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Verifiable for Monster<'_> {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<Vec3>("pos", Self::VT_POS, false)?
|
||||
.visit_field::<i16>("mana", Self::VT_MANA, false)?
|
||||
.visit_field::<i16>("hp", Self::VT_HP, false)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("inventory", Self::VT_INVENTORY, false)?
|
||||
.visit_field::<Color>("color", Self::VT_COLOR, false)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Weapon>>>>("weapons", Self::VT_WEAPONS, false)?
|
||||
.visit_union::<Equipment, _>("equipped_type", Self::VT_EQUIPPED_TYPE, "equipped", Self::VT_EQUIPPED, false, |key, v, pos| {
|
||||
match key {
|
||||
Equipment::Weapon => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<Weapon>>("Equipment::Weapon", pos),
|
||||
_ => Ok(()),
|
||||
}
|
||||
})?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Vec3>>>("path", Self::VT_PATH, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<Vec3>("pos", Self::VT_POS, false)?
|
||||
.visit_field::<i16>("mana", Self::VT_MANA, false)?
|
||||
.visit_field::<i16>("hp", Self::VT_HP, false)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("inventory", Self::VT_INVENTORY, false)?
|
||||
.visit_field::<Color>("color", Self::VT_COLOR, false)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Weapon>>>>("weapons", Self::VT_WEAPONS, false)?
|
||||
.visit_union::<Equipment, _>("equipped_type", Self::VT_EQUIPPED_TYPE, "equipped", Self::VT_EQUIPPED, false, |key, v, pos| {
|
||||
match key {
|
||||
Equipment::Weapon => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<Weapon>>("Equipment::Weapon", pos),
|
||||
_ => Ok(()),
|
||||
}
|
||||
})?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Vec3>>>("path", Self::VT_PATH, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub struct MonsterArgs<'a> {
|
||||
pub pos: Option<&'a Vec3>,
|
||||
pub mana: i16,
|
||||
@@ -220,246 +233,273 @@ pub struct MonsterArgs<'a> {
|
||||
pub equipped: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
|
||||
pub path: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, Vec3>>>,
|
||||
}
|
||||
|
||||
impl<'a> Default for MonsterArgs<'a> {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
MonsterArgs {
|
||||
pos: None,
|
||||
mana: 150,
|
||||
hp: 100,
|
||||
name: None,
|
||||
inventory: None,
|
||||
color: Color::Blue,
|
||||
weapons: None,
|
||||
equipped_type: Equipment::NONE,
|
||||
equipped: None,
|
||||
path: None,
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
MonsterArgs {
|
||||
pos: None,
|
||||
mana: 150,
|
||||
hp: 100,
|
||||
name: None,
|
||||
inventory: None,
|
||||
color: Color::Blue,
|
||||
weapons: None,
|
||||
equipped_type: Equipment::NONE,
|
||||
equipped: None,
|
||||
path: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct MonsterBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
}
|
||||
|
||||
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> MonsterBuilder<'a, 'b, A> {
|
||||
#[inline]
|
||||
pub fn add_pos(&mut self, pos: &Vec3) {
|
||||
self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos);
|
||||
}
|
||||
#[inline]
|
||||
pub fn add_mana(&mut self, mana: i16) {
|
||||
self.fbb_.push_slot::<i16>(Monster::VT_MANA, mana, 150);
|
||||
}
|
||||
#[inline]
|
||||
pub fn add_hp(&mut self, hp: i16) {
|
||||
self.fbb_.push_slot::<i16>(Monster::VT_HP, hp, 100);
|
||||
}
|
||||
#[inline]
|
||||
pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b str>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_NAME, name);
|
||||
}
|
||||
#[inline]
|
||||
pub fn add_inventory(&mut self, inventory: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_INVENTORY, inventory);
|
||||
}
|
||||
#[inline]
|
||||
pub fn add_color(&mut self, color: Color) {
|
||||
self.fbb_.push_slot::<Color>(Monster::VT_COLOR, color, Color::Blue);
|
||||
}
|
||||
#[inline]
|
||||
pub fn add_weapons(&mut self, weapons: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Weapon<'b >>>>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_WEAPONS, weapons);
|
||||
}
|
||||
#[inline]
|
||||
pub fn add_equipped_type(&mut self, equipped_type: Equipment) {
|
||||
self.fbb_.push_slot::<Equipment>(Monster::VT_EQUIPPED_TYPE, equipped_type, Equipment::NONE);
|
||||
}
|
||||
#[inline]
|
||||
pub fn add_equipped(&mut self, equipped: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_EQUIPPED, equipped);
|
||||
}
|
||||
#[inline]
|
||||
pub fn add_path(&mut self, path: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Vec3>>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_PATH, path);
|
||||
}
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
MonsterBuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
#[inline]
|
||||
pub fn add_pos(&mut self, pos: &Vec3) {
|
||||
self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn add_mana(&mut self, mana: i16) {
|
||||
self.fbb_.push_slot::<i16>(Monster::VT_MANA, mana, 150);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn add_hp(&mut self, hp: i16) {
|
||||
self.fbb_.push_slot::<i16>(Monster::VT_HP, hp, 100);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b str>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_NAME, name);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn add_inventory(&mut self, inventory: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_INVENTORY, inventory);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn add_color(&mut self, color: Color) {
|
||||
self.fbb_.push_slot::<Color>(Monster::VT_COLOR, color, Color::Blue);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn add_weapons(&mut self, weapons: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Weapon<'b >>>>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_WEAPONS, weapons);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn add_equipped_type(&mut self, equipped_type: Equipment) {
|
||||
self.fbb_.push_slot::<Equipment>(Monster::VT_EQUIPPED_TYPE, equipped_type, Equipment::NONE);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn add_equipped(&mut self, equipped: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_EQUIPPED, equipped);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn add_path(&mut self, path: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Vec3>>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_PATH, path);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
MonsterBuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<Monster<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<Monster<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for Monster<'_> {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("Monster");
|
||||
ds.field("pos", &self.pos());
|
||||
ds.field("mana", &self.mana());
|
||||
ds.field("hp", &self.hp());
|
||||
ds.field("name", &self.name());
|
||||
ds.field("inventory", &self.inventory());
|
||||
ds.field("color", &self.color());
|
||||
ds.field("weapons", &self.weapons());
|
||||
ds.field("equipped_type", &self.equipped_type());
|
||||
match self.equipped_type() {
|
||||
Equipment::Weapon => {
|
||||
if let Some(x) = self.equipped_as_weapon() {
|
||||
ds.field("equipped", &x)
|
||||
} else {
|
||||
ds.field("equipped", &"InvalidFlatbuffer: Union discriminant does not match value.")
|
||||
}
|
||||
},
|
||||
_ => {
|
||||
let x: Option<()> = None;
|
||||
ds.field("equipped", &x)
|
||||
},
|
||||
};
|
||||
ds.field("path", &self.path());
|
||||
ds.finish()
|
||||
}
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("Monster");
|
||||
ds.field("pos", &self.pos());
|
||||
ds.field("mana", &self.mana());
|
||||
ds.field("hp", &self.hp());
|
||||
ds.field("name", &self.name());
|
||||
ds.field("inventory", &self.inventory());
|
||||
ds.field("color", &self.color());
|
||||
ds.field("weapons", &self.weapons());
|
||||
ds.field("equipped_type", &self.equipped_type());
|
||||
match self.equipped_type() {
|
||||
Equipment::Weapon => {
|
||||
if let Some(x) = self.equipped_as_weapon() {
|
||||
ds.field("equipped", &x)
|
||||
} else {
|
||||
ds.field("equipped", &"InvalidFlatbuffer: Union discriminant does not match value.")
|
||||
}
|
||||
},
|
||||
_ => {
|
||||
let x: Option<()> = None;
|
||||
ds.field("equipped", &x)
|
||||
},
|
||||
};
|
||||
ds.field("path", &self.path());
|
||||
ds.finish()
|
||||
}
|
||||
}
|
||||
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct MonsterT {
|
||||
pub pos: Option<Vec3T>,
|
||||
pub mana: i16,
|
||||
pub hp: i16,
|
||||
pub name: Option<alloc::string::String>,
|
||||
pub inventory: Option<alloc::vec::Vec<u8>>,
|
||||
pub color: Color,
|
||||
pub weapons: Option<alloc::vec::Vec<WeaponT>>,
|
||||
pub equipped: EquipmentT,
|
||||
pub path: Option<alloc::vec::Vec<Vec3T>>,
|
||||
pub pos: Option<Vec3T>,
|
||||
pub mana: i16,
|
||||
pub hp: i16,
|
||||
pub name: Option<alloc::string::String>,
|
||||
pub inventory: Option<alloc::vec::Vec<u8>>,
|
||||
pub color: Color,
|
||||
pub weapons: Option<alloc::vec::Vec<WeaponT>>,
|
||||
pub equipped: EquipmentT,
|
||||
pub path: Option<alloc::vec::Vec<Vec3T>>,
|
||||
}
|
||||
|
||||
impl Default for MonsterT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
pos: None,
|
||||
mana: 150,
|
||||
hp: 100,
|
||||
name: None,
|
||||
inventory: None,
|
||||
color: Color::Blue,
|
||||
weapons: None,
|
||||
equipped: EquipmentT::NONE,
|
||||
path: None,
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
pos: None,
|
||||
mana: 150,
|
||||
hp: 100,
|
||||
name: None,
|
||||
inventory: None,
|
||||
color: Color::Blue,
|
||||
weapons: None,
|
||||
equipped: EquipmentT::NONE,
|
||||
path: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl MonsterT {
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<Monster<'b>> {
|
||||
let pos_tmp = self.pos.as_ref().map(|x| x.pack());
|
||||
let pos = pos_tmp.as_ref();
|
||||
let mana = self.mana;
|
||||
let hp = self.hp;
|
||||
let name = self.name.as_ref().map(|x|{
|
||||
_fbb.create_string(x)
|
||||
});
|
||||
let inventory = self.inventory.as_ref().map(|x|{
|
||||
_fbb.create_vector(x)
|
||||
});
|
||||
let color = self.color;
|
||||
let weapons = self.weapons.as_ref().map(|x|{
|
||||
let w: alloc::vec::Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w)
|
||||
});
|
||||
let equipped_type = self.equipped.equipment_type();
|
||||
let equipped = self.equipped.pack(_fbb);
|
||||
let path = self.path.as_ref().map(|x|{
|
||||
let w: alloc::vec::Vec<_> = x.iter().map(|t| t.pack()).collect();_fbb.create_vector(&w)
|
||||
});
|
||||
Monster::create(_fbb, &MonsterArgs{
|
||||
pos,
|
||||
mana,
|
||||
hp,
|
||||
name,
|
||||
inventory,
|
||||
color,
|
||||
weapons,
|
||||
equipped_type,
|
||||
equipped,
|
||||
path,
|
||||
})
|
||||
}
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<Monster<'b>> {
|
||||
let pos_tmp = self.pos.as_ref().map(|x| x.pack());
|
||||
let pos = pos_tmp.as_ref();
|
||||
let mana = self.mana;
|
||||
let hp = self.hp;
|
||||
let name = self.name.as_ref().map(|x|{
|
||||
_fbb.create_string(x)
|
||||
});
|
||||
let inventory = self.inventory.as_ref().map(|x|{
|
||||
_fbb.create_vector(x)
|
||||
});
|
||||
let color = self.color;
|
||||
let weapons = self.weapons.as_ref().map(|x|{
|
||||
let w: alloc::vec::Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w)
|
||||
});
|
||||
let equipped_type = self.equipped.equipment_type();
|
||||
let equipped = self.equipped.pack(_fbb);
|
||||
let path = self.path.as_ref().map(|x|{
|
||||
let w: alloc::vec::Vec<_> = x.iter().map(|t| t.pack()).collect();_fbb.create_vector(&w)
|
||||
});
|
||||
Monster::create(_fbb, &MonsterArgs{
|
||||
pos,
|
||||
mana,
|
||||
hp,
|
||||
name,
|
||||
inventory,
|
||||
color,
|
||||
weapons,
|
||||
equipped_type,
|
||||
equipped,
|
||||
path,
|
||||
})
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
|
||||
/// Verifies that a buffer of bytes contains a `Monster`
|
||||
/// and returns it.
|
||||
/// Note that verification is still experimental and may not
|
||||
/// catch every error, or be maximally performant. For the
|
||||
/// previous, unchecked, behavior use
|
||||
/// `root_as_monster_unchecked`.
|
||||
pub fn root_as_monster(buf: &[u8]) -> Result<Monster<'_>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::root::<Monster>(buf)
|
||||
}
|
||||
#[inline]
|
||||
pub fn root_as_monster(buf: &[u8]) -> Result<Monster<'_>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::root::<Monster>(buf)
|
||||
}
|
||||
|
||||
/// Verifies that a buffer of bytes contains a size prefixed
|
||||
/// `Monster` and returns it.
|
||||
/// Note that verification is still experimental and may not
|
||||
/// catch every error, or be maximally performant. For the
|
||||
/// previous, unchecked, behavior use
|
||||
/// `size_prefixed_root_as_monster_unchecked`.
|
||||
pub fn size_prefixed_root_as_monster(buf: &[u8]) -> Result<Monster<'_>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::size_prefixed_root::<Monster>(buf)
|
||||
}
|
||||
#[inline]
|
||||
pub fn size_prefixed_root_as_monster(buf: &[u8]) -> Result<Monster<'_>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::size_prefixed_root::<Monster>(buf)
|
||||
}
|
||||
|
||||
/// Verifies, with the given options, that a buffer of bytes
|
||||
/// contains a `Monster` and returns it.
|
||||
/// Note that verification is still experimental and may not
|
||||
/// catch every error, or be maximally performant. For the
|
||||
/// previous, unchecked, behavior use
|
||||
/// `root_as_monster_unchecked`.
|
||||
pub fn root_as_monster_with_opts<'b, 'o>(
|
||||
opts: &'o ::flatbuffers::VerifierOptions,
|
||||
buf: &'b [u8],
|
||||
) -> Result<Monster<'b>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::root_with_opts::<Monster<'b>>(opts, buf)
|
||||
}
|
||||
#[inline]
|
||||
pub fn root_as_monster_with_opts<'b, 'o>(
|
||||
opts: &'o ::flatbuffers::VerifierOptions,
|
||||
buf: &'b [u8],
|
||||
) -> Result<Monster<'b>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::root_with_opts::<Monster<'b>>(opts, buf)
|
||||
}
|
||||
|
||||
/// Verifies, with the given verifier options, that a buffer of
|
||||
/// bytes contains a size prefixed `Monster` and returns
|
||||
/// it. Note that verification is still experimental and may not
|
||||
/// catch every error, or be maximally performant. For the
|
||||
/// previous, unchecked, behavior use
|
||||
/// `root_as_monster_unchecked`.
|
||||
pub fn size_prefixed_root_as_monster_with_opts<'b, 'o>(
|
||||
opts: &'o ::flatbuffers::VerifierOptions,
|
||||
buf: &'b [u8],
|
||||
) -> Result<Monster<'b>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::size_prefixed_root_with_opts::<Monster<'b>>(opts, buf)
|
||||
}
|
||||
#[inline]
|
||||
pub fn size_prefixed_root_as_monster_with_opts<'b, 'o>(
|
||||
opts: &'o ::flatbuffers::VerifierOptions,
|
||||
buf: &'b [u8],
|
||||
) -> Result<Monster<'b>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::size_prefixed_root_with_opts::<Monster<'b>>(opts, buf)
|
||||
}
|
||||
|
||||
/// Assumes, without verification, that a buffer of bytes contains a Monster and returns it.
|
||||
/// # Safety
|
||||
/// Callers must trust the given bytes do indeed contain a valid `Monster`.
|
||||
pub unsafe fn root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> {
|
||||
unsafe { ::flatbuffers::root_unchecked::<Monster>(buf) }
|
||||
}
|
||||
#[inline]
|
||||
pub unsafe fn root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> {
|
||||
unsafe { ::flatbuffers::root_unchecked::<Monster>(buf) }
|
||||
}
|
||||
|
||||
/// Assumes, without verification, that a buffer of bytes contains a size prefixed Monster and returns it.
|
||||
/// # Safety
|
||||
/// Callers must trust the given bytes do indeed contain a valid size prefixed `Monster`.
|
||||
pub unsafe fn size_prefixed_root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> {
|
||||
unsafe { ::flatbuffers::size_prefixed_root_unchecked::<Monster>(buf) }
|
||||
}
|
||||
#[inline]
|
||||
pub fn finish_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
|
||||
fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
root: ::flatbuffers::WIPOffset<Monster<'a>>) {
|
||||
fbb.finish(root, None);
|
||||
pub unsafe fn size_prefixed_root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> {
|
||||
unsafe { ::flatbuffers::size_prefixed_root_unchecked::<Monster>(buf) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn finish_size_prefixed_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset<Monster<'a>>) {
|
||||
fbb.finish_size_prefixed(root, None);
|
||||
pub fn finish_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
|
||||
fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
root: ::flatbuffers::WIPOffset<Monster<'a>>
|
||||
) {
|
||||
fbb.finish(root, None);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn finish_size_prefixed_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
|
||||
fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
root: ::flatbuffers::WIPOffset<Monster<'a>>
|
||||
) {
|
||||
fbb.finish_size_prefixed(root, None);
|
||||
}
|
||||
|
||||
@@ -2,47 +2,57 @@
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
use super::*;
|
||||
|
||||
// struct Vec3, aligned to 4
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
pub struct Vec3(pub [u8; 12]);
|
||||
impl Default for Vec3 {
|
||||
fn default() -> Self {
|
||||
Self([0; 12])
|
||||
}
|
||||
|
||||
impl Default for Vec3 {
|
||||
fn default() -> Self {
|
||||
Self([0; 12])
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for Vec3 {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
f.debug_struct("Vec3")
|
||||
.field("x", &self.x())
|
||||
.field("y", &self.y())
|
||||
.field("z", &self.z())
|
||||
.finish()
|
||||
}
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
f.debug_struct("Vec3")
|
||||
.field("x", &self.x())
|
||||
.field("y", &self.y())
|
||||
.field("z", &self.z())
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for Vec3 {}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for Vec3 {
|
||||
type Inner = &'a Vec3;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { <&'a Vec3>::follow(buf, loc) }
|
||||
}
|
||||
type Inner = &'a Vec3;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { <&'a Vec3>::follow(buf, loc) }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for &'a Vec3 {
|
||||
type Inner = &'a Vec3;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { ::flatbuffers::follow_cast_ref::<Vec3>(buf, loc) }
|
||||
}
|
||||
type Inner = &'a Vec3;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { ::flatbuffers::follow_cast_ref::<Vec3>(buf, loc) }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'b> ::flatbuffers::Push for Vec3 {
|
||||
type Output = Vec3;
|
||||
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
let src = unsafe { ::core::slice::from_raw_parts(self as *const Vec3 as *const u8, <Self as ::flatbuffers::Push>::size()) };
|
||||
dst.copy_from_slice(src);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn alignment() -> ::flatbuffers::PushAlignment {
|
||||
::flatbuffers::PushAlignment::new(4)
|
||||
@@ -50,141 +60,150 @@ impl<'b> ::flatbuffers::Push for Vec3 {
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Verifiable for Vec3 {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.in_buffer::<Self>(pos)
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.in_buffer::<Self>(pos)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Vec3 {
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn new(
|
||||
x: f32,
|
||||
y: f32,
|
||||
z: f32,
|
||||
) -> Self {
|
||||
let mut s = Self([0; 12]);
|
||||
s.set_x(x);
|
||||
s.set_y(y);
|
||||
s.set_z(z);
|
||||
s
|
||||
}
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.Sample.Vec3"
|
||||
}
|
||||
|
||||
pub fn x(&self) -> f32 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[0..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_x(&mut self, x: f32) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[0..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn new(
|
||||
x: f32,
|
||||
y: f32,
|
||||
z: f32,
|
||||
) -> Self {
|
||||
let mut s = Self([0; 12]);
|
||||
s.set_x(x);
|
||||
s.set_y(y);
|
||||
s.set_z(z);
|
||||
s
|
||||
}
|
||||
}
|
||||
|
||||
pub fn y(&self) -> f32 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[4..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_y(&mut self, x: f32) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[4..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.Sample.Vec3"
|
||||
}
|
||||
}
|
||||
|
||||
pub fn z(&self) -> f32 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[8..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_z(&mut self, x: f32) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[8..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
pub fn x(&self) -> f32 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[0..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> Vec3T {
|
||||
Vec3T {
|
||||
x: self.x(),
|
||||
y: self.y(),
|
||||
z: self.z(),
|
||||
pub fn set_x(&mut self, x: f32) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[0..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn y(&self) -> f32 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[4..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_y(&mut self, x: f32) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[4..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn z(&self) -> f32 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[8..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_z(&mut self, x: f32) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[8..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> Vec3T {
|
||||
Vec3T {
|
||||
x: self.x(),
|
||||
y: self.y(),
|
||||
z: self.z(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct Vec3T {
|
||||
pub x: f32,
|
||||
pub y: f32,
|
||||
pub z: f32,
|
||||
pub x: f32,
|
||||
pub y: f32,
|
||||
pub z: f32,
|
||||
}
|
||||
impl Vec3T {
|
||||
pub fn pack(&self) -> Vec3 {
|
||||
Vec3::new(
|
||||
self.x,
|
||||
self.y,
|
||||
self.z,
|
||||
)
|
||||
}
|
||||
impl Default for Vec3T {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
x: 0.0,
|
||||
y: 0.0,
|
||||
z: 0.0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Vec3T {
|
||||
pub fn pack(&self) -> Vec3 {
|
||||
Vec3::new(
|
||||
self.x,
|
||||
self.y,
|
||||
self.z,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,159 +2,172 @@
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
use super::*;
|
||||
pub enum WeaponOffset {}
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
|
||||
pub enum WeaponOffset {}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
pub struct Weapon<'a> {
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for Weapon<'a> {
|
||||
type Inner = Weapon<'a>;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
type Inner = Weapon<'a>;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Weapon<'a> {
|
||||
pub const VT_NAME: ::flatbuffers::VOffsetT = 4;
|
||||
pub const VT_DAMAGE: ::flatbuffers::VOffsetT = 6;
|
||||
pub const VT_NAME: ::flatbuffers::VOffsetT = 4;
|
||||
pub const VT_DAMAGE: ::flatbuffers::VOffsetT = 6;
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.Sample.Weapon"
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
Weapon { _tab: table }
|
||||
}
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args WeaponArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<Weapon<'bldr>> {
|
||||
let mut builder = WeaponBuilder::new(_fbb);
|
||||
if let Some(x) = args.name { builder.add_name(x); }
|
||||
builder.add_damage(args.damage);
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> WeaponT {
|
||||
let name = self.name().map(|x| {
|
||||
alloc::string::ToString::to_string(x)
|
||||
});
|
||||
let damage = self.damage();
|
||||
WeaponT {
|
||||
name,
|
||||
damage,
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.Sample.Weapon"
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn name(&self) -> Option<&'a str> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Weapon::VT_NAME, None)}
|
||||
}
|
||||
#[inline]
|
||||
pub fn damage(&self) -> i16 {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<i16>(Weapon::VT_DAMAGE, Some(0)).unwrap()}
|
||||
}
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
Weapon { _tab: table }
|
||||
}
|
||||
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args WeaponArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<Weapon<'bldr>> {
|
||||
let mut builder = WeaponBuilder::new(_fbb);
|
||||
if let Some(x) = args.name { builder.add_name(x); }
|
||||
builder.add_damage(args.damage);
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> WeaponT {
|
||||
let name = self.name().map(|x| {
|
||||
alloc::string::ToString::to_string(x)
|
||||
});
|
||||
let damage = self.damage();
|
||||
WeaponT {
|
||||
name,
|
||||
damage,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn name(&self) -> Option<&'a str> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Weapon::VT_NAME, None)}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn damage(&self) -> i16 {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<i16>(Weapon::VT_DAMAGE, Some(0)).unwrap()}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Verifiable for Weapon<'_> {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
|
||||
.visit_field::<i16>("damage", Self::VT_DAMAGE, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
|
||||
.visit_field::<i16>("damage", Self::VT_DAMAGE, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub struct WeaponArgs<'a> {
|
||||
pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
|
||||
pub damage: i16,
|
||||
}
|
||||
|
||||
impl<'a> Default for WeaponArgs<'a> {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
WeaponArgs {
|
||||
name: None,
|
||||
damage: 0,
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
WeaponArgs {
|
||||
name: None,
|
||||
damage: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct WeaponBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
}
|
||||
|
||||
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> WeaponBuilder<'a, 'b, A> {
|
||||
#[inline]
|
||||
pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b str>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Weapon::VT_NAME, name);
|
||||
}
|
||||
#[inline]
|
||||
pub fn add_damage(&mut self, damage: i16) {
|
||||
self.fbb_.push_slot::<i16>(Weapon::VT_DAMAGE, damage, 0);
|
||||
}
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> WeaponBuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
WeaponBuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
#[inline]
|
||||
pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b str>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Weapon::VT_NAME, name);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn add_damage(&mut self, damage: i16) {
|
||||
self.fbb_.push_slot::<i16>(Weapon::VT_DAMAGE, damage, 0);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> WeaponBuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
WeaponBuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<Weapon<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<Weapon<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for Weapon<'_> {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("Weapon");
|
||||
ds.field("name", &self.name());
|
||||
ds.field("damage", &self.damage());
|
||||
ds.finish()
|
||||
}
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("Weapon");
|
||||
ds.field("name", &self.name());
|
||||
ds.field("damage", &self.damage());
|
||||
ds.finish()
|
||||
}
|
||||
}
|
||||
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct WeaponT {
|
||||
pub name: Option<alloc::string::String>,
|
||||
pub damage: i16,
|
||||
pub name: Option<alloc::string::String>,
|
||||
pub damage: i16,
|
||||
}
|
||||
|
||||
impl Default for WeaponT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
name: None,
|
||||
damage: 0,
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
name: None,
|
||||
damage: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl WeaponT {
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<Weapon<'b>> {
|
||||
let name = self.name.as_ref().map(|x|{
|
||||
_fbb.create_string(x)
|
||||
});
|
||||
let damage = self.damage;
|
||||
Weapon::create(_fbb, &WeaponArgs{
|
||||
name,
|
||||
damage,
|
||||
})
|
||||
}
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<Weapon<'b>> {
|
||||
let name = self.name.as_ref().map(|x|{
|
||||
_fbb.create_string(x)
|
||||
});
|
||||
let damage = self.damage;
|
||||
Weapon::create(_fbb, &WeaponArgs{
|
||||
name,
|
||||
damage,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
+17
-15
@@ -251,21 +251,6 @@ flatc(
|
||||
schema="vector_table_naked_ptr.fbs",
|
||||
)
|
||||
|
||||
flatc(
|
||||
[
|
||||
"--cpp",
|
||||
"--gen-compare",
|
||||
"--gen-mutable",
|
||||
"--gen-object-api",
|
||||
"--reflect-names",
|
||||
"--cpp-include",
|
||||
"test_vector_type.h",
|
||||
"--cpp-vector-type",
|
||||
"::flatbuffers::tests::CustomVector",
|
||||
],
|
||||
schema="cpp_vector_type.fbs",
|
||||
)
|
||||
|
||||
flatc(
|
||||
BASE_OPTS + CPP_OPTS + CS_OPTS + JAVA_OPTS + KOTLIN_OPTS + PHP_OPTS,
|
||||
prefix="union_vector",
|
||||
@@ -409,6 +394,11 @@ flatc(
|
||||
schema="native_inline_table_test.fbs",
|
||||
)
|
||||
|
||||
flatc(
|
||||
["--cpp", "--gen-compare", "--gen-mutable", "--gen-object-api", "--reflect-names"],
|
||||
schema="cross_namespace_pack_test.fbs",
|
||||
)
|
||||
|
||||
flatc(
|
||||
RUST_OPTS,
|
||||
prefix="arrays_test",
|
||||
@@ -432,6 +422,11 @@ flatc(
|
||||
schema="nested_union_test.fbs",
|
||||
)
|
||||
|
||||
flatc(
|
||||
["--python", "--gen-object-api"],
|
||||
schema="union_name_test.fbs",
|
||||
)
|
||||
|
||||
flatc(
|
||||
NO_INCL_OPTS + CPP_OPTS,
|
||||
schema="default_vectors_strings_test.fbs",
|
||||
@@ -532,6 +527,13 @@ flatc(
|
||||
cwd=swift_code_gen,
|
||||
)
|
||||
|
||||
flatc(
|
||||
SWIFT_OPTS_CODE_GEN + BASE_OPTS,
|
||||
schema="empty_vtable.fbs",
|
||||
cwd=swift_code_gen,
|
||||
prefix="../../Tests/Flatbuffers/",
|
||||
)
|
||||
|
||||
# Swift Wasm Tests
|
||||
swift_Wasm_prefix = "swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests"
|
||||
flatc(
|
||||
|
||||
@@ -126,9 +126,7 @@ static BinarySection GenerateMissingSection(const uint64_t offset,
|
||||
std::map<uint64_t, BinarySection> BinaryAnnotator::Annotate() {
|
||||
if (bfbs_ != nullptr && bfbs_length_ != 0) {
|
||||
flatbuffers::Verifier verifier(bfbs_, static_cast<size_t>(bfbs_length_));
|
||||
if ((is_size_prefixed_ &&
|
||||
!reflection::VerifySizePrefixedSchemaBuffer(verifier)) ||
|
||||
!reflection::VerifySchemaBuffer(verifier)) {
|
||||
if (!reflection::VerifySchemaBuffer(verifier)) {
|
||||
return {};
|
||||
}
|
||||
}
|
||||
|
||||
@@ -145,12 +145,6 @@ const static FlatCOption flatc_options[] = {
|
||||
{"", "cpp-str-flex-ctor", "",
|
||||
"Don't construct custom string types by passing std::string from "
|
||||
"Flatbuffers, but (char* + length)."},
|
||||
{"", "cpp-vector-type", "T",
|
||||
"Set object API vector type (default std::vector). T must be a "
|
||||
"template taking a single element type argument and support "
|
||||
"resize(), reserve(), size(), data(), operator[], emplace_back(), and "
|
||||
"begin()/end(). The custom type also needs its own header to be "
|
||||
"included via --cpp-include."},
|
||||
{"", "cpp-field-case-style", "STYLE",
|
||||
"Generate C++ fields using selected case style. Supported STYLE values: * "
|
||||
"'unchanged' - leave unchanged (default) * 'upper' - schema snake_case "
|
||||
@@ -551,9 +545,6 @@ FlatCOptions FlatCompiler::ParseFromCommandLineArguments(int argc,
|
||||
opts.cpp_object_api_string_type = argv[argi];
|
||||
} else if (arg == "--cpp-str-flex-ctor") {
|
||||
opts.cpp_object_api_string_flexible_constructor = true;
|
||||
} else if (arg == "--cpp-vector-type") {
|
||||
if (++argi >= argc) Error("missing type following: " + arg, true);
|
||||
opts.cpp_object_api_vector_type = argv[argi];
|
||||
} else if (arg == "--no-cpp-direct-copy") {
|
||||
opts.cpp_direct_copy = false;
|
||||
} else if (arg == "--cpp-field-case-style") {
|
||||
|
||||
+46
-297
@@ -257,19 +257,6 @@ class CppGenerator : public BaseGenerator {
|
||||
code_ += " FLATBUFFERS_VERSION_REVISION == " +
|
||||
std::to_string(FLATBUFFERS_VERSION_REVISION) + ",";
|
||||
code_ += " \"Non-compatible flatbuffers version included\");";
|
||||
|
||||
code_ += "// Ensure the included flatbuffers.h is Bigfoot's fork - stock";
|
||||
code_ += "// flatbuffers (or a differently versioned Bigfoot fork) is not compatible.";
|
||||
code_ += "#ifndef FLATBUFFERS_BIGFOOT_VERSION";
|
||||
code_ +=
|
||||
"#error \"This file requires Bigfoot's flatbuffers fork - stock "
|
||||
"flatbuffers is not compatible\"";
|
||||
code_ += "#endif";
|
||||
code_ += "static_assert(FLATBUFFERS_BIGFOOT_VERSION == " +
|
||||
std::to_string(FLATBUFFERS_BIGFOOT_VERSION) + ",";
|
||||
code_ +=
|
||||
" \"Non-compatible Bigfoot flatbuffers fork version "
|
||||
"included\");";
|
||||
}
|
||||
|
||||
void GenIncludeDependencies() {
|
||||
@@ -542,8 +529,6 @@ class CppGenerator : public BaseGenerator {
|
||||
code_ += "";
|
||||
}
|
||||
|
||||
GenerateBigfootRefForwardDecls();
|
||||
|
||||
// Generate preablmle code for mini reflection.
|
||||
if (opts_.mini_reflect != IDLOptions::kNone) {
|
||||
// To break cyclic dependencies, first pre-declare all tables/structs.
|
||||
@@ -773,8 +758,6 @@ class CppGenerator : public BaseGenerator {
|
||||
|
||||
if (cur_name_space_) SetNameSpace(nullptr);
|
||||
|
||||
GenerateBigfootRefImpls();
|
||||
|
||||
// Close the include guard.
|
||||
code_ += "#endif // " + include_guard;
|
||||
|
||||
@@ -909,24 +892,6 @@ class CppGenerator : public BaseGenerator {
|
||||
return opts_.gen_nullable ? " _Nullable " : "";
|
||||
}
|
||||
|
||||
// A field's `native_type`/`native_type_pack_name` normally come from the
|
||||
// referenced struct's own declaration. A field can override both (see
|
||||
// `bigfoot_ref` in idl_parser.cpp, which synthesizes these two attributes
|
||||
// directly on the field) to instantiate a templated native type
|
||||
// differently per field.
|
||||
static const Value* EffectiveNativeType(const FieldDef& field,
|
||||
const StructDef& struct_def) {
|
||||
if (const auto v = field.attributes.Lookup("native_type")) return v;
|
||||
return struct_def.attributes.Lookup("native_type");
|
||||
}
|
||||
|
||||
static const Value* EffectiveNativeTypePackName(const FieldDef& field,
|
||||
const StructDef& struct_def) {
|
||||
if (const auto v = field.attributes.Lookup("native_type_pack_name"))
|
||||
return v;
|
||||
return struct_def.attributes.Lookup("native_type_pack_name");
|
||||
}
|
||||
|
||||
static std::string NativeName(const std::string& name, const StructDef* sd,
|
||||
const IDLOptions& opts) {
|
||||
// If the table is a native_type, return the native_type name.
|
||||
@@ -972,23 +937,6 @@ class CppGenerator : public BaseGenerator {
|
||||
"std::string"; // Only for custom string types.
|
||||
}
|
||||
|
||||
const std::string NativeVectorType(const FieldDef* field) {
|
||||
auto attr = field ? field->attributes.Lookup("cpp_vector_type") : nullptr;
|
||||
auto& ret = attr ? attr->constant : opts_.cpp_object_api_vector_type;
|
||||
if (ret.empty()) {
|
||||
return "std::vector";
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
// True if this field's native vector uses a custom (non-std::vector)
|
||||
// container, meaning generated Pack() code can't rely on the std::vector
|
||||
// specific CreateVector*() overloads and must fall back to data()/size()
|
||||
// or per-element construction instead.
|
||||
bool UsesCustomVectorType(const FieldDef* field) {
|
||||
return NativeVectorType(field) != "std::vector";
|
||||
}
|
||||
|
||||
std::string GenTypeNativePtr(const std::string& type, const FieldDef* field,
|
||||
bool is_constructor) {
|
||||
auto& ptr_type = PtrType(field);
|
||||
@@ -1026,21 +974,20 @@ class CppGenerator : public BaseGenerator {
|
||||
case BASE_TYPE_VECTOR64:
|
||||
case BASE_TYPE_VECTOR: {
|
||||
const auto type_name = GenTypeNative(type.VectorType(), true, field);
|
||||
const auto vector_type = NativeVectorType(&field);
|
||||
if (vector_type == "std::vector" && type.struct_def &&
|
||||
if (type.struct_def &&
|
||||
type.struct_def->attributes.Lookup("native_custom_alloc")) {
|
||||
auto native_custom_alloc =
|
||||
type.struct_def->attributes.Lookup("native_custom_alloc");
|
||||
return "std::vector<" + type_name + "," +
|
||||
native_custom_alloc->constant + "<" + type_name + ">>";
|
||||
} else {
|
||||
return vector_type + "<" + type_name + ">";
|
||||
return "std::vector<" + type_name + ">";
|
||||
}
|
||||
}
|
||||
case BASE_TYPE_STRUCT: {
|
||||
auto type_name = WrapInNameSpace(*type.struct_def);
|
||||
if (IsStruct(type)) {
|
||||
auto native_type = EffectiveNativeType(field, *type.struct_def);
|
||||
auto native_type = type.struct_def->attributes.Lookup("native_type");
|
||||
if (native_type) {
|
||||
type_name = native_type->constant;
|
||||
}
|
||||
@@ -2032,7 +1979,7 @@ class CppGenerator : public BaseGenerator {
|
||||
const std::string& full_type =
|
||||
(cpp_type
|
||||
? (IsVector(field.value.type)
|
||||
? NativeVectorType(&field) + "<" +
|
||||
? "std::vector<" +
|
||||
GenTypeNativePtr(cpp_type->constant, &field,
|
||||
false) +
|
||||
"> "
|
||||
@@ -2049,19 +1996,8 @@ class CppGenerator : public BaseGenerator {
|
||||
" = " + (native_default ? std::string(native_default->constant)
|
||||
: GetDefaultScalarValue(field, true));
|
||||
} else if (field.value.type.base_type == BASE_TYPE_STRUCT) {
|
||||
if (IsStruct(field.value.type)) {
|
||||
if (native_default) {
|
||||
field_di = " = " + native_default->constant;
|
||||
}
|
||||
} else if (!cpp_type && !field.native_inline && field.IsRequired() &&
|
||||
PtrType(&field) != "naked") {
|
||||
// A required table field can never legally be absent once
|
||||
// Verify()/Pack() succeed, so default-construct it here instead
|
||||
// of leaving every hand-written native constructor to remember
|
||||
// to allocate it before the first Pack().
|
||||
const auto nn = WrapNativeNameInNameSpace(
|
||||
*field.value.type.struct_def, opts_);
|
||||
field_di = "{new " + nn + "()}";
|
||||
if (IsStruct(field.value.type) && native_default) {
|
||||
field_di = " = " + native_default->constant;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -2843,15 +2779,17 @@ class CppGenerator : public BaseGenerator {
|
||||
get_call += ">(" + offset_str + ");";
|
||||
code_ += get_call;
|
||||
} else if (IsString(type) && field.value.constant != "0") {
|
||||
// TODO: Add logic to always convert the string to a valid C++ string
|
||||
// literal by handling string escapes.
|
||||
std::string escaped;
|
||||
flatbuffers::EscapeString(field.value.constant.c_str(),
|
||||
field.value.constant.length(), &escaped,
|
||||
true, false);
|
||||
code_ += " auto* ptr = {{FIELD_VALUE}};";
|
||||
code_ += " if (ptr) return ptr;";
|
||||
code_ += " static const struct { uint32_t len; const char s[" +
|
||||
NumToString(field.value.constant.length() + 1) +
|
||||
"]; } bfbs_string = { " +
|
||||
NumToString(field.value.constant.length()) + ", \"" +
|
||||
field.value.constant + "\" };";
|
||||
NumToString(field.value.constant.length()) + ", " +
|
||||
escaped + " };";
|
||||
code_ +=
|
||||
" return reinterpret_cast<const ::flatbuffers::String "
|
||||
" *>(&bfbs_string);";
|
||||
@@ -3481,11 +3419,15 @@ class CppGenerator : public BaseGenerator {
|
||||
code_.SetValue("CREATE_STRING", "CreateSharedString");
|
||||
}
|
||||
if (field->value.constant != "0") {
|
||||
std::string escaped;
|
||||
flatbuffers::EscapeString(field->value.constant.c_str(),
|
||||
field->value.constant.length(), &escaped,
|
||||
true, false);
|
||||
code_ +=
|
||||
" auto {{FIELD_NAME}}__ = {{FIELD_NAME}} ? "
|
||||
"_fbb.{{CREATE_STRING}}({{FIELD_NAME}}) : "
|
||||
"_fbb.{{CREATE_STRING}}(\"" +
|
||||
field->value.constant + "\");";
|
||||
"_fbb.{{CREATE_STRING}}(" +
|
||||
escaped + ");";
|
||||
} else {
|
||||
code_ +=
|
||||
" auto {{FIELD_NAME}}__ = {{FIELD_NAME}} ? "
|
||||
@@ -3579,11 +3521,11 @@ class CppGenerator : public BaseGenerator {
|
||||
}
|
||||
case BASE_TYPE_STRUCT: {
|
||||
if (IsStruct(type)) {
|
||||
const auto native_type = EffectiveNativeType(afield, *type.struct_def);
|
||||
const auto& struct_attrs = type.struct_def->attributes;
|
||||
const auto native_type = struct_attrs.Lookup("native_type");
|
||||
if (native_type) {
|
||||
std::string unpack_call = "::flatbuffers::UnPack";
|
||||
const auto pack_name =
|
||||
EffectiveNativeTypePackName(afield, *type.struct_def);
|
||||
const auto pack_name = struct_attrs.Lookup("native_type_pack_name");
|
||||
if (pack_name) {
|
||||
unpack_call += pack_name->constant;
|
||||
}
|
||||
@@ -3836,22 +3778,13 @@ class CppGenerator : public BaseGenerator {
|
||||
case BASE_TYPE_VECTOR64:
|
||||
case BASE_TYPE_VECTOR: {
|
||||
auto vector_type = field.value.type.VectorType();
|
||||
// If the field's native container isn't std::vector, the
|
||||
// std::vector-specific CreateVector*() overloads in
|
||||
// flatbuffer_builder.h can't be used directly. Fall back to
|
||||
// data()/size()-based overloads (which only require the container to
|
||||
// support those, like std::vector does) or, where no such overload
|
||||
// exists, to the same per-element lambda serialization already used
|
||||
// above for custom string/table/union element types.
|
||||
const bool custom_vector = UsesCustomVectorType(&field);
|
||||
switch (vector_type.base_type) {
|
||||
case BASE_TYPE_STRING: {
|
||||
if (!custom_vector && NativeString(&field) == "std::string") {
|
||||
if (NativeString(&field) == "std::string") {
|
||||
code += "_fbb.CreateVectorOfStrings(" + value + ")";
|
||||
} else {
|
||||
// Use by-function serialization to emulate
|
||||
// CreateVectorOfStrings(); this works also with non-std strings
|
||||
// and non-std::vector vector types.
|
||||
// CreateVectorOfStrings(); this works also with non-std strings.
|
||||
code +=
|
||||
"_fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::"
|
||||
"String>>"
|
||||
@@ -3866,37 +3799,20 @@ class CppGenerator : public BaseGenerator {
|
||||
}
|
||||
case BASE_TYPE_STRUCT: {
|
||||
if (IsStruct(vector_type)) {
|
||||
const auto native_type =
|
||||
EffectiveNativeType(field, *field.value.type.struct_def);
|
||||
const auto& struct_attrs =
|
||||
field.value.type.struct_def->attributes;
|
||||
const auto native_type = struct_attrs.Lookup("native_type");
|
||||
if (native_type) {
|
||||
code += "_fbb.CreateVectorOfNativeStructs<";
|
||||
code += WrapInNameSpace(*vector_type.struct_def) + ", " +
|
||||
native_type->constant + ">";
|
||||
if (custom_vector) {
|
||||
code += "(" + value + ".data(), " + value + ".size()";
|
||||
} else {
|
||||
code += "(" + value;
|
||||
}
|
||||
const auto pack_name = EffectiveNativeTypePackName(
|
||||
field, *field.value.type.struct_def);
|
||||
code += "(" + value;
|
||||
const auto pack_name =
|
||||
struct_attrs.Lookup("native_type_pack_name");
|
||||
if (pack_name) {
|
||||
code += ", ::flatbuffers::Pack" + pack_name->constant;
|
||||
}
|
||||
code += ")";
|
||||
} else if (custom_vector &&
|
||||
(field.value.type.base_type == BASE_TYPE_VECTOR64 ||
|
||||
field.offset64)) {
|
||||
// CreateVectorOfStructs64() (and CreateVectorOfStructs64<V>()
|
||||
// for offset64) only accept a std::vector; use the
|
||||
// equivalent explicit-template raw pointer overload instead.
|
||||
const auto struct_type = WrapInNameSpace(*vector_type.struct_def);
|
||||
const auto vector_t = field.value.type.base_type ==
|
||||
BASE_TYPE_VECTOR64
|
||||
? "::flatbuffers::Vector64"
|
||||
: "::flatbuffers::Vector";
|
||||
code += "_fbb.CreateVectorOfStructs<" + struct_type +
|
||||
", ::flatbuffers::Offset64, " + vector_t + ">(" +
|
||||
value + ".data(), " + value + ".size())";
|
||||
} else {
|
||||
// If the field uses 64-bit addressing, create a 64-bit vector.
|
||||
if (field.value.type.base_type == BASE_TYPE_VECTOR64) {
|
||||
@@ -3908,18 +3824,16 @@ class CppGenerator : public BaseGenerator {
|
||||
code += "64<::flatbuffers::Vector>";
|
||||
}
|
||||
}
|
||||
if (custom_vector) {
|
||||
code += "(" + value + ".data(), " + value + ".size())";
|
||||
} else {
|
||||
code += "(" + value + ")";
|
||||
}
|
||||
code += "(" + value + ")";
|
||||
}
|
||||
} else {
|
||||
code += "_fbb.CreateVector<::flatbuffers::Offset<";
|
||||
code += WrapInNameSpace(*vector_type.struct_def) + ">> ";
|
||||
code += "(" + value + ".size(), ";
|
||||
code += "[](size_t i, _VectorArgs *__va) { ";
|
||||
code += "return Create" + vector_type.struct_def->name;
|
||||
code += "return " +
|
||||
WrapInNameSpace(vector_type.struct_def->defined_namespace,
|
||||
"Create" + vector_type.struct_def->name);
|
||||
code += "(*__va->__fbb, ";
|
||||
if (field.native_inline) {
|
||||
code += "&(__va->_" + value + "[i])";
|
||||
@@ -3931,17 +3845,7 @@ class CppGenerator : public BaseGenerator {
|
||||
break;
|
||||
}
|
||||
case BASE_TYPE_BOOL: {
|
||||
if (custom_vector) {
|
||||
// Vectors of bool are always stored on the wire as uint8_t
|
||||
// (there is no Vector<bool>); CreateVectorScalarCast() does
|
||||
// the per-element bool->uint8_t cast from a raw data()/size()
|
||||
// pointer pair, avoiding any dependency on std::vector<bool>'s
|
||||
// bit-packed specialization.
|
||||
code += "_fbb.CreateVectorScalarCast<uint8_t>(" + value +
|
||||
".data(), " + value + ".size())";
|
||||
} else {
|
||||
code += "_fbb.CreateVector(" + value + ")";
|
||||
}
|
||||
code += "_fbb.CreateVector(" + value + ")";
|
||||
break;
|
||||
}
|
||||
case BASE_TYPE_UNION: {
|
||||
@@ -3977,11 +3881,9 @@ class CppGenerator : public BaseGenerator {
|
||||
// the underlying storage type (eg. uint8_t).
|
||||
const auto basetype = GenTypeBasic(
|
||||
field.value.type.enum_def->underlying_type, false);
|
||||
const std::string data_ptr =
|
||||
custom_vector ? value + ".data()"
|
||||
: "::flatbuffers::data(" + value + ")";
|
||||
code += "_fbb.CreateVectorScalarCast<" + basetype + ">(" +
|
||||
data_ptr + ", " + value + ".size())";
|
||||
code += "_fbb.CreateVectorScalarCast<" + basetype +
|
||||
">(::flatbuffers::data(" + value + "), " + value +
|
||||
".size())";
|
||||
} else if (field.attributes.Lookup("cpp_type")) {
|
||||
auto type = GenTypeBasic(vector_type, false);
|
||||
code += "_fbb.CreateVector<" + type + ">(" + value + ".size(), ";
|
||||
@@ -3990,27 +3892,6 @@ class CppGenerator : public BaseGenerator {
|
||||
code += "static_cast<" + type + ">((*__va->__rehasher)";
|
||||
code += "(__va->_" + value + "[i]" + GenPtrGet(field) + ")) : 0";
|
||||
code += "; }, &_va )";
|
||||
} else if (custom_vector) {
|
||||
// Explicitly specify the element type so it can be deduced
|
||||
// from a raw data()/size() pointer pair instead of relying on
|
||||
// the std::vector<T, Alloc>-specific CreateVector overloads.
|
||||
// Use the user-facing type (matches what GenTypeNative()
|
||||
// stores in the native vector, e.g. the enum type itself for
|
||||
// scoped-enum fields) so it matches data()'s pointee type.
|
||||
auto type = GenTypeBasic(vector_type, true);
|
||||
if (field.value.type.base_type == BASE_TYPE_VECTOR64) {
|
||||
code += "_fbb.CreateVector<" + type +
|
||||
", ::flatbuffers::Offset64, ::flatbuffers::Vector64>(" +
|
||||
value + ".data(), " + value + ".size())";
|
||||
} else if (field.offset64) {
|
||||
// This is normal 32-bit vector, with 64-bit addressing.
|
||||
code += "_fbb.CreateVector<" + type +
|
||||
", ::flatbuffers::Offset64, ::flatbuffers::Vector>(" +
|
||||
value + ".data(), " + value + ".size())";
|
||||
} else {
|
||||
code += "_fbb.CreateVector(" + value + ".data(), " + value +
|
||||
".size())";
|
||||
}
|
||||
} else {
|
||||
// If the field uses 64-bit addressing, create a 64-bit vector.
|
||||
if (field.value.type.base_type == BASE_TYPE_VECTOR64) {
|
||||
@@ -4044,12 +3925,12 @@ class CppGenerator : public BaseGenerator {
|
||||
}
|
||||
case BASE_TYPE_STRUCT: {
|
||||
if (IsStruct(field.value.type)) {
|
||||
const auto native_type =
|
||||
EffectiveNativeType(field, *field.value.type.struct_def);
|
||||
const auto& struct_attribs = field.value.type.struct_def->attributes;
|
||||
const auto native_type = struct_attribs.Lookup("native_type");
|
||||
if (native_type && field.native_inline) {
|
||||
code += "::flatbuffers::Pack";
|
||||
const auto pack_name =
|
||||
EffectiveNativeTypePackName(field, *field.value.type.struct_def);
|
||||
struct_attribs.Lookup("native_type_pack_name");
|
||||
if (pack_name) {
|
||||
code += pack_name->constant;
|
||||
}
|
||||
@@ -4065,8 +3946,10 @@ class CppGenerator : public BaseGenerator {
|
||||
}
|
||||
} else {
|
||||
// _o->field ? CreateT(_fbb, _o->field.get(), _rehasher);
|
||||
const std::string& type = field.value.type.struct_def->name;
|
||||
code += value + " ? Create" + type;
|
||||
const auto& nested_struct = *field.value.type.struct_def;
|
||||
code += value + " ? " +
|
||||
WrapInNameSpace(nested_struct.defined_namespace,
|
||||
"Create" + nested_struct.name);
|
||||
code += "(_fbb, " + value;
|
||||
if (!field.native_inline) code += GenPtrGet(field);
|
||||
code += ", _rehasher) : 0";
|
||||
@@ -4214,7 +4097,8 @@ class CppGenerator : public BaseGenerator {
|
||||
if (field->value.type.base_type == BASE_TYPE_STRUCT) {
|
||||
if (IsStruct(field->value.type)) {
|
||||
auto native_type =
|
||||
EffectiveNativeType(*field, *field->value.type.struct_def);
|
||||
field->value.type.struct_def->attributes.Lookup(
|
||||
"native_type");
|
||||
auto native_inline = field->attributes.Lookup("native_inline");
|
||||
if (native_type) {
|
||||
pass_by_address = true;
|
||||
@@ -4569,141 +4453,6 @@ class CppGenerator : public BaseGenerator {
|
||||
}
|
||||
}
|
||||
|
||||
// Split a "::"-qualified C++ name into namespace components + final name.
|
||||
static std::vector<std::string> SplitQualifiedName(const std::string& qualified) {
|
||||
std::vector<std::string> parts;
|
||||
size_t start = qualified.compare(0, 2, "::") == 0 ? 2 : 0;
|
||||
for (;;) {
|
||||
const auto pos = qualified.find("::", start);
|
||||
if (pos == std::string::npos) {
|
||||
parts.push_back(qualified.substr(start));
|
||||
break;
|
||||
}
|
||||
parts.push_back(qualified.substr(start, pos - start));
|
||||
start = pos + 2;
|
||||
}
|
||||
return parts;
|
||||
}
|
||||
|
||||
// Bigfoot: for every field annotated `bigfoot_ref: "::Ns::AssetX"` (see
|
||||
// idl_parser.cpp), forward-declare AssetX plus prototype the Pack/UnPack
|
||||
// functions for its reference wrapper. Called early (alongside the
|
||||
// regular struct/table forward declarations), since these prototypes -
|
||||
// unlike their definitions in GenerateBigfootRefImpls() - only need
|
||||
// AssetX and the wrapper struct forward-declared, not complete.
|
||||
void GenerateBigfootRefForwardDecls() {
|
||||
std::unordered_set<std::string> declared_assets;
|
||||
for (const auto& struct_def : parser_.structs_.vec) {
|
||||
if (struct_def->generated) continue;
|
||||
for (const auto& field : struct_def->fields.vec) {
|
||||
const auto* bigfoot_ref = field->attributes.Lookup("bigfoot_ref");
|
||||
if (!bigfoot_ref) continue;
|
||||
if (!declared_assets.insert(bigfoot_ref->constant).second) continue;
|
||||
|
||||
auto parts = SplitQualifiedName(bigfoot_ref->constant);
|
||||
const std::string class_name = parts.back();
|
||||
parts.pop_back();
|
||||
|
||||
SetNameSpace(nullptr);
|
||||
for (const auto& ns_part : parts) code_ += "namespace " + ns_part + " {";
|
||||
code_ += "class " + class_name + ";";
|
||||
for (auto it = parts.rbegin(); it != parts.rend(); ++it)
|
||||
code_ += "} // namespace " + *it;
|
||||
code_ += "";
|
||||
}
|
||||
}
|
||||
|
||||
std::unordered_set<std::string> declared_pairs;
|
||||
bool opened_flatbuffers_ns = false;
|
||||
for (const auto& struct_def : parser_.structs_.vec) {
|
||||
if (struct_def->generated) continue;
|
||||
for (const auto& field : struct_def->fields.vec) {
|
||||
const auto* bigfoot_ref = field->attributes.Lookup("bigfoot_ref");
|
||||
if (!bigfoot_ref) continue;
|
||||
|
||||
const auto* pack_name = field->attributes.Lookup("native_type_pack_name");
|
||||
if (!declared_pairs.insert(pack_name->constant).second) continue;
|
||||
|
||||
if (!opened_flatbuffers_ns) {
|
||||
SetNameSpace(nullptr);
|
||||
code_ += "namespace flatbuffers {";
|
||||
opened_flatbuffers_ns = true;
|
||||
}
|
||||
|
||||
const auto* native_type = field->attributes.Lookup("native_type");
|
||||
const std::string flat_wrapper =
|
||||
WrapInNameSpace(*field->value.type.struct_def);
|
||||
|
||||
code_ += flat_wrapper + " Pack" + pack_name->constant +
|
||||
"(const " + native_type->constant + "& p_asset);";
|
||||
code_ += native_type->constant + " UnPack" + pack_name->constant +
|
||||
"(const " + flat_wrapper + "& p_asset);";
|
||||
}
|
||||
}
|
||||
|
||||
if (opened_flatbuffers_ns) {
|
||||
code_ += "} // namespace flatbuffers";
|
||||
code_ += "";
|
||||
}
|
||||
}
|
||||
|
||||
// Bigfoot: defines the Pack/UnPack functions prototyped by
|
||||
// GenerateBigfootRefForwardDecls(). Called late (after every struct/table
|
||||
// in this file has been fully defined), since a wrapper struct (e.g.
|
||||
// HardReference/SoftReference) may be defined in this same generated file
|
||||
// rather than one it includes, and these definitions construct it by
|
||||
// value - they need it complete, unlike the earlier prototypes.
|
||||
void GenerateBigfootRefImpls() {
|
||||
std::unordered_set<std::string> declared_pairs;
|
||||
bool opened_flatbuffers_ns = false;
|
||||
for (const auto& struct_def : parser_.structs_.vec) {
|
||||
if (struct_def->generated) continue;
|
||||
for (const auto& field : struct_def->fields.vec) {
|
||||
const auto* bigfoot_ref = field->attributes.Lookup("bigfoot_ref");
|
||||
if (!bigfoot_ref) continue;
|
||||
|
||||
const auto* pack_name = field->attributes.Lookup("native_type_pack_name");
|
||||
if (!declared_pairs.insert(pack_name->constant).second) continue;
|
||||
|
||||
if (!opened_flatbuffers_ns) {
|
||||
SetNameSpace(nullptr);
|
||||
code_ += "namespace flatbuffers {";
|
||||
opened_flatbuffers_ns = true;
|
||||
}
|
||||
|
||||
const auto* native_type = field->attributes.Lookup("native_type");
|
||||
const std::string flat_wrapper =
|
||||
WrapInNameSpace(*field->value.type.struct_def);
|
||||
|
||||
// A single translation unit can end up including two different
|
||||
// generated headers that both reference the same asset type (e.g.
|
||||
// AssetB references AssetA, and some other TU includes both
|
||||
// AssetA_generated.hpp and AssetB_generated.hpp directly) - each
|
||||
// would otherwise emit an identical, independent definition of these
|
||||
// functions. `inline` only allows identical definitions to repeat
|
||||
// across *different* translation units, not twice within the same
|
||||
// one, so guard against that with a plain macro guard.
|
||||
std::string guard_name = pack_name->constant;
|
||||
std::transform(guard_name.begin(), guard_name.end(), guard_name.begin(), CharToUpper);
|
||||
const std::string guard = "FLATBUFFERS_BIGFOOT_REF_" + guard_name;
|
||||
code_ += "#ifndef " + guard;
|
||||
code_ += "#define " + guard;
|
||||
code_ += "inline " + flat_wrapper + " Pack" + pack_name->constant +
|
||||
"(const " + native_type->constant +
|
||||
"& p_asset) { return {Pack(p_asset.GetUUID())}; }";
|
||||
code_ += "inline " + native_type->constant + " UnPack" +
|
||||
pack_name->constant + "(const " + flat_wrapper +
|
||||
"& p_asset) { return {UnPack(p_asset.uuid())}; }";
|
||||
code_ += "#endif // " + guard;
|
||||
}
|
||||
}
|
||||
|
||||
if (opened_flatbuffers_ns) {
|
||||
code_ += "} // namespace flatbuffers";
|
||||
code_ += "";
|
||||
}
|
||||
}
|
||||
|
||||
// Set up the correct namespace. Only open a namespace if the existing one is
|
||||
// different (closing/opening only what is necessary).
|
||||
//
|
||||
|
||||
+11
-1
@@ -368,7 +368,17 @@ static std::string GenerateFBS(const Parser& parser,
|
||||
if (field.value.type.base_type != BASE_TYPE_UTYPE) {
|
||||
GenComment(field.doc_comment, &schema, nullptr, " ");
|
||||
schema += " " + field.name + ":" + GenType(field.value.type);
|
||||
if (field.value.constant != "0") schema += " = " + field.value.constant;
|
||||
if (field.value.constant != "0") {
|
||||
if (IsString(field.value.type)) {
|
||||
std::string escaped;
|
||||
flatbuffers::EscapeString(field.value.constant.c_str(),
|
||||
field.value.constant.length(), &escaped,
|
||||
true, false);
|
||||
schema += " = " + escaped;
|
||||
} else {
|
||||
schema += " = " + field.value.constant;
|
||||
}
|
||||
}
|
||||
std::vector<std::string> attributes;
|
||||
if (field.IsRequired()) attributes.push_back("required");
|
||||
if (field.key) attributes.push_back("key");
|
||||
|
||||
@@ -1528,7 +1528,7 @@ class PythonGenerator : public BaseGenerator {
|
||||
} else {
|
||||
code += "def Create" + field_method + "Vector(builder, data):\n";
|
||||
}
|
||||
code += Indent + helper_name + "(builder, data)\n\n";
|
||||
code += Indent + "return " + helper_name + "(builder, data)\n\n";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2095,12 +2095,12 @@ class PythonGenerator : public BaseGenerator {
|
||||
const auto field_method = namer_.Method(field);
|
||||
const auto struct_var = namer_.Variable(struct_def);
|
||||
const EnumDef& enum_def = *field.value.type.enum_def;
|
||||
auto union_type = namer_.Type(enum_def);
|
||||
auto union_fn = namer_.Function(enum_def);
|
||||
|
||||
if (parser_.opts.include_dependence_headers) {
|
||||
union_type = namer_.NamespacedType(enum_def) + "." + union_type;
|
||||
union_fn = namer_.NamespacedType(enum_def) + "." + union_fn;
|
||||
}
|
||||
code += GenIndents(2) + "self." + field_field + " = " + union_type +
|
||||
code += GenIndents(2) + "self." + field_field + " = " + union_fn +
|
||||
"Creator(" + "self." + field_field + "Type, " + struct_var + "." +
|
||||
field_method + "())";
|
||||
}
|
||||
|
||||
+552
-414
File diff suppressed because it is too large
Load Diff
+78
-44
@@ -164,7 +164,7 @@ class SwiftGenerator : public BaseGenerator {
|
||||
bool generate() {
|
||||
code_.Clear();
|
||||
code_.SetValue("ACCESS", "_accessor");
|
||||
code_.SetValue("TABLEOFFSET", "VTOFFSET");
|
||||
code_.SetValue("TABLEOFFSET", "VT");
|
||||
code_ += "// " + std::string(FlatBuffersGeneratedWarning());
|
||||
code_ += "// swiftlint:disable all";
|
||||
code_ += "// swiftformat:disable all\n";
|
||||
@@ -282,9 +282,16 @@ class SwiftGenerator : public BaseGenerator {
|
||||
NumToString(field.value.type.VectorType().fixed_length);
|
||||
code_.SetValue("FIXEDLENGTH", fixed_length);
|
||||
|
||||
const auto vector_base_type = IsStruct(field.value.type.VectorType())
|
||||
? (type + "()")
|
||||
: SwiftConstant(field);
|
||||
std::string vector_base_type;
|
||||
if (IsStruct(field.value.type.VectorType())) {
|
||||
vector_base_type = type + "()";
|
||||
} else if (IsBool(field.value.type.VectorType().base_type)) {
|
||||
vector_base_type = "false";
|
||||
} else if (IsFloat(field.value.type.VectorType().base_type)) {
|
||||
vector_base_type = "0.0";
|
||||
} else {
|
||||
vector_base_type = SwiftConstant(field);
|
||||
}
|
||||
code_ += "private var _{{FIELDVAR}}: InlineArray<{{FIXEDLENGTH}}, " +
|
||||
valueType + ">";
|
||||
|
||||
@@ -518,7 +525,7 @@ class SwiftGenerator : public BaseGenerator {
|
||||
void GenTableAccessors(const StructDef& struct_def) {
|
||||
// Generate field id constants.
|
||||
if (struct_def.fields.vec.size() > 0) {
|
||||
code_ += "private enum {{TABLEOFFSET}}: VOffset {";
|
||||
code_ += "private struct {{TABLEOFFSET}} {";
|
||||
Indent();
|
||||
for (auto it = struct_def.fields.vec.begin();
|
||||
it != struct_def.fields.vec.end(); ++it) {
|
||||
@@ -528,10 +535,8 @@ class SwiftGenerator : public BaseGenerator {
|
||||
}
|
||||
code_.SetValue("OFFSET_NAME", namer_.Variable(field));
|
||||
code_.SetValue("OFFSET_VALUE", NumToString(field.value.offset));
|
||||
code_ += "case {{OFFSET_NAME}} = {{OFFSET_VALUE}}";
|
||||
code_ += "static let {{OFFSET_NAME}}: VOffset = {{OFFSET_VALUE}}";
|
||||
}
|
||||
code_ += "var v: Int32 { Int32(self.rawValue) }";
|
||||
code_ += "var p: VOffset { self.rawValue }";
|
||||
Outdent();
|
||||
code_ += "}";
|
||||
code_ += "";
|
||||
@@ -620,7 +625,8 @@ class SwiftGenerator : public BaseGenerator {
|
||||
if (should_generate_create) {
|
||||
code_ += "{{ACCESS_TYPE}} static func create{{SHORT_STRUCTNAME}}(";
|
||||
Indent();
|
||||
code_ += "_ fbb: inout FlatBufferBuilder,";
|
||||
code_ += "_ fbb: inout FlatBufferBuilder\\";
|
||||
if (create_func_header.empty() == false) code_ += ",";
|
||||
for (auto it = create_func_header.begin(); it < create_func_header.end();
|
||||
++it) {
|
||||
code_ += *it + "\\";
|
||||
@@ -699,7 +705,7 @@ class SwiftGenerator : public BaseGenerator {
|
||||
code_ += field.IsOptional() ? (optional_enum + "\\")
|
||||
: (is_enum + ", def: {{CONSTANT}}\\");
|
||||
|
||||
code_ += ", at: {{TABLEOFFSET}}.{{OFFSET}}.p) }";
|
||||
code_ += ", at: {{TABLEOFFSET}}.{{OFFSET}}) }";
|
||||
|
||||
const auto default_value =
|
||||
IsEnum(field.value.type)
|
||||
@@ -719,7 +725,7 @@ class SwiftGenerator : public BaseGenerator {
|
||||
code_ +=
|
||||
"{{VALUETYPE}}" + builder_string + "fbb.add(element: {{FIELDVAR}},\\";
|
||||
code_ += field.IsOptional() ? "\\" : " def: {{CONSTANT}},";
|
||||
code_ += " at: {{TABLEOFFSET}}.{{OFFSET}}.p) }";
|
||||
code_ += " at: {{TABLEOFFSET}}.{{OFFSET}}) }";
|
||||
create_func_header.push_back(
|
||||
field_var + ": " + nullable_type + " = " +
|
||||
(field.IsOptional() ? "nil" : default_value));
|
||||
@@ -730,7 +736,7 @@ class SwiftGenerator : public BaseGenerator {
|
||||
const auto create_struct =
|
||||
"guard let {{FIELDVAR}} = {{FIELDVAR}} else { return };"
|
||||
" fbb.create(struct: {{FIELDVAR}}, position: "
|
||||
"{{TABLEOFFSET}}.{{OFFSET}}.p) }";
|
||||
"{{TABLEOFFSET}}.{{OFFSET}}) }";
|
||||
code_ += type + "?" + builder_string + create_struct;
|
||||
/// Optional hard coded since structs are always optional
|
||||
create_func_header.push_back(field_var + ": " + type +
|
||||
@@ -747,8 +753,9 @@ class SwiftGenerator : public BaseGenerator {
|
||||
(field.IsRequired() ? "" : " = Offset()"));
|
||||
const auto reader_type =
|
||||
IsStruct(field.value.type) && field.value.type.struct_def->fixed
|
||||
? "structOffset: {{TABLEOFFSET}}.{{OFFSET}}.p) }"
|
||||
: "offset: {{FIELDVAR}}, at: {{TABLEOFFSET}}.{{OFFSET}}.p) }";
|
||||
? "structOffset: {{TABLEOFFSET}}.{{OFFSET}}) }"
|
||||
: "offset: {{FIELDVAR}}, at: {{TABLEOFFSET}}.{{OFFSET}}) "
|
||||
"}";
|
||||
code_ += "Offset" + builder_string + "fbb.add(" + reader_type;
|
||||
|
||||
const auto vectortype = field.value.type.VectorType();
|
||||
@@ -852,7 +859,10 @@ class SwiftGenerator : public BaseGenerator {
|
||||
break;
|
||||
|
||||
case BASE_TYPE_STRING: {
|
||||
const auto default_string = "\"" + SwiftConstant(field) + "\"";
|
||||
const auto sc = SwiftConstant(field);
|
||||
std::string default_string;
|
||||
flatbuffers::EscapeString(sc.c_str(), sc.length(), &default_string,
|
||||
true, false);
|
||||
code_.SetValue("VALUETYPE", GenType(field.value.type));
|
||||
code_.SetValue("CONSTANT", field.IsDefault() ? default_string : "nil");
|
||||
code_ += GenReaderMainBody(is_required) + GenOffset() +
|
||||
@@ -860,7 +870,7 @@ class SwiftGenerator : public BaseGenerator {
|
||||
code_ += "{{ACCESS_TYPE}} var {{FIELDVAR}}SegmentArray: [UInt8]" +
|
||||
is_required +
|
||||
" { return "
|
||||
"{{ACCESS}}.getVector(at: {{TABLEOFFSET}}.{{OFFSET}}.v) }";
|
||||
"{{ACCESS}}.getVector(at: {{TABLEOFFSET}}.{{OFFSET}}) }";
|
||||
break;
|
||||
}
|
||||
case BASE_TYPE_ARRAY:
|
||||
@@ -894,7 +904,7 @@ class SwiftGenerator : public BaseGenerator {
|
||||
code_ +=
|
||||
"{{ACCESS_TYPE}} var {{FIELDVAR}}: "
|
||||
"FlatbufferVector<{{VALUETYPE}}> "
|
||||
"{ return {{ACCESS}}.vector(at: {{TABLEOFFSET}}.{{OFFSET}}.v, "
|
||||
"{ return {{ACCESS}}.vector(at: {{TABLEOFFSET}}.{{OFFSET}}, "
|
||||
"byteSize: {{SIZE}}) }";
|
||||
}
|
||||
|
||||
@@ -911,7 +921,7 @@ class SwiftGenerator : public BaseGenerator {
|
||||
code_ +=
|
||||
"{{ACCESS_TYPE}} var {{FIELDVAR}}: "
|
||||
"FlatbufferVector<{{VALUETYPE}}_Mutable> "
|
||||
"{ return {{ACCESS}}.vector(at: {{TABLEOFFSET}}.{{OFFSET}}.v, "
|
||||
"{ return {{ACCESS}}.vector(at: {{TABLEOFFSET}}.{{OFFSET}}, "
|
||||
"byteSize: {{SIZE}}) }";
|
||||
GenUnsafeBufferPointer(field);
|
||||
return;
|
||||
@@ -920,7 +930,8 @@ class SwiftGenerator : public BaseGenerator {
|
||||
if (vectortype.base_type == BASE_TYPE_UNION) {
|
||||
code_ +=
|
||||
"{{ACCESS_TYPE}} var {{FIELDVAR}}: UnionFlatbufferVector "
|
||||
"{ return {{ACCESS}}.unionVector(at: {{TABLEOFFSET}}.{{OFFSET}}.v, "
|
||||
"{ return {{ACCESS}}.unionVector(at: "
|
||||
"{{TABLEOFFSET}}.{{OFFSET}}, "
|
||||
"byteSize: {{SIZE}}) }";
|
||||
code_ +=
|
||||
"{{ACCESS_TYPE}} func {{FIELDVAR}}<T: FlatbuffersInitializable>(at "
|
||||
@@ -954,24 +965,21 @@ class SwiftGenerator : public BaseGenerator {
|
||||
"{{ACCESS_TYPE}} func {{functionName}}<T>(_ body: "
|
||||
"(UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return "
|
||||
"try "
|
||||
"{{ACCESS}}.withUnsafePointerToSlice(at: {{TABLEOFFSET}}.{{OFFSET}}.v, "
|
||||
"{{ACCESS}}.withUnsafePointerToSlice(at: "
|
||||
"{{TABLEOFFSET}}.{{OFFSET}}, "
|
||||
"body: body) }";
|
||||
}
|
||||
|
||||
void GenerateCodingKeys(const StructDef& struct_def) {
|
||||
code_ += "enum CodingKeys: String, CodingKey {";
|
||||
Indent();
|
||||
std::vector<std::string> GenerateCodingKeys(const StructDef& struct_def) {
|
||||
std::vector<std::string> coding_keys;
|
||||
for (auto it = struct_def.fields.vec.begin();
|
||||
it != struct_def.fields.vec.end(); ++it) {
|
||||
const auto& field = **it;
|
||||
if (field.deprecated) continue;
|
||||
|
||||
code_.SetValue("RAWVALUENAME", field.name);
|
||||
code_.SetValue("FIELDVAR", namer_.Variable(field));
|
||||
code_ += "case {{FIELDVAR}} = \"{{RAWVALUENAME}}\"";
|
||||
coding_keys.push_back("case " + namer_.Variable(field) + " = \"" +
|
||||
field.name + "\"");
|
||||
}
|
||||
Outdent();
|
||||
code_ += "}";
|
||||
return coding_keys;
|
||||
}
|
||||
|
||||
void GenerateEncoderUnionBody(const FieldDef& field) {
|
||||
@@ -1093,14 +1101,31 @@ class SwiftGenerator : public BaseGenerator {
|
||||
GenOSVersionChecks();
|
||||
code_ += "extension {{STRUCTNAME}}: Encodable {";
|
||||
Indent();
|
||||
code_ += "";
|
||||
if (struct_def.fields.vec.empty() == false) GenerateCodingKeys(struct_def);
|
||||
auto coding_keys = GenerateCodingKeys(struct_def);
|
||||
|
||||
if (coding_keys.empty() == false) {
|
||||
code_ += "enum CodingKeys: String, CodingKey {";
|
||||
Indent();
|
||||
for (auto it = coding_keys.begin(); it != coding_keys.end(); ++it) {
|
||||
const auto& field = *it;
|
||||
code_ += field;
|
||||
}
|
||||
Outdent();
|
||||
code_ += "}";
|
||||
|
||||
code_ += "";
|
||||
}
|
||||
|
||||
code_ += "{{ACCESS_TYPE}} func encode(to encoder: Encoder) throws {";
|
||||
Indent();
|
||||
if (struct_def.fields.vec.empty() == false) GenerateEncoderBody(struct_def);
|
||||
Outdent();
|
||||
|
||||
if (coding_keys.empty() == false) {
|
||||
Indent();
|
||||
GenerateEncoderBody(struct_def);
|
||||
Outdent();
|
||||
}
|
||||
|
||||
code_ += "}";
|
||||
|
||||
Outdent();
|
||||
code_ += "}";
|
||||
code_ += "";
|
||||
@@ -1130,7 +1155,7 @@ class SwiftGenerator : public BaseGenerator {
|
||||
}
|
||||
|
||||
code_ +=
|
||||
"try _v.visit(field: {{TABLEOFFSET}}.{{OFFSET}}.p, fieldName: "
|
||||
"try _v.visit(field: {{TABLEOFFSET}}.{{OFFSET}}, fieldName: "
|
||||
"\"{{FIELDVAR}}\", required: {{ISREQUIRED}}, type: "
|
||||
"{{VALUETYPE}}.self)";
|
||||
}
|
||||
@@ -1150,8 +1175,9 @@ class SwiftGenerator : public BaseGenerator {
|
||||
code_.SetValue("VALUETYPE", namer_.NamespacedType(union_def));
|
||||
code_.SetValue("FUNCTION_NAME", is_vector ? "visitUnionVector" : "visit");
|
||||
code_ +=
|
||||
"try _v.{{FUNCTION_NAME}}(unionKey: {{TABLEOFFSET}}.{{OFFSET}}Type.p, "
|
||||
"unionField: {{TABLEOFFSET}}.{{OFFSET}}.p, unionKeyName: "
|
||||
"try _v.{{FUNCTION_NAME}}(unionKey: "
|
||||
"{{TABLEOFFSET}}.{{OFFSET}}Type, "
|
||||
"unionField: {{TABLEOFFSET}}.{{OFFSET}}, unionKeyName: "
|
||||
"\"{{FIELDVAR}}Type\", fieldName: \"{{FIELDVAR}}\", required: "
|
||||
"{{ISREQUIRED}}, completion: { (verifier, key: {{VALUETYPE}}, pos) in";
|
||||
Indent();
|
||||
@@ -1626,15 +1652,23 @@ class SwiftGenerator : public BaseGenerator {
|
||||
buffer_constructor.push_back(field_var + " = _t." + field_field);
|
||||
|
||||
if (field.IsRequired()) {
|
||||
std::string default_value =
|
||||
field.IsDefault() ? SwiftConstant(field) : "";
|
||||
base_constructor.push_back(field_var + " = \"" + default_value +
|
||||
"\"");
|
||||
std::string default_value;
|
||||
if (field.IsDefault()) {
|
||||
const auto sc = SwiftConstant(field);
|
||||
flatbuffers::EscapeString(sc.c_str(), sc.length(), &default_value,
|
||||
true, false);
|
||||
} else {
|
||||
default_value = "\"\"";
|
||||
}
|
||||
base_constructor.push_back(field_var + " = " + default_value);
|
||||
break;
|
||||
}
|
||||
if (field.IsDefault() && !field.IsRequired()) {
|
||||
std::string value = field.IsDefault() ? SwiftConstant(field) : "nil";
|
||||
base_constructor.push_back(field_var + " = \"" + value + "\"");
|
||||
const auto sc = SwiftConstant(field);
|
||||
std::string value;
|
||||
flatbuffers::EscapeString(sc.c_str(), sc.length(), &value,
|
||||
true, false);
|
||||
base_constructor.push_back(field_var + " = " + value);
|
||||
}
|
||||
break;
|
||||
}
|
||||
@@ -1893,7 +1927,7 @@ class SwiftGenerator : public BaseGenerator {
|
||||
}
|
||||
|
||||
std::string GenOffset() {
|
||||
return "let o = {{ACCESS}}.offset({{TABLEOFFSET}}.{{OFFSET}}.v); ";
|
||||
return "let o = {{ACCESS}}.offset({{TABLEOFFSET}}.{{OFFSET}}); ";
|
||||
}
|
||||
|
||||
std::string GenReaderMainBody(const std::string& optional = "") {
|
||||
|
||||
+169
-53
@@ -324,9 +324,10 @@ class TsGenerator : public BaseGenerator {
|
||||
export_counter++;
|
||||
}
|
||||
|
||||
if (export_counter > 0)
|
||||
if (export_counter > 0) {
|
||||
parser_.opts.file_saver->SaveFile(it.second.filepath.c_str(), code,
|
||||
false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -521,7 +522,20 @@ class TsGenerator : public BaseGenerator {
|
||||
case BASE_TYPE_BOOL:
|
||||
return value.constant == "0" ? "false" : "true";
|
||||
|
||||
case BASE_TYPE_STRING:
|
||||
case BASE_TYPE_STRING: {
|
||||
// NOTE: Strings without a default value are parsed as "0" by
|
||||
// the parser, so therefore we have to treat "0" as a null-signifying
|
||||
// value.
|
||||
if (value.constant == "0" || value.constant == "null") {
|
||||
return "null";
|
||||
} else {
|
||||
std::string escaped;
|
||||
flatbuffers::EscapeString(value.constant.c_str(),
|
||||
value.constant.length(), &escaped,
|
||||
true, false);
|
||||
return escaped;
|
||||
}
|
||||
}
|
||||
case BASE_TYPE_UNION:
|
||||
case BASE_TYPE_STRUCT: {
|
||||
return null_keyword_;
|
||||
@@ -647,7 +661,8 @@ class TsGenerator : public BaseGenerator {
|
||||
}
|
||||
|
||||
void GenStructArgs(import_set& imports, const StructDef& struct_def,
|
||||
std::string* arguments, const std::string& nameprefix) {
|
||||
const Definition& owner, std::string* arguments,
|
||||
const std::string& nameprefix) {
|
||||
for (auto it = struct_def.fields.vec.begin();
|
||||
it != struct_def.fields.vec.end(); ++it) {
|
||||
auto& field = **it;
|
||||
@@ -655,11 +670,11 @@ class TsGenerator : public BaseGenerator {
|
||||
// Generate arguments for a struct inside a struct. To ensure names
|
||||
// don't clash, and to make it obvious these arguments are constructing
|
||||
// a nested struct, prefix the name with the field name.
|
||||
GenStructArgs(imports, *field.value.type.struct_def, arguments,
|
||||
GenStructArgs(imports, *field.value.type.struct_def, owner, arguments,
|
||||
nameprefix + field.name + "_");
|
||||
} else {
|
||||
*arguments += ", " + nameprefix + field.name + ": " +
|
||||
GenTypeName(imports, field, field.value.type, true,
|
||||
GenTypeName(imports, owner, field.value.type, true,
|
||||
field.IsOptional());
|
||||
}
|
||||
}
|
||||
@@ -921,6 +936,48 @@ class TsGenerator : public BaseGenerator {
|
||||
return symbols_expression;
|
||||
}
|
||||
|
||||
std::vector<std::string> PathComponents(const std::string& path) const {
|
||||
std::vector<std::string> components;
|
||||
size_t start = 0;
|
||||
while (start < path.size()) {
|
||||
auto end = path.find(kPathSeparator, start);
|
||||
if (end == std::string::npos) end = path.size();
|
||||
if (end > start) {
|
||||
components.emplace_back(path.substr(start, end - start));
|
||||
}
|
||||
if (end == path.size()) break;
|
||||
start = end + 1;
|
||||
}
|
||||
return components;
|
||||
}
|
||||
|
||||
std::string RelativeDirectory(const std::vector<std::string>& from,
|
||||
const std::vector<std::string>& to) const {
|
||||
size_t common = 0;
|
||||
while (common < from.size() && common < to.size() &&
|
||||
from[common] == to[common]) {
|
||||
++common;
|
||||
}
|
||||
|
||||
std::string rel;
|
||||
const size_t ups = from.size() - common;
|
||||
if (ups == 0) {
|
||||
rel = ".";
|
||||
} else {
|
||||
for (size_t i = 0; i < ups; ++i) {
|
||||
if (!rel.empty()) rel += kPathSeparator;
|
||||
rel += "..";
|
||||
}
|
||||
}
|
||||
|
||||
for (size_t i = common; i < to.size(); ++i) {
|
||||
if (!rel.empty()) rel += kPathSeparator;
|
||||
rel += to[i];
|
||||
}
|
||||
|
||||
return rel;
|
||||
}
|
||||
|
||||
template <typename DefinitionT>
|
||||
ImportDefinition AddImport(import_set& imports, const Definition& dependent,
|
||||
const DefinitionT& dependency) {
|
||||
@@ -948,26 +1005,32 @@ class TsGenerator : public BaseGenerator {
|
||||
const std::string symbols_expression = GenSymbolExpression(
|
||||
dependency, has_name_clash, import_name, name, object_name);
|
||||
|
||||
std::string bare_file_path;
|
||||
std::string rel_file_path;
|
||||
if (dependent.defined_namespace) {
|
||||
const auto& dep_comps = dependent.defined_namespace->components;
|
||||
for (size_t i = 0; i < dep_comps.size(); i++) {
|
||||
rel_file_path += i == 0 ? ".." : (kPathSeparator + std::string(".."));
|
||||
}
|
||||
if (dep_comps.size() == 0) {
|
||||
rel_file_path += ".";
|
||||
}
|
||||
} else {
|
||||
rel_file_path += "..";
|
||||
}
|
||||
const Namespace* dependent_ns = dependent.defined_namespace
|
||||
? dependent.defined_namespace
|
||||
: parser_.empty_namespace_;
|
||||
const Namespace* dependency_ns = dependency.defined_namespace
|
||||
? dependency.defined_namespace
|
||||
: parser_.empty_namespace_;
|
||||
|
||||
bare_file_path +=
|
||||
kPathSeparator +
|
||||
namer_.Directories(dependency.defined_namespace->components,
|
||||
SkipDir::OutputPath) +
|
||||
const std::string dependent_dirs =
|
||||
namer_.Directories(*dependent_ns, SkipDir::OutputPath);
|
||||
const std::string dependency_dirs =
|
||||
namer_.Directories(*dependency_ns, SkipDir::OutputPath);
|
||||
|
||||
const auto dependent_components = PathComponents(dependent_dirs);
|
||||
const auto dependency_components = PathComponents(dependency_dirs);
|
||||
|
||||
std::string rel_dir =
|
||||
RelativeDirectory(dependent_components, dependency_components);
|
||||
if (rel_dir.empty()) rel_dir = ".";
|
||||
if (!rel_dir.empty()) rel_dir += kPathSeparator;
|
||||
|
||||
std::string rel_file_path =
|
||||
rel_dir + namer_.File(dependency, SkipFile::SuffixAndExtension);
|
||||
|
||||
std::string bare_file_path =
|
||||
kPathSeparator + dependency_dirs +
|
||||
namer_.File(dependency, SkipFile::SuffixAndExtension);
|
||||
rel_file_path += bare_file_path;
|
||||
|
||||
ImportDefinition import;
|
||||
import.name = name;
|
||||
@@ -1172,9 +1235,10 @@ class TsGenerator : public BaseGenerator {
|
||||
|
||||
std::string GenNullCheckConditional(const std::string& nullCheckVar,
|
||||
const std::string& trueVal,
|
||||
const std::string& falseVal) {
|
||||
const std::string& falseVal = "") {
|
||||
std::string false_val = falseVal.empty() ? null_keyword_ : falseVal;
|
||||
return "(" + nullCheckVar + " !== " + null_keyword_ + " ? " + trueVal +
|
||||
" : " + falseVal + ")";
|
||||
" : " + false_val + ")";
|
||||
}
|
||||
|
||||
std::string GenStructMemberValueTS(const StructDef& struct_def,
|
||||
@@ -1283,10 +1347,9 @@ class TsGenerator : public BaseGenerator {
|
||||
// Emit a scalar field
|
||||
const auto is_string = IsString(field.value.type);
|
||||
if (IsScalar(field.value.type.base_type) || is_string) {
|
||||
const auto has_null_default = is_string || HasNullDefault(field);
|
||||
|
||||
field_type += GenTypeName(imports, field, field.value.type, false,
|
||||
has_null_default);
|
||||
field_type +=
|
||||
GenTypeName(imports, field, field.value.type, false,
|
||||
!HasDefaultValue(field) || HasNullDefault(field));
|
||||
field_val = "this." + namer_.Method(field) + "()";
|
||||
|
||||
if (field.value.type.base_type != BASE_TYPE_STRING) {
|
||||
@@ -1632,11 +1695,12 @@ class TsGenerator : public BaseGenerator {
|
||||
GenDocComment(struct_def.doc_comment, code_ptr);
|
||||
code += "export class ";
|
||||
code += object_name;
|
||||
if (parser.opts.generate_object_based_api)
|
||||
if (parser.opts.generate_object_based_api) {
|
||||
code += " implements flatbuffers.IUnpackableObject<" + object_api_name +
|
||||
"> {\n";
|
||||
else
|
||||
} else {
|
||||
code += " {\n";
|
||||
}
|
||||
code += " bb: flatbuffers.ByteBuffer|" + null_keyword_ + " = " +
|
||||
null_keyword_ + ";\n";
|
||||
code += " bb_pos = 0;\n";
|
||||
@@ -1679,21 +1743,22 @@ class TsGenerator : public BaseGenerator {
|
||||
offset_prefix = " const offset = " + GenBBAccess() +
|
||||
".__offset(this.bb_pos, " +
|
||||
NumToString(field.value.offset) + ");\n";
|
||||
offset_prefix += " return offset ? ";
|
||||
offset_prefix += " return ";
|
||||
}
|
||||
|
||||
// Emit a scalar field
|
||||
const auto is_string = IsString(field.value.type);
|
||||
if (IsScalar(field.value.type.base_type) || is_string) {
|
||||
const auto has_null_default = is_string || HasNullDefault(field);
|
||||
const auto has_null_default =
|
||||
!field.IsRequired() && !HasDefaultValue(field);
|
||||
|
||||
GenDocComment(field.doc_comment, code_ptr);
|
||||
std::string prefix = namer_.Method(field) + "(";
|
||||
if (is_string) {
|
||||
code += prefix + "):string|" + null_keyword_ + "\n";
|
||||
code += prefix + "):" + (has_null_default ? "string|" + null_keyword_ : "string") + "\n";
|
||||
code +=
|
||||
prefix + "optionalEncoding:flatbuffers.Encoding" + "):" +
|
||||
GenTypeName(imports, struct_def, field.value.type, false, true) +
|
||||
GenTypeName(imports, struct_def, field.value.type, false, has_null_default) +
|
||||
"\n";
|
||||
code += prefix + "optionalEncoding?:any";
|
||||
} else {
|
||||
@@ -1722,9 +1787,16 @@ class TsGenerator : public BaseGenerator {
|
||||
if (is_string) {
|
||||
index += ", optionalEncoding";
|
||||
}
|
||||
code +=
|
||||
offset_prefix + GenGetter(field.value.type, "(" + index + ")");
|
||||
if (field.value.type.base_type != BASE_TYPE_ARRAY) {
|
||||
if (field.IsRequired()) {
|
||||
code +=
|
||||
offset_prefix + GenGetter(field.value.type, "(" + index + ")");
|
||||
;
|
||||
} else {
|
||||
code += offset_prefix + "offset ? " +
|
||||
GenGetter(field.value.type, "(" + index + ")");
|
||||
}
|
||||
if (field.value.type.base_type != BASE_TYPE_ARRAY &&
|
||||
!field.IsRequired()) {
|
||||
code += " : " + GenDefaultValue(field, imports);
|
||||
}
|
||||
code += ";\n";
|
||||
@@ -1749,8 +1821,8 @@ class TsGenerator : public BaseGenerator {
|
||||
code +=
|
||||
MaybeAdd(field.value.offset) + ", " + GenBBAccess() + ");\n";
|
||||
} else {
|
||||
code += offset_prefix + "(obj || " + GenerateNewExpression(type) +
|
||||
").__init(";
|
||||
code += offset_prefix + "offset ? (obj || " +
|
||||
GenerateNewExpression(type) + ").__init(";
|
||||
code += field.value.type.struct_def->fixed
|
||||
? "this.bb_pos + offset"
|
||||
: GenBBAccess() + ".__indirect(this.bb_pos + offset)";
|
||||
@@ -1908,7 +1980,7 @@ class TsGenerator : public BaseGenerator {
|
||||
code += "):" + vectortypename + "|" + null_keyword_ + " {\n";
|
||||
|
||||
if (vectortype.base_type == BASE_TYPE_STRUCT) {
|
||||
code += offset_prefix + "(obj || " +
|
||||
code += offset_prefix + "offset ? (obj || " +
|
||||
GenerateNewExpression(vectortypename);
|
||||
code += ").__init(";
|
||||
code += vectortype.struct_def->fixed
|
||||
@@ -1921,7 +1993,8 @@ class TsGenerator : public BaseGenerator {
|
||||
} else if (IsString(vectortype)) {
|
||||
index += ", optionalEncoding";
|
||||
}
|
||||
code += offset_prefix + GenGetter(vectortype, "(" + index + ")");
|
||||
code += offset_prefix + "offset ? " +
|
||||
GenGetter(vectortype, "(" + index + ")");
|
||||
}
|
||||
code += " : ";
|
||||
if (field.value.type.element == BASE_TYPE_BOOL) {
|
||||
@@ -1953,7 +2026,7 @@ class TsGenerator : public BaseGenerator {
|
||||
" "
|
||||
"{\n";
|
||||
|
||||
code += offset_prefix +
|
||||
code += offset_prefix + "offset ? " +
|
||||
GenGetter(field.value.type, "(obj, this.bb_pos + offset)") +
|
||||
" : " + null_keyword_ + ";\n";
|
||||
break;
|
||||
@@ -2006,7 +2079,7 @@ class TsGenerator : public BaseGenerator {
|
||||
// Emit a length helper
|
||||
GenDocComment(code_ptr);
|
||||
code += namer_.Method(field, "Length");
|
||||
code += "():number {\n" + offset_prefix;
|
||||
code += "():number {\n" + offset_prefix + "offset ? ";
|
||||
|
||||
code +=
|
||||
GenBBAccess() + ".__vector_len(this.bb_pos + offset) : 0;\n}\n\n";
|
||||
@@ -2017,15 +2090,30 @@ class TsGenerator : public BaseGenerator {
|
||||
GenDocComment(code_ptr);
|
||||
|
||||
code += namer_.Method(field, "Array");
|
||||
code += "():" + GenType(vectorType) + "Array|" + null_keyword_ +
|
||||
" {\n" + offset_prefix;
|
||||
|
||||
code += "new " + GenType(vectorType) + "Array(" + GenBBAccess() +
|
||||
".bytes().buffer, " + GenBBAccess() +
|
||||
".bytes().byteOffset + " + GenBBAccess() +
|
||||
".__vector(this.bb_pos + offset), " + GenBBAccess() +
|
||||
".__vector_len(this.bb_pos + offset)) : " + null_keyword_ +
|
||||
";\n}\n\n";
|
||||
std::string return_type =
|
||||
(field.IsRequired() || HasDefaultValue(field))
|
||||
? "Array"
|
||||
: ("Array|" + null_keyword_);
|
||||
if (field.IsRequired()) {
|
||||
code += "():" + GenType(vectorType) + return_type + " {\n" +
|
||||
offset_prefix + "new " + GenType(vectorType) + "Array(" +
|
||||
GenBBAccess() + ".bytes().buffer, " + GenBBAccess() +
|
||||
".bytes().byteOffset + " + GenBBAccess() +
|
||||
".__vector(this.bb_pos + offset), " + GenBBAccess() +
|
||||
".__vector_len(this.bb_pos + offset));\n}\n\n";
|
||||
} else {
|
||||
std::string value = HasDefaultValue(field)
|
||||
? "new " + GenType(vectorType) + "Array()"
|
||||
: "null";
|
||||
code += "():" + GenType(vectorType) + return_type + " {\n" +
|
||||
offset_prefix + "offset ? new " + GenType(vectorType) +
|
||||
"Array(" + GenBBAccess() + ".bytes().buffer, " +
|
||||
GenBBAccess() + ".bytes().byteOffset + " + GenBBAccess() +
|
||||
".__vector(this.bb_pos + offset), " + GenBBAccess() +
|
||||
".__vector_len(this.bb_pos + offset)) : " + value +
|
||||
";\n}\n\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -2054,7 +2142,7 @@ class TsGenerator : public BaseGenerator {
|
||||
// Emit a factory constructor
|
||||
if (struct_def.fixed) {
|
||||
std::string arguments;
|
||||
GenStructArgs(imports, struct_def, &arguments, "");
|
||||
GenStructArgs(imports, struct_def, struct_def, &arguments, "");
|
||||
GenDocComment(code_ptr);
|
||||
|
||||
code += "static create" + GetPrefixedName(struct_def) +
|
||||
@@ -2256,6 +2344,34 @@ class TsGenerator : public BaseGenerator {
|
||||
return field.IsOptional() && field.value.constant == "null";
|
||||
}
|
||||
|
||||
static bool HasDefaultValue(const FieldDef& field) {
|
||||
switch (field.value.type.base_type) {
|
||||
// These types can't have defaults
|
||||
case BASE_TYPE_UNION:
|
||||
case BASE_TYPE_STRUCT: {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Arrays always have a default (empty array)
|
||||
case BASE_TYPE_ARRAY:
|
||||
return true;
|
||||
|
||||
// The only supported default for vectors is []
|
||||
case BASE_TYPE_VECTOR:
|
||||
return field.value.constant == "[]";
|
||||
|
||||
// Even strings are presumed to be null-default if the default value is
|
||||
// "0", this is intended behavior.
|
||||
case BASE_TYPE_STRING: {
|
||||
return field.value.constant != "0" && field.value.constant != "null";
|
||||
}
|
||||
|
||||
default: {
|
||||
return field.value.constant != "null";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::string GetArgType(import_set& imports, const Definition& owner,
|
||||
const FieldDef& field, bool allowNull) {
|
||||
return GenTypeName(imports, owner, field.value.type, true,
|
||||
|
||||
+6
-52
@@ -1286,55 +1286,6 @@ CheckedError Parser::ParseField(StructDef& struct_def) {
|
||||
"'native_inline' can only be defined on structs, vector of structs or "
|
||||
"vector of tables");
|
||||
|
||||
// `bigfoot_ref` is Bigfoot's single-purpose replacement for the old,
|
||||
// general-purpose `native_type_template`/`native_type_template_arg` pair:
|
||||
// a field typed as a `bigfoot_ref_wrapper`-tagged struct (HardReference or
|
||||
// SoftReference) and annotated `bigfoot_ref: "::Bigfoot::AssetX"` gets its
|
||||
// native type instantiated as `<wrapper><::Bigfoot::AssetX>`, plus (unlike
|
||||
// the old mechanism) a forward declaration of AssetX and inline Pack/UnPack
|
||||
// definitions are emitted directly into the generated header - see
|
||||
// GenerateBigfootRefDecls in idl_gen_cpp.cpp.
|
||||
auto bigfoot_ref = field->attributes.Lookup("bigfoot_ref");
|
||||
if (bigfoot_ref) {
|
||||
if (!IsStruct(field->value.type) && !IsVectorOfStruct(field->value.type))
|
||||
return Error(
|
||||
"'bigfoot_ref' can only be defined on struct-typed fields or "
|
||||
"vectors of structs");
|
||||
const auto* target_struct = field->value.type.struct_def;
|
||||
const auto* wrapper = target_struct->attributes.Lookup("bigfoot_ref_wrapper");
|
||||
if (!wrapper)
|
||||
return Error(
|
||||
"'bigfoot_ref' requires the field's type ('" + target_struct->name +
|
||||
"') to declare a 'bigfoot_ref_wrapper' attribute");
|
||||
if (field->attributes.Lookup("native_type"))
|
||||
return Error(
|
||||
"'bigfoot_ref' cannot be combined with an explicit 'native_type' "
|
||||
"on the same field");
|
||||
|
||||
const auto b = bigfoot_ref->constant.find_first_not_of(" \t");
|
||||
const auto e = bigfoot_ref->constant.find_last_not_of(" \t");
|
||||
const std::string asset_type =
|
||||
b == std::string::npos ? "" : bigfoot_ref->constant.substr(b, e - b + 1);
|
||||
if (asset_type.empty())
|
||||
return Error("'bigfoot_ref' cannot be empty");
|
||||
|
||||
auto native_type_val = new Value();
|
||||
native_type_val->type = bigfoot_ref->type;
|
||||
native_type_val->constant = wrapper->constant + "<" + asset_type + ">";
|
||||
field->attributes.Add("native_type", native_type_val);
|
||||
|
||||
if (!field->attributes.Lookup("native_type_pack_name")) {
|
||||
const auto last_colon = asset_type.find_last_of(':');
|
||||
const std::string asset_short_name =
|
||||
last_colon == std::string::npos ? asset_type
|
||||
: asset_type.substr(last_colon + 1);
|
||||
auto pack_name_val = new Value();
|
||||
pack_name_val->type = bigfoot_ref->type;
|
||||
pack_name_val->constant = target_struct->name + asset_short_name;
|
||||
field->attributes.Add("native_type_pack_name", pack_name_val);
|
||||
}
|
||||
}
|
||||
|
||||
auto nested = field->attributes.Lookup("nested_flatbuffer");
|
||||
if (nested) {
|
||||
if (nested->type.base_type != BASE_TYPE_STRING)
|
||||
@@ -2858,7 +2809,8 @@ bool Parser::SupportsOptionalScalars() const {
|
||||
bool Parser::SupportsDefaultVectorsAndStrings() const {
|
||||
static FLATBUFFERS_CONSTEXPR unsigned long supported_langs =
|
||||
IDLOptions::kRust | IDLOptions::kSwift | IDLOptions::kNim |
|
||||
IDLOptions::kCpp | IDLOptions::kBinary | IDLOptions::kJson;
|
||||
IDLOptions::kCpp | IDLOptions::kBinary | IDLOptions::kJson |
|
||||
IDLOptions::kTs;
|
||||
return !(opts.lang_to_generate & ~supported_langs);
|
||||
}
|
||||
|
||||
@@ -3220,8 +3172,10 @@ CheckedError Parser::ParseProtoFields(StructDef* struct_def, bool isextend,
|
||||
return Error("Protobuf has non positive number in reserved ids");
|
||||
|
||||
if (range) {
|
||||
for (voffset_t id = from + 1; id <= attribute; id++)
|
||||
struct_def->reserved_ids.push_back(id);
|
||||
for (uint32_t id = static_cast<uint32_t>(from) + 1;
|
||||
id <= static_cast<uint32_t>(attribute); id++) {
|
||||
struct_def->reserved_ids.push_back(static_cast<voffset_t>(id));
|
||||
}
|
||||
|
||||
range = false;
|
||||
} else {
|
||||
|
||||
+4
-1
@@ -641,7 +641,10 @@ const uint8_t* AddFlatBuffer(std::vector<uint8_t>& flatbuf,
|
||||
const uint8_t* newbuf, size_t newlen) {
|
||||
// Align to sizeof(uoffset_t) past sizeof(largest_scalar_t) since we're
|
||||
// going to chop off the root offset.
|
||||
if (!newbuf || newlen < sizeof(uoffset_t)) return nullptr;
|
||||
FLATBUFFERS_ASSERT(newlen >= sizeof(uoffset_t));
|
||||
auto root = ReadScalar<uoffset_t>(newbuf);
|
||||
if (root < sizeof(uoffset_t) || root >= newlen) return nullptr;
|
||||
while ((flatbuf.size() & (sizeof(uoffset_t) - 1)) ||
|
||||
!(flatbuf.size() & (sizeof(largest_scalar_t) - 1))) {
|
||||
flatbuf.push_back(0);
|
||||
@@ -649,7 +652,7 @@ const uint8_t* AddFlatBuffer(std::vector<uint8_t>& flatbuf,
|
||||
auto insertion_point = static_cast<uoffset_t>(flatbuf.size());
|
||||
// Insert the entire FlatBuffer minus the root pointer.
|
||||
flatbuf.insert(flatbuf.end(), newbuf + sizeof(uoffset_t), newbuf + newlen);
|
||||
auto root_offset = ReadScalar<uoffset_t>(newbuf) - sizeof(uoffset_t);
|
||||
auto root_offset = root - sizeof(uoffset_t);
|
||||
return flatbuf.data() + insertion_point + root_offset;
|
||||
}
|
||||
|
||||
|
||||
@@ -49,7 +49,7 @@ public struct Table {
|
||||
/// the vtable
|
||||
/// - Parameter o: current offset
|
||||
/// - Returns: offset of field within buffer
|
||||
public func offset(_ o: Int32) -> Int32 {
|
||||
public func offset(_ o: VOffset) -> Int32 {
|
||||
let vtable = position &- bb.read(def: Int32.self, position: Int(position))
|
||||
return o
|
||||
< bb
|
||||
@@ -57,7 +57,7 @@ public struct Table {
|
||||
? Int32(
|
||||
bb.read(
|
||||
def: Int16.self,
|
||||
position: Int(vtable &+ o))) : 0
|
||||
position: Int(vtable &+ Int32(o)))) : 0
|
||||
}
|
||||
|
||||
/// Gets the indirect offset of the current stored object
|
||||
@@ -106,13 +106,13 @@ public struct Table {
|
||||
/// This should only be used by `Scalars`
|
||||
/// - Parameter off: Readable offset
|
||||
/// - Returns: Returns a vector of type [T]
|
||||
public func getVector<T>(at off: Int32) -> [T]? {
|
||||
public func getVector<T>(at off: VOffset) -> [T]? {
|
||||
let o = offset(off)
|
||||
guard o != 0 else { return nil }
|
||||
return bb.readSlice(index: Int(vector(at: o)), count: Int(vector(count: o)))
|
||||
}
|
||||
|
||||
public func vector<T>(at off: Int32, byteSize: Int) -> FlatbufferVector<T> {
|
||||
public func vector<T>(at off: VOffset, byteSize: Int) -> FlatbufferVector<T> {
|
||||
let off = offset(off)
|
||||
return FlatbufferVector(
|
||||
bb: bb,
|
||||
@@ -122,7 +122,7 @@ public struct Table {
|
||||
}
|
||||
|
||||
public func unionVector(
|
||||
at off: Int32,
|
||||
at off: VOffset,
|
||||
byteSize: Int) -> UnionFlatbufferVector
|
||||
{
|
||||
let off = offset(off)
|
||||
@@ -146,7 +146,7 @@ public struct Table {
|
||||
/// - Returns: Returns a pointer to the underlying data
|
||||
@inline(__always)
|
||||
public func withUnsafePointerToSlice<T>(
|
||||
at off: Int32,
|
||||
at off: VOffset,
|
||||
body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T?
|
||||
{
|
||||
let o = offset(off)
|
||||
|
||||
@@ -14,6 +14,7 @@
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
import Common
|
||||
import Foundation
|
||||
|
||||
enum FlexBuffersErrors: Error {
|
||||
@@ -23,6 +24,10 @@ enum FlexBuffersErrors: Error {
|
||||
|
||||
@inline(__always)
|
||||
public func getRoot(buffer: ByteBuffer) throws -> Reference? {
|
||||
assert(
|
||||
isLitteEndian,
|
||||
"Swift FlexBuffers currently only supports little-endian systems")
|
||||
|
||||
let end = buffer.count
|
||||
if buffer.count < 3 {
|
||||
throw FlexBuffersErrors.sizeOfBufferIsTooSmall
|
||||
|
||||
@@ -37,12 +37,15 @@ public struct FlexBuffersWriter {
|
||||
private var hasDuplicatedKeys = false
|
||||
private var minBitWidth: BitWidth = .w8
|
||||
private var _bb: _InternalByteBuffer
|
||||
private var stack: [Value] = []
|
||||
private var stack: Stack = Stack()
|
||||
private var keyPool: [Int: UInt] = [:]
|
||||
private var stringPool: [Int: UInt] = [:]
|
||||
private var flags: BuilderFlag
|
||||
|
||||
public init(initialSize: Int = 1024, flags: BuilderFlag = .shareKeys) {
|
||||
assert(
|
||||
isLitteEndian,
|
||||
"Swift FlexBuffers currently only supports little-endian systems")
|
||||
_bb = _InternalByteBuffer(initialSize: initialSize)
|
||||
self.flags = flags
|
||||
}
|
||||
@@ -148,7 +151,7 @@ public struct FlexBuffersWriter {
|
||||
typed: typed,
|
||||
fixed: fixed,
|
||||
keys: nil)
|
||||
stack = Array(stack[..<start])
|
||||
stack.popLast(start)
|
||||
stack.append(vec)
|
||||
return vec.u
|
||||
}
|
||||
@@ -217,7 +220,7 @@ public struct FlexBuffersWriter {
|
||||
typed: false,
|
||||
fixed: false,
|
||||
keys: keys)
|
||||
stack = Array(stack[..<start])
|
||||
stack.popLast(start)
|
||||
stack.append(vec)
|
||||
return numericCast(vec.u)
|
||||
}
|
||||
@@ -721,7 +724,7 @@ public struct FlexBuffersWriter {
|
||||
assert(
|
||||
vectorType == stack[i].type,
|
||||
"""
|
||||
If you get this assert you are writing a typed vector
|
||||
If you get this assert you are writing a typed vector
|
||||
with elements that are not all the same type
|
||||
""")
|
||||
}
|
||||
@@ -757,7 +760,7 @@ public struct FlexBuffersWriter {
|
||||
}
|
||||
|
||||
if !fixed {
|
||||
write(value: count, byteWidth: byteWidth)
|
||||
write(value: UInt64(count), byteWidth: byteWidth)
|
||||
}
|
||||
|
||||
let vloc = _bb.writerIndex
|
||||
@@ -830,13 +833,14 @@ public struct FlexBuffersWriter {
|
||||
let key, value: Value
|
||||
}
|
||||
|
||||
stack[start...].withUnsafeMutableBytes { buffer in
|
||||
stack.withUnsafeMutableBytes(start: start) { buffer in
|
||||
var ptr = buffer.assumingMemoryBound(to: TwoValue.self)
|
||||
ptr.sort { a, b in
|
||||
let aMem = _bb.memory.advanced(by: numericCast(a.key.u))
|
||||
.assumingMemoryBound(to: CChar.self)
|
||||
let bMem = _bb.memory.advanced(by: numericCast(b.key.u))
|
||||
.assumingMemoryBound(to: CChar.self)
|
||||
|
||||
let comp = strcmp(aMem, bMem)
|
||||
if (comp == 0) && a != b { hasDuplicatedKeys = true }
|
||||
return comp < 0
|
||||
@@ -897,3 +901,129 @@ extension FlexBuffersWriter {
|
||||
return endMap(start: start)
|
||||
}
|
||||
}
|
||||
|
||||
fileprivate struct Stack: RandomAccessCollection {
|
||||
typealias Element = Value
|
||||
typealias Index = Int
|
||||
|
||||
private final class Storage {
|
||||
var memory: UnsafeMutableRawPointer
|
||||
|
||||
init(capacity: Int, alignment: Int) {
|
||||
memory = .allocate(byteCount: capacity, alignment: alignment)
|
||||
memset(memory, 0, capacity)
|
||||
}
|
||||
|
||||
deinit {
|
||||
memory.deallocate()
|
||||
}
|
||||
}
|
||||
|
||||
private static let initialCapacity = 10 &* MemoryLayout<Value>.stride
|
||||
private let storage: Storage
|
||||
private var capacity: Int
|
||||
private(set) var count: Int
|
||||
|
||||
var startIndex: Int {
|
||||
0
|
||||
}
|
||||
|
||||
var endIndex: Int {
|
||||
count
|
||||
}
|
||||
|
||||
init() {
|
||||
count = 0
|
||||
capacity = Self.initialCapacity
|
||||
|
||||
storage = Storage(
|
||||
capacity: capacity,
|
||||
alignment: MemoryLayout<Value>.alignment)
|
||||
}
|
||||
|
||||
@inline(__always)
|
||||
subscript(position: Int) -> Value {
|
||||
get {
|
||||
storage.memory.advanced(by: position &* MemoryLayout<Value>.stride)
|
||||
.assumingMemoryBound(to: Value.self).pointee
|
||||
}
|
||||
set {
|
||||
storage.memory.advanced(by: position &* MemoryLayout<Value>.stride)
|
||||
.assumingMemoryBound(to: Value.self).pointee = newValue
|
||||
}
|
||||
}
|
||||
|
||||
@inline(__always)
|
||||
mutating func popLast(_ val: Int) {
|
||||
count = if val < 0 {
|
||||
0
|
||||
} else {
|
||||
val
|
||||
}
|
||||
}
|
||||
|
||||
mutating func append(_ value: Value) {
|
||||
let writePosition = count &* MemoryLayout<Value>.stride
|
||||
if writePosition >= capacity {
|
||||
reallocate(writePosition: writePosition)
|
||||
}
|
||||
|
||||
storage.memory.advanced(by: writePosition).storeBytes(
|
||||
of: value,
|
||||
as: Value.self)
|
||||
count += 1
|
||||
}
|
||||
|
||||
mutating func removeAll(keepingCapacity keepCapacity: Bool = false) {
|
||||
count = 0
|
||||
if !keepCapacity {
|
||||
capacity = Self.initialCapacity
|
||||
storage.memory = UnsafeMutableRawPointer.allocate(
|
||||
byteCount: capacity,
|
||||
alignment: MemoryLayout<Value>.alignment)
|
||||
}
|
||||
memset(storage.memory, 0, capacity)
|
||||
}
|
||||
|
||||
@discardableResult
|
||||
mutating func withUnsafeMutableBytes<R>(
|
||||
start: Int,
|
||||
_ body: (UnsafeMutableRawBufferPointer) throws -> R) rethrows -> R
|
||||
{
|
||||
let startingPosition = start &* MemoryLayout<Value>.stride
|
||||
let pointer = storage.memory.advanced(by: startingPosition)
|
||||
return try body(UnsafeMutableRawBufferPointer(
|
||||
start: pointer,
|
||||
count: (count &* MemoryLayout<Value>.stride) &- startingPosition))
|
||||
}
|
||||
|
||||
@discardableResult
|
||||
mutating func withUnsafeMutableBytes<R>(
|
||||
_ body: (UnsafeMutableRawBufferPointer) throws
|
||||
-> R) rethrows -> R
|
||||
{
|
||||
return try body(UnsafeMutableRawBufferPointer(
|
||||
start: storage.memory,
|
||||
count: count &* MemoryLayout<Value>.stride))
|
||||
}
|
||||
|
||||
mutating private func reallocate(writePosition: Int) {
|
||||
while capacity <= writePosition {
|
||||
capacity = capacity << 1
|
||||
}
|
||||
|
||||
/// solution take from Apple-NIO
|
||||
capacity = capacity.convertToPowerofTwo
|
||||
|
||||
let newData = UnsafeMutableRawPointer.allocate(
|
||||
byteCount: capacity,
|
||||
alignment: MemoryLayout<Value>.alignment)
|
||||
memset(newData, 0, capacity)
|
||||
memcpy(
|
||||
newData,
|
||||
storage.memory,
|
||||
writePosition)
|
||||
storage.memory.deallocate()
|
||||
storage.memory = newData
|
||||
}
|
||||
}
|
||||
|
||||
@@ -60,7 +60,7 @@ struct _InternalByteBuffer {
|
||||
let newData = UnsafeMutableRawPointer.allocate(
|
||||
byteCount: capacity,
|
||||
alignment: alignment)
|
||||
memset(newData, 0, capacity &- writerSize)
|
||||
memset(newData, 0, capacity)
|
||||
memcpy(
|
||||
newData,
|
||||
memory,
|
||||
|
||||
+13
-17
@@ -52,6 +52,7 @@ cc_test(
|
||||
"monster_test.cpp",
|
||||
"monster_test.h",
|
||||
"monster_test_bfbs_generated.h",
|
||||
"cross_namespace_pack_test_generated.h",
|
||||
"namespace_test/namespace_test1_generated.h",
|
||||
"namespace_test/namespace_test2_generated.h",
|
||||
"native_inline_table_test_generated.h",
|
||||
@@ -78,9 +79,6 @@ cc_test(
|
||||
"vector_table_naked_ptr/vector_table_naked_ptr_generated.h",
|
||||
"vector_table_naked_ptr_test.h",
|
||||
"vector_table_naked_ptr_test.cpp",
|
||||
"test_vector_type.h",
|
||||
"cpp_vector_type_test.h",
|
||||
"cpp_vector_type_test.cpp",
|
||||
],
|
||||
copts = [
|
||||
"-DFLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE",
|
||||
@@ -139,7 +137,7 @@ cc_test(
|
||||
deps = [
|
||||
":alignment_test_cc_fbs",
|
||||
":arrays_test_cc_fbs",
|
||||
":cpp_vector_type_cc_fbs",
|
||||
":cross_namespace_pack_test_cc_fbs",
|
||||
":default_vectors_strings_test_cc_fbs",
|
||||
":monster_extra_cc_fbs",
|
||||
":monster_test_cc_fbs",
|
||||
@@ -265,6 +263,17 @@ flatbuffer_cc_library(
|
||||
],
|
||||
)
|
||||
|
||||
flatbuffer_cc_library(
|
||||
name = "cross_namespace_pack_test_cc_fbs",
|
||||
srcs = ["cross_namespace_pack_test.fbs"],
|
||||
flatc_args = [
|
||||
"--gen-object-api",
|
||||
"--gen-mutable",
|
||||
"--gen-compare",
|
||||
"--reflect-names",
|
||||
],
|
||||
)
|
||||
|
||||
flatbuffer_cc_library(
|
||||
name = "native_type_test_cc_fbs",
|
||||
srcs = ["native_type_test.fbs"],
|
||||
@@ -275,19 +284,6 @@ flatbuffer_cc_library(
|
||||
],
|
||||
)
|
||||
|
||||
flatbuffer_cc_library(
|
||||
name = "cpp_vector_type_cc_fbs",
|
||||
srcs = ["cpp_vector_type.fbs"],
|
||||
flatc_args = [
|
||||
"--gen-compare",
|
||||
"--gen-mutable",
|
||||
"--gen-object-api",
|
||||
"--reflect-names",
|
||||
"--cpp-include test_vector_type.h",
|
||||
"--cpp-vector-type ::flatbuffers::tests::CustomVector",
|
||||
],
|
||||
)
|
||||
|
||||
flatbuffer_cc_library(
|
||||
name = "alignment_test_cc_fbs",
|
||||
srcs = ["alignment_test.fbs"],
|
||||
|
||||
@@ -106,6 +106,9 @@
|
||||
<Compile Include="..\MyGame\Example\NestedStruct.cs">
|
||||
<Link>MyGame\Example\NestedStruct.cs</Link>
|
||||
</Compile>
|
||||
<Compile Include="..\MyGame\Example\LargeArrayStruct.cs">
|
||||
<Link>MyGame\Example\LargeArrayStruct.cs</Link>
|
||||
</Compile>
|
||||
<Compile Include="..\MyGame\Example\LongEnum.cs">
|
||||
<Link>MyGame\Example\LongEnum.cs</Link>
|
||||
</Compile>
|
||||
|
||||
@@ -922,7 +922,7 @@ def MonsterCreateInventoryVector(builder, data):
|
||||
return builder.EndVector()
|
||||
|
||||
def CreateInventoryVector(builder, data):
|
||||
MonsterCreateInventoryVector(builder, data)
|
||||
return MonsterCreateInventoryVector(builder, data)
|
||||
|
||||
def MonsterAddColor(builder, color):
|
||||
builder.PrependUint8Slot(6, color, 8)
|
||||
@@ -962,7 +962,7 @@ def MonsterCreateTest4Vector(builder, data):
|
||||
return builder.EndVector()
|
||||
|
||||
def CreateTest4Vector(builder, data):
|
||||
MonsterCreateTest4Vector(builder, data)
|
||||
return MonsterCreateTest4Vector(builder, data)
|
||||
|
||||
def MonsterAddTestarrayofstring(builder, testarrayofstring):
|
||||
builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
|
||||
@@ -980,7 +980,7 @@ def MonsterCreateTestarrayofstringVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateTestarrayofstringVector(builder, data):
|
||||
MonsterCreateTestarrayofstringVector(builder, data)
|
||||
return MonsterCreateTestarrayofstringVector(builder, data)
|
||||
|
||||
def MonsterAddTestarrayoftables(builder, testarrayoftables):
|
||||
builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
|
||||
@@ -998,7 +998,7 @@ def MonsterCreateTestarrayoftablesVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateTestarrayoftablesVector(builder, data):
|
||||
MonsterCreateTestarrayoftablesVector(builder, data)
|
||||
return MonsterCreateTestarrayoftablesVector(builder, data)
|
||||
|
||||
def MonsterAddEnemy(builder, enemy):
|
||||
builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
|
||||
@@ -1026,7 +1026,7 @@ def MonsterCreateTestnestedflatbufferVector(builder, data):
|
||||
return builder.EndVector()
|
||||
|
||||
def CreateTestnestedflatbufferVector(builder, data):
|
||||
MonsterCreateTestnestedflatbufferVector(builder, data)
|
||||
return MonsterCreateTestnestedflatbufferVector(builder, data)
|
||||
|
||||
def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
|
||||
builder.StartVector(1, len(bytes), 1)
|
||||
@@ -1115,7 +1115,7 @@ def MonsterCreateTestarrayofboolsVector(builder, data):
|
||||
return builder.EndVector()
|
||||
|
||||
def CreateTestarrayofboolsVector(builder, data):
|
||||
MonsterCreateTestarrayofboolsVector(builder, data)
|
||||
return MonsterCreateTestarrayofboolsVector(builder, data)
|
||||
|
||||
def MonsterAddTestf(builder, testf):
|
||||
builder.PrependFloat32Slot(25, testf, 3.14159)
|
||||
@@ -1151,7 +1151,7 @@ def MonsterCreateTestarrayofstring2Vector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateTestarrayofstring2Vector(builder, data):
|
||||
MonsterCreateTestarrayofstring2Vector(builder, data)
|
||||
return MonsterCreateTestarrayofstring2Vector(builder, data)
|
||||
|
||||
def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
|
||||
builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
|
||||
@@ -1173,7 +1173,7 @@ def MonsterCreateTestarrayofsortedstructVector(builder, data):
|
||||
return builder.EndVector()
|
||||
|
||||
def CreateTestarrayofsortedstructVector(builder, data):
|
||||
MonsterCreateTestarrayofsortedstructVector(builder, data)
|
||||
return MonsterCreateTestarrayofsortedstructVector(builder, data)
|
||||
|
||||
def MonsterAddFlex(builder, flex):
|
||||
builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
|
||||
@@ -1195,7 +1195,7 @@ def MonsterCreateFlexVector(builder, data):
|
||||
return builder.EndVector()
|
||||
|
||||
def CreateFlexVector(builder, data):
|
||||
MonsterCreateFlexVector(builder, data)
|
||||
return MonsterCreateFlexVector(builder, data)
|
||||
|
||||
def MonsterAddTest5(builder, test5):
|
||||
builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
|
||||
@@ -1217,7 +1217,7 @@ def MonsterCreateTest5Vector(builder, data):
|
||||
return builder.EndVector()
|
||||
|
||||
def CreateTest5Vector(builder, data):
|
||||
MonsterCreateTest5Vector(builder, data)
|
||||
return MonsterCreateTest5Vector(builder, data)
|
||||
|
||||
def MonsterAddVectorOfLongs(builder, vectorOfLongs):
|
||||
builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
|
||||
@@ -1239,7 +1239,7 @@ def MonsterCreateVectorOfLongsVector(builder, data):
|
||||
return builder.EndVector()
|
||||
|
||||
def CreateVectorOfLongsVector(builder, data):
|
||||
MonsterCreateVectorOfLongsVector(builder, data)
|
||||
return MonsterCreateVectorOfLongsVector(builder, data)
|
||||
|
||||
def MonsterAddVectorOfDoubles(builder, vectorOfDoubles):
|
||||
builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
|
||||
@@ -1261,7 +1261,7 @@ def MonsterCreateVectorOfDoublesVector(builder, data):
|
||||
return builder.EndVector()
|
||||
|
||||
def CreateVectorOfDoublesVector(builder, data):
|
||||
MonsterCreateVectorOfDoublesVector(builder, data)
|
||||
return MonsterCreateVectorOfDoublesVector(builder, data)
|
||||
|
||||
def MonsterAddParentNamespaceTest(builder, parentNamespaceTest):
|
||||
builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
|
||||
@@ -1285,7 +1285,7 @@ def MonsterCreateVectorOfReferrablesVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateVectorOfReferrablesVector(builder, data):
|
||||
MonsterCreateVectorOfReferrablesVector(builder, data)
|
||||
return MonsterCreateVectorOfReferrablesVector(builder, data)
|
||||
|
||||
def MonsterAddSingleWeakReference(builder, singleWeakReference):
|
||||
builder.PrependUint64Slot(36, singleWeakReference, 0)
|
||||
@@ -1313,7 +1313,7 @@ def MonsterCreateVectorOfWeakReferencesVector(builder, data):
|
||||
return builder.EndVector()
|
||||
|
||||
def CreateVectorOfWeakReferencesVector(builder, data):
|
||||
MonsterCreateVectorOfWeakReferencesVector(builder, data)
|
||||
return MonsterCreateVectorOfWeakReferencesVector(builder, data)
|
||||
|
||||
def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
|
||||
builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
|
||||
@@ -1331,7 +1331,7 @@ def MonsterCreateVectorOfStrongReferrablesVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateVectorOfStrongReferrablesVector(builder, data):
|
||||
MonsterCreateVectorOfStrongReferrablesVector(builder, data)
|
||||
return MonsterCreateVectorOfStrongReferrablesVector(builder, data)
|
||||
|
||||
def MonsterAddCoOwningReference(builder, coOwningReference):
|
||||
builder.PrependUint64Slot(39, coOwningReference, 0)
|
||||
@@ -1359,7 +1359,7 @@ def MonsterCreateVectorOfCoOwningReferencesVector(builder, data):
|
||||
return builder.EndVector()
|
||||
|
||||
def CreateVectorOfCoOwningReferencesVector(builder, data):
|
||||
MonsterCreateVectorOfCoOwningReferencesVector(builder, data)
|
||||
return MonsterCreateVectorOfCoOwningReferencesVector(builder, data)
|
||||
|
||||
def MonsterAddNonOwningReference(builder, nonOwningReference):
|
||||
builder.PrependUint64Slot(41, nonOwningReference, 0)
|
||||
@@ -1387,7 +1387,7 @@ def MonsterCreateVectorOfNonOwningReferencesVector(builder, data):
|
||||
return builder.EndVector()
|
||||
|
||||
def CreateVectorOfNonOwningReferencesVector(builder, data):
|
||||
MonsterCreateVectorOfNonOwningReferencesVector(builder, data)
|
||||
return MonsterCreateVectorOfNonOwningReferencesVector(builder, data)
|
||||
|
||||
def MonsterAddAnyUniqueType(builder, anyUniqueType):
|
||||
builder.PrependUint8Slot(43, anyUniqueType, 0)
|
||||
@@ -1433,7 +1433,7 @@ def MonsterCreateVectorOfEnumsVector(builder, data):
|
||||
return builder.EndVector()
|
||||
|
||||
def CreateVectorOfEnumsVector(builder, data):
|
||||
MonsterCreateVectorOfEnumsVector(builder, data)
|
||||
return MonsterCreateVectorOfEnumsVector(builder, data)
|
||||
|
||||
def MonsterAddSignedEnum(builder, signedEnum):
|
||||
builder.PrependInt8Slot(48, signedEnum, -1)
|
||||
@@ -1461,7 +1461,7 @@ def MonsterCreateTestrequirednestedflatbufferVector(builder, data):
|
||||
return builder.EndVector()
|
||||
|
||||
def CreateTestrequirednestedflatbufferVector(builder, data):
|
||||
MonsterCreateTestrequirednestedflatbufferVector(builder, data)
|
||||
return MonsterCreateTestrequirednestedflatbufferVector(builder, data)
|
||||
|
||||
def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
|
||||
builder.StartVector(1, len(bytes), 1)
|
||||
@@ -1486,7 +1486,7 @@ def MonsterCreateScalarKeySortedTablesVector(builder, data):
|
||||
return builder.CreateVectorOfTables(data)
|
||||
|
||||
def CreateScalarKeySortedTablesVector(builder, data):
|
||||
MonsterCreateScalarKeySortedTablesVector(builder, data)
|
||||
return MonsterCreateScalarKeySortedTablesVector(builder, data)
|
||||
|
||||
def MonsterAddNativeInline(builder, nativeInline):
|
||||
builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
|
||||
|
||||
@@ -238,7 +238,7 @@ def TypeAliasesCreateV8Vector(builder, data):
|
||||
return builder.EndVector()
|
||||
|
||||
def CreateV8Vector(builder, data):
|
||||
TypeAliasesCreateV8Vector(builder, data)
|
||||
return TypeAliasesCreateV8Vector(builder, data)
|
||||
|
||||
def TypeAliasesAddVf64(builder, vf64):
|
||||
builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
|
||||
@@ -260,7 +260,7 @@ def TypeAliasesCreateVf64Vector(builder, data):
|
||||
return builder.EndVector()
|
||||
|
||||
def CreateVf64Vector(builder, data):
|
||||
TypeAliasesCreateVf64Vector(builder, data)
|
||||
return TypeAliasesCreateVf64Vector(builder, data)
|
||||
|
||||
def TypeAliasesEnd(builder):
|
||||
return builder.EndObject()
|
||||
|
||||
@@ -214,7 +214,7 @@ def MonsterExtraCreateDvecVector(builder: flatbuffers.Builder, data: Iterable[An
|
||||
return builder.EndVector()
|
||||
|
||||
def CreateDvecVector(builder: flatbuffers.Builder, data: Iterable[Any]) -> int:
|
||||
MonsterExtraCreateDvecVector(builder, data)
|
||||
return MonsterExtraCreateDvecVector(builder, data)
|
||||
|
||||
def MonsterExtraAddFvec(builder: flatbuffers.Builder, fvec: int):
|
||||
builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0)
|
||||
@@ -236,7 +236,7 @@ def MonsterExtraCreateFvecVector(builder: flatbuffers.Builder, data: Iterable[An
|
||||
return builder.EndVector()
|
||||
|
||||
def CreateFvecVector(builder: flatbuffers.Builder, data: Iterable[Any]) -> int:
|
||||
MonsterExtraCreateFvecVector(builder, data)
|
||||
return MonsterExtraCreateFvecVector(builder, data)
|
||||
|
||||
def MonsterExtraEnd(builder: flatbuffers.Builder) -> int:
|
||||
return builder.EndObject()
|
||||
|
||||
@@ -28,6 +28,7 @@ ${test_dir}/../flatc -p -o ${gen_code_path} -I include_test monster_extra.fbs --
|
||||
${test_dir}/../flatc -p -o ${gen_code_path} -I include_test arrays_test.fbs --gen-object-api --python-typing
|
||||
${test_dir}/../flatc -p -o ${gen_code_path} -I include_test nested_union_test.fbs --gen-object-api --python-typing --python-decode-obj-api-strings
|
||||
${test_dir}/../flatc -p -o ${gen_code_path} -I include_test service_test.fbs --grpc --grpc-python-typed-handlers --python-typing --no-python-gen-numpy --gen-onefile
|
||||
${test_dir}/../flatc -p -o ${gen_code_path} union_name_test.fbs --gen-object-api
|
||||
|
||||
# Syntax: run_tests <interpreter> <benchmark vtable dedupes>
|
||||
# <benchmark read count> <benchmark build count>
|
||||
|
||||
Binary file not shown.
@@ -18,6 +18,14 @@ struct ArrayStruct{
|
||||
f:[int64:2];
|
||||
}
|
||||
|
||||
struct LargeArrayStruct {
|
||||
d:[ubyte:64];
|
||||
e:[float:64];
|
||||
f:[bool:64];
|
||||
g:[NestedStruct:64];
|
||||
h:[TestEnum:64];
|
||||
}
|
||||
|
||||
table ArrayTable{
|
||||
a:ArrayStruct;
|
||||
}
|
||||
|
||||
@@ -59,6 +59,37 @@
|
||||
},
|
||||
"additionalProperties" : false
|
||||
},
|
||||
"MyGame_Example_LargeArrayStruct" : {
|
||||
"type" : "object",
|
||||
"properties" : {
|
||||
"d" : {
|
||||
"type" : "array", "items" : {"type" : "integer", "minimum" : 0, "maximum" :255},
|
||||
"minItems": 64,
|
||||
"maxItems": 64
|
||||
},
|
||||
"e" : {
|
||||
"type" : "array", "items" : {"type" : "number"},
|
||||
"minItems": 64,
|
||||
"maxItems": 64
|
||||
},
|
||||
"f" : {
|
||||
"type" : "array", "items" : {"type" : "boolean"},
|
||||
"minItems": 64,
|
||||
"maxItems": 64
|
||||
},
|
||||
"g" : {
|
||||
"type" : "array", "items" : {"$ref" : "#/definitions/MyGame_Example_NestedStruct"},
|
||||
"minItems": 64,
|
||||
"maxItems": 64
|
||||
},
|
||||
"h" : {
|
||||
"type" : "array", "items" : {"$ref" : "#/definitions/MyGame_Example_TestEnum"},
|
||||
"minItems": 64,
|
||||
"maxItems": 64
|
||||
}
|
||||
},
|
||||
"additionalProperties" : false
|
||||
},
|
||||
"MyGame_Example_ArrayTable" : {
|
||||
"type" : "object",
|
||||
"properties" : {
|
||||
|
||||
+13
-11
@@ -1,16 +1,18 @@
|
||||
// Automatically generated by the Flatbuffers compiler. Do not modify.
|
||||
// @generated
|
||||
pub mod my_game {
|
||||
use super::*;
|
||||
pub mod example {
|
||||
use super::*;
|
||||
mod test_enum_generated;
|
||||
pub use self::test_enum_generated::*;
|
||||
mod nested_struct_generated;
|
||||
pub use self::nested_struct_generated::*;
|
||||
mod array_struct_generated;
|
||||
pub use self::array_struct_generated::*;
|
||||
mod array_table_generated;
|
||||
pub use self::array_table_generated::*;
|
||||
} // example
|
||||
pub mod example {
|
||||
use super::*;
|
||||
mod test_enum_generated;
|
||||
pub use self::test_enum_generated::*;
|
||||
mod nested_struct_generated;
|
||||
pub use self::nested_struct_generated::*;
|
||||
mod array_struct_generated;
|
||||
pub use self::array_struct_generated::*;
|
||||
mod large_array_struct_generated;
|
||||
pub use self::large_array_struct_generated::*;
|
||||
mod array_table_generated;
|
||||
pub use self::array_table_generated::*;
|
||||
} // example
|
||||
} // my_game
|
||||
|
||||
@@ -2,50 +2,60 @@
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
use super::*;
|
||||
|
||||
// struct ArrayStruct, aligned to 8
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
pub struct ArrayStruct(pub [u8; 160]);
|
||||
impl Default for ArrayStruct {
|
||||
fn default() -> Self {
|
||||
Self([0; 160])
|
||||
}
|
||||
|
||||
impl Default for ArrayStruct {
|
||||
fn default() -> Self {
|
||||
Self([0; 160])
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for ArrayStruct {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
f.debug_struct("ArrayStruct")
|
||||
.field("a", &self.a())
|
||||
.field("b", &self.b())
|
||||
.field("c", &self.c())
|
||||
.field("d", &self.d())
|
||||
.field("e", &self.e())
|
||||
.field("f", &self.f())
|
||||
.finish()
|
||||
}
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
f.debug_struct("ArrayStruct")
|
||||
.field("a", &self.a())
|
||||
.field("b", &self.b())
|
||||
.field("c", &self.c())
|
||||
.field("d", &self.d())
|
||||
.field("e", &self.e())
|
||||
.field("f", &self.f())
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for ArrayStruct {}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for ArrayStruct {
|
||||
type Inner = &'a ArrayStruct;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { <&'a ArrayStruct>::follow(buf, loc) }
|
||||
}
|
||||
type Inner = &'a ArrayStruct;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { <&'a ArrayStruct>::follow(buf, loc) }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for &'a ArrayStruct {
|
||||
type Inner = &'a ArrayStruct;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { ::flatbuffers::follow_cast_ref::<ArrayStruct>(buf, loc) }
|
||||
}
|
||||
type Inner = &'a ArrayStruct;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { ::flatbuffers::follow_cast_ref::<ArrayStruct>(buf, loc) }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'b> ::flatbuffers::Push for ArrayStruct {
|
||||
type Output = ArrayStruct;
|
||||
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
let src = unsafe { ::core::slice::from_raw_parts(self as *const ArrayStruct as *const u8, <Self as ::flatbuffers::Push>::size()) };
|
||||
dst.copy_from_slice(src);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn alignment() -> ::flatbuffers::PushAlignment {
|
||||
::flatbuffers::PushAlignment::new(8)
|
||||
@@ -53,207 +63,219 @@ impl<'b> ::flatbuffers::Push for ArrayStruct {
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Verifiable for ArrayStruct {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.in_buffer::<Self>(pos)
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.in_buffer::<Self>(pos)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ArrayStruct {
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn new(
|
||||
a: f32,
|
||||
b: &[i32; 15],
|
||||
c: i8,
|
||||
d: &[NestedStruct; 2],
|
||||
e: i32,
|
||||
f: &[i64; 2],
|
||||
) -> Self {
|
||||
let mut s = Self([0; 160]);
|
||||
s.set_a(a);
|
||||
s.set_b(b);
|
||||
s.set_c(c);
|
||||
s.set_d(d);
|
||||
s.set_e(e);
|
||||
s.set_f(f);
|
||||
s
|
||||
}
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.Example.ArrayStruct"
|
||||
}
|
||||
|
||||
pub fn a(&self) -> f32 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[0..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_a(&mut self, x: f32) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[0..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn new(
|
||||
a: f32,
|
||||
b: &[i32; 15],
|
||||
c: i8,
|
||||
d: &[NestedStruct; 2],
|
||||
e: i32,
|
||||
f: &[i64; 2],
|
||||
) -> Self {
|
||||
let mut s = Self([0; 160]);
|
||||
s.set_a(a);
|
||||
s.set_b(b);
|
||||
s.set_c(c);
|
||||
s.set_d(d);
|
||||
s.set_e(e);
|
||||
s.set_f(f);
|
||||
s
|
||||
}
|
||||
}
|
||||
|
||||
pub fn b(&'a self) -> ::flatbuffers::Array<'a, i32, 15> {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
use ::flatbuffers::Follow;
|
||||
unsafe { ::flatbuffers::Array::follow(&self.0, 4) }
|
||||
}
|
||||
|
||||
pub fn set_b(&mut self, items: &[i32; 15]) {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 4, items) };
|
||||
}
|
||||
|
||||
pub fn c(&self) -> i8 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<i8 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[64..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<i8 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_c(&mut self, x: i8) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[64..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<i8 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.Example.ArrayStruct"
|
||||
}
|
||||
}
|
||||
|
||||
pub fn d(&'a self) -> ::flatbuffers::Array<'a, NestedStruct, 2> {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
use ::flatbuffers::Follow;
|
||||
unsafe { ::flatbuffers::Array::follow(&self.0, 72) }
|
||||
}
|
||||
|
||||
pub fn set_d(&mut self, x: &[NestedStruct; 2]) {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy(
|
||||
x.as_ptr() as *const u8,
|
||||
self.0.as_mut_ptr().add(72),
|
||||
64,
|
||||
);
|
||||
pub fn a(&self) -> f32 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[0..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
pub fn e(&self) -> i32 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<i32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[136..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_e(&mut self, x: i32) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[136..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
pub fn set_a(&mut self, x: f32) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[0..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn f(&'a self) -> ::flatbuffers::Array<'a, i64, 2> {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
use ::flatbuffers::Follow;
|
||||
unsafe { ::flatbuffers::Array::follow(&self.0, 144) }
|
||||
}
|
||||
|
||||
pub fn set_f(&mut self, items: &[i64; 2]) {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 144, items) };
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> ArrayStructT {
|
||||
ArrayStructT {
|
||||
a: self.a(),
|
||||
b: self.b().into(),
|
||||
c: self.c(),
|
||||
d: { let d = self.d(); ::flatbuffers::array_init(|i| d.get(i).unpack()) },
|
||||
e: self.e(),
|
||||
f: self.f().into(),
|
||||
pub fn b(&'a self) -> ::flatbuffers::Array<'a, i32, 15> {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
use ::flatbuffers::Follow;
|
||||
unsafe { ::flatbuffers::Array::follow(&self.0, 4) }
|
||||
}
|
||||
|
||||
pub fn set_b(&mut self, items: &[i32; 15]) {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 4, items) };
|
||||
}
|
||||
|
||||
pub fn c(&self) -> i8 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<i8 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[64..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<i8 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_c(&mut self, x: i8) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[64..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<i8 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn d(&'a self) -> ::flatbuffers::Array<'a, NestedStruct, 2> {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
use ::flatbuffers::Follow;
|
||||
unsafe { ::flatbuffers::Array::follow(&self.0, 72) }
|
||||
}
|
||||
|
||||
pub fn set_d(&mut self, x: &[NestedStruct; 2]) {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy(
|
||||
x.as_ptr() as *const u8,
|
||||
self.0.as_mut_ptr().add(72),
|
||||
64,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn e(&self) -> i32 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<i32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[136..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_e(&mut self, x: i32) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[136..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn f(&'a self) -> ::flatbuffers::Array<'a, i64, 2> {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
use ::flatbuffers::Follow;
|
||||
unsafe { ::flatbuffers::Array::follow(&self.0, 144) }
|
||||
}
|
||||
|
||||
pub fn set_f(&mut self, items: &[i64; 2]) {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 144, items) };
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> ArrayStructT {
|
||||
ArrayStructT {
|
||||
a: self.a(),
|
||||
b: self.b().into(),
|
||||
c: self.c(),
|
||||
d: { let d = self.d(); ::flatbuffers::array_init(|i| d.get(i).unpack()) },
|
||||
e: self.e(),
|
||||
f: self.f().into(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct ArrayStructT {
|
||||
pub a: f32,
|
||||
pub b: [i32; 15],
|
||||
pub c: i8,
|
||||
pub d: [NestedStructT; 2],
|
||||
pub e: i32,
|
||||
pub f: [i64; 2],
|
||||
pub a: f32,
|
||||
pub b: [i32; 15],
|
||||
pub c: i8,
|
||||
pub d: [NestedStructT; 2],
|
||||
pub e: i32,
|
||||
pub f: [i64; 2],
|
||||
}
|
||||
impl ArrayStructT {
|
||||
pub fn pack(&self) -> ArrayStruct {
|
||||
ArrayStruct::new(
|
||||
self.a,
|
||||
&self.b,
|
||||
self.c,
|
||||
&::flatbuffers::array_init(|i| self.d[i].pack()),
|
||||
self.e,
|
||||
&self.f,
|
||||
)
|
||||
}
|
||||
impl Default for ArrayStructT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
a: 0.0,
|
||||
b: [0; 15],
|
||||
c: 0,
|
||||
d: ::flatbuffers::array_init(|_| Default::default()),
|
||||
e: 0,
|
||||
f: [0; 2],
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ArrayStructT {
|
||||
pub fn pack(&self) -> ArrayStruct {
|
||||
ArrayStruct::new(
|
||||
self.a,
|
||||
&self.b,
|
||||
self.c,
|
||||
&::flatbuffers::array_init(|i| self.d[i].pack()),
|
||||
self.e,
|
||||
&self.f,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,208 +2,226 @@
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
use super::*;
|
||||
pub enum ArrayTableOffset {}
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
|
||||
pub enum ArrayTableOffset {}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
pub struct ArrayTable<'a> {
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for ArrayTable<'a> {
|
||||
type Inner = ArrayTable<'a>;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
type Inner = ArrayTable<'a>;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ArrayTable<'a> {
|
||||
pub const VT_A: ::flatbuffers::VOffsetT = 4;
|
||||
pub const VT_A: ::flatbuffers::VOffsetT = 4;
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.Example.ArrayTable"
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
ArrayTable { _tab: table }
|
||||
}
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args ArrayTableArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<ArrayTable<'bldr>> {
|
||||
let mut builder = ArrayTableBuilder::new(_fbb);
|
||||
if let Some(x) = args.a { builder.add_a(x); }
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> ArrayTableT {
|
||||
let a = self.a().map(|x| {
|
||||
x.unpack()
|
||||
});
|
||||
ArrayTableT {
|
||||
a,
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.Example.ArrayTable"
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn a(&self) -> Option<&'a ArrayStruct> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<ArrayStruct>(ArrayTable::VT_A, None)}
|
||||
}
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
ArrayTable { _tab: table }
|
||||
}
|
||||
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args ArrayTableArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<ArrayTable<'bldr>> {
|
||||
let mut builder = ArrayTableBuilder::new(_fbb);
|
||||
if let Some(x) = args.a { builder.add_a(x); }
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> ArrayTableT {
|
||||
let a = self.a().map(|x| {
|
||||
x.unpack()
|
||||
});
|
||||
ArrayTableT {
|
||||
a,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn a(&self) -> Option<&'a ArrayStruct> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<ArrayStruct>(ArrayTable::VT_A, None)}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Verifiable for ArrayTable<'_> {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<ArrayStruct>("a", Self::VT_A, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<ArrayStruct>("a", Self::VT_A, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub struct ArrayTableArgs<'a> {
|
||||
pub a: Option<&'a ArrayStruct>,
|
||||
}
|
||||
|
||||
impl<'a> Default for ArrayTableArgs<'a> {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
ArrayTableArgs {
|
||||
a: None,
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
ArrayTableArgs {
|
||||
a: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct ArrayTableBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
}
|
||||
|
||||
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ArrayTableBuilder<'a, 'b, A> {
|
||||
#[inline]
|
||||
pub fn add_a(&mut self, a: &ArrayStruct) {
|
||||
self.fbb_.push_slot_always::<&ArrayStruct>(ArrayTable::VT_A, a);
|
||||
}
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ArrayTableBuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
ArrayTableBuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
#[inline]
|
||||
pub fn add_a(&mut self, a: &ArrayStruct) {
|
||||
self.fbb_.push_slot_always::<&ArrayStruct>(ArrayTable::VT_A, a);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ArrayTableBuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
ArrayTableBuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<ArrayTable<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<ArrayTable<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for ArrayTable<'_> {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("ArrayTable");
|
||||
ds.field("a", &self.a());
|
||||
ds.finish()
|
||||
}
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("ArrayTable");
|
||||
ds.field("a", &self.a());
|
||||
ds.finish()
|
||||
}
|
||||
}
|
||||
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct ArrayTableT {
|
||||
pub a: Option<ArrayStructT>,
|
||||
pub a: Option<ArrayStructT>,
|
||||
}
|
||||
|
||||
impl Default for ArrayTableT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
a: None,
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
a: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ArrayTableT {
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<ArrayTable<'b>> {
|
||||
let a_tmp = self.a.as_ref().map(|x| x.pack());
|
||||
let a = a_tmp.as_ref();
|
||||
ArrayTable::create(_fbb, &ArrayTableArgs{
|
||||
a,
|
||||
})
|
||||
}
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<ArrayTable<'b>> {
|
||||
let a_tmp = self.a.as_ref().map(|x| x.pack());
|
||||
let a = a_tmp.as_ref();
|
||||
ArrayTable::create(_fbb, &ArrayTableArgs{
|
||||
a,
|
||||
})
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
|
||||
/// Verifies that a buffer of bytes contains a `ArrayTable`
|
||||
/// and returns it.
|
||||
/// Note that verification is still experimental and may not
|
||||
/// catch every error, or be maximally performant. For the
|
||||
/// previous, unchecked, behavior use
|
||||
/// `root_as_array_table_unchecked`.
|
||||
pub fn root_as_array_table(buf: &[u8]) -> Result<ArrayTable<'_>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::root::<ArrayTable>(buf)
|
||||
}
|
||||
#[inline]
|
||||
pub fn root_as_array_table(buf: &[u8]) -> Result<ArrayTable<'_>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::root::<ArrayTable>(buf)
|
||||
}
|
||||
|
||||
/// Verifies that a buffer of bytes contains a size prefixed
|
||||
/// `ArrayTable` and returns it.
|
||||
/// Note that verification is still experimental and may not
|
||||
/// catch every error, or be maximally performant. For the
|
||||
/// previous, unchecked, behavior use
|
||||
/// `size_prefixed_root_as_array_table_unchecked`.
|
||||
pub fn size_prefixed_root_as_array_table(buf: &[u8]) -> Result<ArrayTable<'_>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::size_prefixed_root::<ArrayTable>(buf)
|
||||
}
|
||||
#[inline]
|
||||
pub fn size_prefixed_root_as_array_table(buf: &[u8]) -> Result<ArrayTable<'_>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::size_prefixed_root::<ArrayTable>(buf)
|
||||
}
|
||||
|
||||
/// Verifies, with the given options, that a buffer of bytes
|
||||
/// contains a `ArrayTable` and returns it.
|
||||
/// Note that verification is still experimental and may not
|
||||
/// catch every error, or be maximally performant. For the
|
||||
/// previous, unchecked, behavior use
|
||||
/// `root_as_array_table_unchecked`.
|
||||
pub fn root_as_array_table_with_opts<'b, 'o>(
|
||||
opts: &'o ::flatbuffers::VerifierOptions,
|
||||
buf: &'b [u8],
|
||||
) -> Result<ArrayTable<'b>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::root_with_opts::<ArrayTable<'b>>(opts, buf)
|
||||
}
|
||||
#[inline]
|
||||
pub fn root_as_array_table_with_opts<'b, 'o>(
|
||||
opts: &'o ::flatbuffers::VerifierOptions,
|
||||
buf: &'b [u8],
|
||||
) -> Result<ArrayTable<'b>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::root_with_opts::<ArrayTable<'b>>(opts, buf)
|
||||
}
|
||||
|
||||
/// Verifies, with the given verifier options, that a buffer of
|
||||
/// bytes contains a size prefixed `ArrayTable` and returns
|
||||
/// it. Note that verification is still experimental and may not
|
||||
/// catch every error, or be maximally performant. For the
|
||||
/// previous, unchecked, behavior use
|
||||
/// `root_as_array_table_unchecked`.
|
||||
pub fn size_prefixed_root_as_array_table_with_opts<'b, 'o>(
|
||||
opts: &'o ::flatbuffers::VerifierOptions,
|
||||
buf: &'b [u8],
|
||||
) -> Result<ArrayTable<'b>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::size_prefixed_root_with_opts::<ArrayTable<'b>>(opts, buf)
|
||||
}
|
||||
#[inline]
|
||||
pub fn size_prefixed_root_as_array_table_with_opts<'b, 'o>(
|
||||
opts: &'o ::flatbuffers::VerifierOptions,
|
||||
buf: &'b [u8],
|
||||
) -> Result<ArrayTable<'b>, ::flatbuffers::InvalidFlatbuffer> {
|
||||
::flatbuffers::size_prefixed_root_with_opts::<ArrayTable<'b>>(opts, buf)
|
||||
}
|
||||
|
||||
/// Assumes, without verification, that a buffer of bytes contains a ArrayTable and returns it.
|
||||
/// # Safety
|
||||
/// Callers must trust the given bytes do indeed contain a valid `ArrayTable`.
|
||||
pub unsafe fn root_as_array_table_unchecked(buf: &[u8]) -> ArrayTable<'_> {
|
||||
unsafe { ::flatbuffers::root_unchecked::<ArrayTable>(buf) }
|
||||
}
|
||||
#[inline]
|
||||
pub unsafe fn root_as_array_table_unchecked(buf: &[u8]) -> ArrayTable<'_> {
|
||||
unsafe { ::flatbuffers::root_unchecked::<ArrayTable>(buf) }
|
||||
}
|
||||
|
||||
/// Assumes, without verification, that a buffer of bytes contains a size prefixed ArrayTable and returns it.
|
||||
/// # Safety
|
||||
/// Callers must trust the given bytes do indeed contain a valid size prefixed `ArrayTable`.
|
||||
#[inline]
|
||||
pub unsafe fn size_prefixed_root_as_array_table_unchecked(buf: &[u8]) -> ArrayTable<'_> {
|
||||
unsafe { ::flatbuffers::size_prefixed_root_unchecked::<ArrayTable>(buf) }
|
||||
unsafe { ::flatbuffers::size_prefixed_root_unchecked::<ArrayTable>(buf) }
|
||||
}
|
||||
|
||||
pub const ARRAY_TABLE_IDENTIFIER: &str = "ARRT";
|
||||
|
||||
#[inline]
|
||||
pub fn array_table_buffer_has_identifier(buf: &[u8]) -> bool {
|
||||
::flatbuffers::buffer_has_identifier(buf, ARRAY_TABLE_IDENTIFIER, false)
|
||||
::flatbuffers::buffer_has_identifier(buf, ARRAY_TABLE_IDENTIFIER, false)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn array_table_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool {
|
||||
::flatbuffers::buffer_has_identifier(buf, ARRAY_TABLE_IDENTIFIER, true)
|
||||
::flatbuffers::buffer_has_identifier(buf, ARRAY_TABLE_IDENTIFIER, true)
|
||||
}
|
||||
|
||||
pub const ARRAY_TABLE_EXTENSION: &str = "mon";
|
||||
@@ -211,11 +229,15 @@ pub const ARRAY_TABLE_EXTENSION: &str = "mon";
|
||||
#[inline]
|
||||
pub fn finish_array_table_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
|
||||
fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
root: ::flatbuffers::WIPOffset<ArrayTable<'a>>) {
|
||||
fbb.finish(root, Some(ARRAY_TABLE_IDENTIFIER));
|
||||
root: ::flatbuffers::WIPOffset<ArrayTable<'a>>
|
||||
) {
|
||||
fbb.finish(root, Some(ARRAY_TABLE_IDENTIFIER));
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn finish_size_prefixed_array_table_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset<ArrayTable<'a>>) {
|
||||
fbb.finish_size_prefixed(root, Some(ARRAY_TABLE_IDENTIFIER));
|
||||
pub fn finish_size_prefixed_array_table_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
|
||||
fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
root: ::flatbuffers::WIPOffset<ArrayTable<'a>>
|
||||
) {
|
||||
fbb.finish_size_prefixed(root, Some(ARRAY_TABLE_IDENTIFIER));
|
||||
}
|
||||
|
||||
@@ -2,48 +2,58 @@
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
use super::*;
|
||||
|
||||
// struct NestedStruct, aligned to 8
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
pub struct NestedStruct(pub [u8; 32]);
|
||||
impl Default for NestedStruct {
|
||||
fn default() -> Self {
|
||||
Self([0; 32])
|
||||
}
|
||||
|
||||
impl Default for NestedStruct {
|
||||
fn default() -> Self {
|
||||
Self([0; 32])
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for NestedStruct {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
f.debug_struct("NestedStruct")
|
||||
.field("a", &self.a())
|
||||
.field("b", &self.b())
|
||||
.field("c", &self.c())
|
||||
.field("d", &self.d())
|
||||
.finish()
|
||||
}
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
f.debug_struct("NestedStruct")
|
||||
.field("a", &self.a())
|
||||
.field("b", &self.b())
|
||||
.field("c", &self.c())
|
||||
.field("d", &self.d())
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for NestedStruct {}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for NestedStruct {
|
||||
type Inner = &'a NestedStruct;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { <&'a NestedStruct>::follow(buf, loc) }
|
||||
}
|
||||
type Inner = &'a NestedStruct;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { <&'a NestedStruct>::follow(buf, loc) }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for &'a NestedStruct {
|
||||
type Inner = &'a NestedStruct;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { ::flatbuffers::follow_cast_ref::<NestedStruct>(buf, loc) }
|
||||
}
|
||||
type Inner = &'a NestedStruct;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { ::flatbuffers::follow_cast_ref::<NestedStruct>(buf, loc) }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'b> ::flatbuffers::Push for NestedStruct {
|
||||
type Output = NestedStruct;
|
||||
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
let src = unsafe { ::core::slice::from_raw_parts(self as *const NestedStruct as *const u8, <Self as ::flatbuffers::Push>::size()) };
|
||||
dst.copy_from_slice(src);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn alignment() -> ::flatbuffers::PushAlignment {
|
||||
::flatbuffers::PushAlignment::new(8)
|
||||
@@ -51,139 +61,149 @@ impl<'b> ::flatbuffers::Push for NestedStruct {
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Verifiable for NestedStruct {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.in_buffer::<Self>(pos)
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.in_buffer::<Self>(pos)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> NestedStruct {
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn new(
|
||||
a: &[i32; 2],
|
||||
b: TestEnum,
|
||||
c: &[TestEnum; 2],
|
||||
d: &[i64; 2],
|
||||
) -> Self {
|
||||
let mut s = Self([0; 32]);
|
||||
s.set_a(a);
|
||||
s.set_b(b);
|
||||
s.set_c(c);
|
||||
s.set_d(d);
|
||||
s
|
||||
}
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.Example.NestedStruct"
|
||||
}
|
||||
|
||||
pub fn a(&'a self) -> ::flatbuffers::Array<'a, i32, 2> {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
use ::flatbuffers::Follow;
|
||||
unsafe { ::flatbuffers::Array::follow(&self.0, 0) }
|
||||
}
|
||||
|
||||
pub fn set_a(&mut self, items: &[i32; 2]) {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 0, items) };
|
||||
}
|
||||
|
||||
pub fn b(&self) -> TestEnum {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<TestEnum as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[8..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<TestEnum as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_b(&mut self, x: TestEnum) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[8..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<TestEnum as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn new(
|
||||
a: &[i32; 2],
|
||||
b: TestEnum,
|
||||
c: &[TestEnum; 2],
|
||||
d: &[i64; 2],
|
||||
) -> Self {
|
||||
let mut s = Self([0; 32]);
|
||||
s.set_a(a);
|
||||
s.set_b(b);
|
||||
s.set_c(c);
|
||||
s.set_d(d);
|
||||
s
|
||||
}
|
||||
}
|
||||
|
||||
pub fn c(&'a self) -> ::flatbuffers::Array<'a, TestEnum, 2> {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
use ::flatbuffers::Follow;
|
||||
unsafe { ::flatbuffers::Array::follow(&self.0, 9) }
|
||||
}
|
||||
|
||||
pub fn set_c(&mut self, x: &[TestEnum; 2]) {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy(
|
||||
x.as_ptr() as *const u8,
|
||||
self.0.as_mut_ptr().add(9),
|
||||
2,
|
||||
);
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.Example.NestedStruct"
|
||||
}
|
||||
}
|
||||
|
||||
pub fn d(&'a self) -> ::flatbuffers::Array<'a, i64, 2> {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
use ::flatbuffers::Follow;
|
||||
unsafe { ::flatbuffers::Array::follow(&self.0, 16) }
|
||||
}
|
||||
|
||||
pub fn set_d(&mut self, items: &[i64; 2]) {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 16, items) };
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> NestedStructT {
|
||||
NestedStructT {
|
||||
a: self.a().into(),
|
||||
b: self.b(),
|
||||
c: self.c().into(),
|
||||
d: self.d().into(),
|
||||
pub fn a(&'a self) -> ::flatbuffers::Array<'a, i32, 2> {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
use ::flatbuffers::Follow;
|
||||
unsafe { ::flatbuffers::Array::follow(&self.0, 0) }
|
||||
}
|
||||
|
||||
pub fn set_a(&mut self, items: &[i32; 2]) {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 0, items) };
|
||||
}
|
||||
|
||||
pub fn b(&self) -> TestEnum {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<TestEnum as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[8..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<TestEnum as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_b(&mut self, x: TestEnum) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[8..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<TestEnum as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn c(&'a self) -> ::flatbuffers::Array<'a, TestEnum, 2> {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
use ::flatbuffers::Follow;
|
||||
unsafe { ::flatbuffers::Array::follow(&self.0, 9) }
|
||||
}
|
||||
|
||||
pub fn set_c(&mut self, x: &[TestEnum; 2]) {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy(
|
||||
x.as_ptr() as *const u8,
|
||||
self.0.as_mut_ptr().add(9),
|
||||
2,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn d(&'a self) -> ::flatbuffers::Array<'a, i64, 2> {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
use ::flatbuffers::Follow;
|
||||
unsafe { ::flatbuffers::Array::follow(&self.0, 16) }
|
||||
}
|
||||
|
||||
pub fn set_d(&mut self, items: &[i64; 2]) {
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid array in this slot
|
||||
unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 16, items) };
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> NestedStructT {
|
||||
NestedStructT {
|
||||
a: self.a().into(),
|
||||
b: self.b(),
|
||||
c: self.c().into(),
|
||||
d: self.d().into(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct NestedStructT {
|
||||
pub a: [i32; 2],
|
||||
pub b: TestEnum,
|
||||
pub c: [TestEnum; 2],
|
||||
pub d: [i64; 2],
|
||||
pub a: [i32; 2],
|
||||
pub b: TestEnum,
|
||||
pub c: [TestEnum; 2],
|
||||
pub d: [i64; 2],
|
||||
}
|
||||
impl NestedStructT {
|
||||
pub fn pack(&self) -> NestedStruct {
|
||||
NestedStruct::new(
|
||||
&self.a,
|
||||
self.b,
|
||||
&self.c,
|
||||
&self.d,
|
||||
)
|
||||
}
|
||||
impl Default for NestedStructT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
a: [0; 2],
|
||||
b: TestEnum::A,
|
||||
c: ::flatbuffers::array_init(|_| Default::default()),
|
||||
d: [0; 2],
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl NestedStructT {
|
||||
pub fn pack(&self) -> NestedStruct {
|
||||
NestedStruct::new(
|
||||
&self.a,
|
||||
self.b,
|
||||
&self.c,
|
||||
&self.d,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,64 +2,73 @@
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
use super::*;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MIN_TEST_ENUM: i8 = 0;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MAX_TEST_ENUM: i8 = 2;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
#[allow(non_camel_case_types)]
|
||||
pub const ENUM_VALUES_TEST_ENUM: [TestEnum; 3] = [
|
||||
TestEnum::A,
|
||||
TestEnum::B,
|
||||
TestEnum::C,
|
||||
TestEnum::A,
|
||||
TestEnum::B,
|
||||
TestEnum::C,
|
||||
];
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
|
||||
#[repr(transparent)]
|
||||
pub struct TestEnum(pub i8);
|
||||
|
||||
#[allow(non_upper_case_globals)]
|
||||
impl TestEnum {
|
||||
pub const A: Self = Self(0);
|
||||
pub const B: Self = Self(1);
|
||||
pub const C: Self = Self(2);
|
||||
pub const A: Self = Self(0);
|
||||
pub const B: Self = Self(1);
|
||||
pub const C: Self = Self(2);
|
||||
|
||||
pub const ENUM_MIN: i8 = 0;
|
||||
pub const ENUM_MAX: i8 = 2;
|
||||
pub const ENUM_VALUES: &'static [Self] = &[
|
||||
Self::A,
|
||||
Self::B,
|
||||
Self::C,
|
||||
];
|
||||
/// Returns the variant's name or "" if unknown.
|
||||
pub fn variant_name(self) -> Option<&'static str> {
|
||||
match self {
|
||||
Self::A => Some("A"),
|
||||
Self::B => Some("B"),
|
||||
Self::C => Some("C"),
|
||||
_ => None,
|
||||
pub const ENUM_MIN: i8 = 0;
|
||||
pub const ENUM_MAX: i8 = 2;
|
||||
pub const ENUM_VALUES: &'static [Self] = &[
|
||||
Self::A,
|
||||
Self::B,
|
||||
Self::C,
|
||||
];
|
||||
|
||||
/// Returns the variant's name or "" if unknown.
|
||||
pub fn variant_name(self) -> Option<&'static str> {
|
||||
match self {
|
||||
Self::A => Some("A"),
|
||||
Self::B => Some("B"),
|
||||
Self::C => Some("C"),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for TestEnum {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
if let Some(name) = self.variant_name() {
|
||||
f.write_str(name)
|
||||
} else {
|
||||
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
if let Some(name) = self.variant_name() {
|
||||
f.write_str(name)
|
||||
} else {
|
||||
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for TestEnum {
|
||||
type Inner = Self;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
let b = unsafe { ::flatbuffers::read_scalar_at::<i8>(buf, loc) };
|
||||
Self(b)
|
||||
}
|
||||
type Inner = Self;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
let b = unsafe { ::flatbuffers::read_scalar_at::<i8>(buf, loc) };
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Push for TestEnum {
|
||||
type Output = TestEnum;
|
||||
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
unsafe { ::flatbuffers::emplace_scalar::<i8>(dst, self.0) };
|
||||
@@ -67,26 +76,28 @@ impl ::flatbuffers::Push for TestEnum {
|
||||
}
|
||||
|
||||
impl ::flatbuffers::EndianScalar for TestEnum {
|
||||
type Scalar = i8;
|
||||
#[inline]
|
||||
fn to_little_endian(self) -> i8 {
|
||||
self.0.to_le()
|
||||
}
|
||||
#[inline]
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
fn from_little_endian(v: i8) -> Self {
|
||||
let b = i8::from_le(v);
|
||||
Self(b)
|
||||
}
|
||||
type Scalar = i8;
|
||||
|
||||
#[inline]
|
||||
fn to_little_endian(self) -> i8 {
|
||||
self.0.to_le()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
fn from_little_endian(v: i8) -> Self {
|
||||
let b = i8::from_le(v);
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Verifiable for TestEnum {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
i8::run_verifier(v, pos)
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
i8::run_verifier(v, pos)
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for TestEnum {}
|
||||
|
||||
@@ -1,31 +0,0 @@
|
||||
native_include "bigfoot_ref_test_impl.h";
|
||||
|
||||
namespace BigfootRefTestNS;
|
||||
|
||||
// Stands in for Bigfoot's real UUID - a `native_type` struct so RefId has a
|
||||
// distinct native/flat representation, matching the shape `bigfoot_ref`
|
||||
// requires of a wrapper's payload field.
|
||||
struct RefId (native_type: "Native::RefId") {
|
||||
value: uint64;
|
||||
}
|
||||
|
||||
// The reference-wrapper template itself. `bigfoot_ref_wrapper` marks Ref as
|
||||
// instantiable per referenced type via `bigfoot_ref` below.
|
||||
struct Ref (bigfoot_ref_wrapper: "Native::Ref") {
|
||||
uuid: RefId;
|
||||
}
|
||||
|
||||
// RefHolder references two distinct C++ types (Thing, OtherThing) that are
|
||||
// *never defined anywhere in this test* - only ever forward-declared, by
|
||||
// flatc itself, directly into the generated header. This is the property
|
||||
// `bigfoot_ref` exists to provide: a reference field never requires the
|
||||
// referenced type to be complete. It also references `Thing` twice (once as
|
||||
// a plain field, once in a vector), exercising the include-guard dedup for
|
||||
// two fields that resolve to the identical Pack/UnPack pair.
|
||||
table RefHolder {
|
||||
ref_a: Ref (native_inline, bigfoot_ref: "Native::Thing");
|
||||
ref_a_again: [Ref] (native_inline, bigfoot_ref: "Native::Thing");
|
||||
ref_b: Ref (native_inline, bigfoot_ref: "Native::OtherThing");
|
||||
}
|
||||
|
||||
root_type RefHolder;
|
||||
@@ -1,47 +0,0 @@
|
||||
#include "bigfoot_ref_test_impl.h"
|
||||
|
||||
#include "bigfoot_ref_test_generated.h"
|
||||
#include "test_assert.h"
|
||||
|
||||
namespace flatbuffers {
|
||||
BigfootRefTestNS::RefId Pack(const Native::RefId& obj) {
|
||||
return BigfootRefTestNS::RefId(obj.value);
|
||||
}
|
||||
|
||||
const Native::RefId UnPack(const BigfootRefTestNS::RefId& obj) {
|
||||
return Native::RefId(obj.value());
|
||||
}
|
||||
} // namespace flatbuffers
|
||||
|
||||
namespace flatbuffers {
|
||||
namespace tests {
|
||||
|
||||
// Exercises the --bigfoot_ref/--bigfoot_ref_wrapper flatc attributes (see
|
||||
// tests/bigfoot_ref_test.fbs): a reference field never requires the
|
||||
// referenced native type to be complete, and the generated header supplies
|
||||
// its own forward declaration plus inline Pack/UnPack definitions, with no
|
||||
// hand-written boilerplate anywhere in this file for `Thing`/`OtherThing`.
|
||||
void BigfootRefTest() {
|
||||
using BigfootRefTestNS::RefHolder;
|
||||
using BigfootRefTestNS::RefHolderT;
|
||||
|
||||
RefHolderT src;
|
||||
src.ref_a = Native::Ref<Native::Thing>(Native::RefId(1));
|
||||
src.ref_a_again.push_back(Native::Ref<Native::Thing>(Native::RefId(2)));
|
||||
src.ref_a_again.push_back(Native::Ref<Native::Thing>(Native::RefId(3)));
|
||||
src.ref_b = Native::Ref<Native::OtherThing>(Native::RefId(4));
|
||||
|
||||
flatbuffers::FlatBufferBuilder fbb;
|
||||
fbb.Finish(RefHolder::Pack(fbb, &src));
|
||||
|
||||
auto dst = BigfootRefTestNS::UnPackRefHolder(fbb.GetBufferPointer());
|
||||
|
||||
TEST_EQ(dst->ref_a.uuid.value, 1u);
|
||||
TEST_EQ(dst->ref_a_again.size(), 2u);
|
||||
TEST_EQ(dst->ref_a_again[0].uuid.value, 2u);
|
||||
TEST_EQ(dst->ref_a_again[1].uuid.value, 3u);
|
||||
TEST_EQ(dst->ref_b.uuid.value, 4u);
|
||||
}
|
||||
|
||||
} // namespace tests
|
||||
} // namespace flatbuffers
|
||||
@@ -1,55 +0,0 @@
|
||||
#ifndef BIGFOOT_REF_TEST_IMPL_H
|
||||
#define BIGFOOT_REF_TEST_IMPL_H
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
namespace Native {
|
||||
// Stands in for Bigfoot's real UUID.
|
||||
struct RefId {
|
||||
uint64_t value;
|
||||
|
||||
RefId() : value(0) {}
|
||||
explicit RefId(uint64_t _value) : value(_value) {}
|
||||
|
||||
bool operator==(const RefId& other) const { return value == other.value; }
|
||||
};
|
||||
|
||||
// `Thing`/`OtherThing` are intentionally *never* defined anywhere in this
|
||||
// test (see bigfoot_ref_test.fbs) - Ref<T> must compile and round-trip
|
||||
// without T ever being a complete type, exactly like Bigfoot's
|
||||
// HardReference<T>/SoftReference<T>. Their forward declarations are emitted
|
||||
// automatically by flatc (GenerateBigfootRefForwardDecls in
|
||||
// idl_gen_cpp.cpp) directly into bigfoot_ref_test_generated.h - no manual
|
||||
// forward declaration belongs here.
|
||||
|
||||
// The reference-wrapper template `bigfoot_ref_wrapper`/`bigfoot_ref` (see
|
||||
// idl_parser.cpp/idl_gen_cpp.cpp) instantiate per referenced type. Only
|
||||
// needs a `GetUUID()` accessor and a constructor from RefId - never needs T
|
||||
// complete.
|
||||
template <typename T>
|
||||
struct Ref {
|
||||
RefId uuid;
|
||||
|
||||
Ref() : uuid() {}
|
||||
Ref(const RefId& _uuid) : uuid(_uuid) {}
|
||||
|
||||
const RefId& GetUUID() const { return uuid; }
|
||||
|
||||
bool operator==(const Ref& other) const { return uuid == other.uuid; }
|
||||
};
|
||||
} // namespace Native
|
||||
|
||||
namespace BigfootRefTestNS {
|
||||
struct RefId;
|
||||
} // namespace BigfootRefTestNS
|
||||
|
||||
namespace flatbuffers {
|
||||
BigfootRefTestNS::RefId Pack(const Native::RefId& obj);
|
||||
const Native::RefId UnPack(const BigfootRefTestNS::RefId& obj);
|
||||
|
||||
namespace tests {
|
||||
void BigfootRefTest();
|
||||
} // namespace tests
|
||||
} // namespace flatbuffers
|
||||
|
||||
#endif // BIGFOOT_REF_TEST_IMPL_H
|
||||
@@ -3276,10 +3276,10 @@ inline ::flatbuffers::Offset<Monster> Monster::Pack(::flatbuffers::FlatBufferBui
|
||||
auto _test = _o->test.Pack(_fbb);
|
||||
auto _test4 = _o->test4.size() ? _fbb.CreateVectorOfStructs(_o->test4) : 0;
|
||||
auto _testarrayofstring = _o->testarrayofstring.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring) : 0;
|
||||
auto _testarrayoftables = _o->testarrayoftables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Monster>> (_o->testarrayoftables.size(), [](size_t i, _VectorArgs *__va) { return CreateMonster(*__va->__fbb, __va->__o->testarrayoftables[i].get(), __va->__rehasher); }, &_va ) : 0;
|
||||
auto _enemy = _o->enemy ? CreateMonster(_fbb, _o->enemy.get(), _rehasher) : 0;
|
||||
auto _testarrayoftables = _o->testarrayoftables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Monster>> (_o->testarrayoftables.size(), [](size_t i, _VectorArgs *__va) { return MyGame::Example::CreateMonster(*__va->__fbb, __va->__o->testarrayoftables[i].get(), __va->__rehasher); }, &_va ) : 0;
|
||||
auto _enemy = _o->enemy ? MyGame::Example::CreateMonster(_fbb, _o->enemy.get(), _rehasher) : 0;
|
||||
auto _testnestedflatbuffer = _o->testnestedflatbuffer.size() ? _fbb.CreateVector(_o->testnestedflatbuffer) : 0;
|
||||
auto _testempty = _o->testempty ? CreateStat(_fbb, _o->testempty.get(), _rehasher) : 0;
|
||||
auto _testempty = _o->testempty ? MyGame::Example::CreateStat(_fbb, _o->testempty.get(), _rehasher) : 0;
|
||||
auto _testbool = _o->testbool;
|
||||
auto _testhashs32_fnv1 = _o->testhashs32_fnv1;
|
||||
auto _testhashu32_fnv1 = _o->testhashu32_fnv1;
|
||||
@@ -3299,11 +3299,11 @@ inline ::flatbuffers::Offset<Monster> Monster::Pack(::flatbuffers::FlatBufferBui
|
||||
auto _test5 = _o->test5.size() ? _fbb.CreateVectorOfStructs(_o->test5) : 0;
|
||||
auto _vector_of_longs = _o->vector_of_longs.size() ? _fbb.CreateVector(_o->vector_of_longs) : 0;
|
||||
auto _vector_of_doubles = _o->vector_of_doubles.size() ? _fbb.CreateVector(_o->vector_of_doubles) : 0;
|
||||
auto _parent_namespace_test = _o->parent_namespace_test ? CreateInParentNamespace(_fbb, _o->parent_namespace_test.get(), _rehasher) : 0;
|
||||
auto _vector_of_referrables = _o->vector_of_referrables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Referrable>> (_o->vector_of_referrables.size(), [](size_t i, _VectorArgs *__va) { return CreateReferrable(*__va->__fbb, __va->__o->vector_of_referrables[i].get(), __va->__rehasher); }, &_va ) : 0;
|
||||
auto _parent_namespace_test = _o->parent_namespace_test ? MyGame::CreateInParentNamespace(_fbb, _o->parent_namespace_test.get(), _rehasher) : 0;
|
||||
auto _vector_of_referrables = _o->vector_of_referrables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Referrable>> (_o->vector_of_referrables.size(), [](size_t i, _VectorArgs *__va) { return MyGame::Example::CreateReferrable(*__va->__fbb, __va->__o->vector_of_referrables[i].get(), __va->__rehasher); }, &_va ) : 0;
|
||||
auto _single_weak_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->single_weak_reference)) : 0;
|
||||
auto _vector_of_weak_references = _o->vector_of_weak_references.size() ? _fbb.CreateVector<uint64_t>(_o->vector_of_weak_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast<uint64_t>((*__va->__rehasher)(__va->__o->vector_of_weak_references[i])) : 0; }, &_va ) : 0;
|
||||
auto _vector_of_strong_referrables = _o->vector_of_strong_referrables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Referrable>> (_o->vector_of_strong_referrables.size(), [](size_t i, _VectorArgs *__va) { return CreateReferrable(*__va->__fbb, __va->__o->vector_of_strong_referrables[i].get(), __va->__rehasher); }, &_va ) : 0;
|
||||
auto _vector_of_strong_referrables = _o->vector_of_strong_referrables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Referrable>> (_o->vector_of_strong_referrables.size(), [](size_t i, _VectorArgs *__va) { return MyGame::Example::CreateReferrable(*__va->__fbb, __va->__o->vector_of_strong_referrables[i].get(), __va->__rehasher); }, &_va ) : 0;
|
||||
auto _co_owning_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->co_owning_reference)) : 0;
|
||||
auto _vector_of_co_owning_references = _o->vector_of_co_owning_references.size() ? _fbb.CreateVector<uint64_t>(_o->vector_of_co_owning_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast<uint64_t>((*__va->__rehasher)(__va->__o->vector_of_co_owning_references[i].get())) : 0; }, &_va ) : 0;
|
||||
auto _non_owning_reference = _rehasher ? static_cast<uint64_t>((*_rehasher)(_o->non_owning_reference)) : 0;
|
||||
@@ -3315,7 +3315,7 @@ inline ::flatbuffers::Offset<Monster> Monster::Pack(::flatbuffers::FlatBufferBui
|
||||
auto _vector_of_enums = _o->vector_of_enums.size() ? _fbb.CreateVector(_o->vector_of_enums) : 0;
|
||||
auto _signed_enum = _o->signed_enum;
|
||||
auto _testrequirednestedflatbuffer = _o->testrequirednestedflatbuffer.size() ? _fbb.CreateVector(_o->testrequirednestedflatbuffer) : 0;
|
||||
auto _scalar_key_sorted_tables = _o->scalar_key_sorted_tables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Stat>> (_o->scalar_key_sorted_tables.size(), [](size_t i, _VectorArgs *__va) { return CreateStat(*__va->__fbb, __va->__o->scalar_key_sorted_tables[i].get(), __va->__rehasher); }, &_va ) : 0;
|
||||
auto _scalar_key_sorted_tables = _o->scalar_key_sorted_tables.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Example::Stat>> (_o->scalar_key_sorted_tables.size(), [](size_t i, _VectorArgs *__va) { return MyGame::Example::CreateStat(*__va->__fbb, __va->__o->scalar_key_sorted_tables[i].get(), __va->__rehasher); }, &_va ) : 0;
|
||||
auto _native_inline = &_o->native_inline;
|
||||
auto _long_enum_non_enum_default = _o->long_enum_non_enum_default;
|
||||
auto _long_enum_normal_default = _o->long_enum_normal_default;
|
||||
|
||||
@@ -1,29 +0,0 @@
|
||||
// Schema used to test the --cpp-vector-type flatc option, which lets the
|
||||
// generated Object API use a custom vector-like container (e.g.
|
||||
// eastl::vector) instead of std::vector. See tests/test_vector_type.h for
|
||||
// the stand-in container used by the test, and
|
||||
// tests/cpp_vector_type_test.cpp for the test itself.
|
||||
|
||||
namespace CppVectorTypeNS;
|
||||
|
||||
enum CppVectorTypeColor : byte { Red = 0, Green, Blue }
|
||||
|
||||
struct CppVectorTypeVec2 {
|
||||
x: float;
|
||||
y: float;
|
||||
}
|
||||
|
||||
table CppVectorTypeMonster {
|
||||
id: int32;
|
||||
}
|
||||
|
||||
table CppVectorTypeTest {
|
||||
ints: [int32];
|
||||
flags: [bool];
|
||||
colors: [CppVectorTypeColor];
|
||||
strings: [string];
|
||||
positions: [CppVectorTypeVec2];
|
||||
monsters: [CppVectorTypeMonster];
|
||||
}
|
||||
|
||||
root_type CppVectorTypeTest;
|
||||
@@ -1,143 +0,0 @@
|
||||
#include "cpp_vector_type_test.h"
|
||||
|
||||
#include "cpp_vector_type_generated.h"
|
||||
#include "test_assert.h"
|
||||
|
||||
namespace flatbuffers {
|
||||
namespace tests {
|
||||
|
||||
// Exercises the --cpp-vector-type flatc option (see
|
||||
// tests/cpp_vector_type.fbs and tests/test_vector_type.h), which replaces
|
||||
// std::vector with a custom vector-like container in the generated Object
|
||||
// API. This covers every CreateVector*-family code path in Pack(): plain
|
||||
// scalars, bool, enum-cast, vector-of-string, vector-of-struct and
|
||||
// vector-of-table, then round-trips everything back through UnPackTo().
|
||||
void CppVectorTypeTest() {
|
||||
using CppVectorTypeNS::CppVectorTypeColor_Blue;
|
||||
using CppVectorTypeNS::CppVectorTypeColor_Green;
|
||||
using CppVectorTypeNS::CppVectorTypeColor_Red;
|
||||
using CppVectorTypeNS::CppVectorTypeMonsterT;
|
||||
using CppVectorTypeNS::CppVectorTypeTest;
|
||||
using CppVectorTypeNS::CppVectorTypeTestT;
|
||||
using CppVectorTypeNS::CppVectorTypeVec2;
|
||||
|
||||
// ---------------------------------------
|
||||
// 1) Build a native object using the custom vector container for every
|
||||
// vector field (scalars, bools, enums, strings, structs and tables).
|
||||
// ---------------------------------------
|
||||
CppVectorTypeTestT src;
|
||||
src.ints.push_back(1);
|
||||
src.ints.push_back(2);
|
||||
src.ints.push_back(3);
|
||||
|
||||
src.flags.push_back(true);
|
||||
src.flags.push_back(false);
|
||||
src.flags.push_back(true);
|
||||
|
||||
src.colors.push_back(CppVectorTypeColor_Red);
|
||||
src.colors.push_back(CppVectorTypeColor_Green);
|
||||
src.colors.push_back(CppVectorTypeColor_Blue);
|
||||
|
||||
src.strings.push_back("hello");
|
||||
src.strings.push_back("world");
|
||||
|
||||
src.positions.push_back(CppVectorTypeVec2(1.0f, 2.0f));
|
||||
src.positions.push_back(CppVectorTypeVec2(3.0f, 4.0f));
|
||||
|
||||
src.monsters.emplace_back(new CppVectorTypeMonsterT());
|
||||
src.monsters[0]->id = 111;
|
||||
src.monsters.emplace_back(new CppVectorTypeMonsterT());
|
||||
src.monsters[1]->id = 222;
|
||||
|
||||
// ---------------------------------------
|
||||
// 2) Exercise the copy constructor / copy assignment operator generated
|
||||
// for object-API types (--gen-compare requires these too), which rely
|
||||
// on the custom vector's own copy ctor plus reserve()/emplace_back()
|
||||
// for the vector-of-pointer (table) field.
|
||||
// ---------------------------------------
|
||||
CppVectorTypeTestT copy_of_src(src);
|
||||
TEST_EQ(copy_of_src == src, true);
|
||||
TEST_ASSERT(copy_of_src.monsters[0].get() != src.monsters[0].get());
|
||||
TEST_EQ(copy_of_src.monsters[0]->id, 111);
|
||||
|
||||
// ---------------------------------------
|
||||
// 3) Pack into a FlatBuffer and verify the wire-format contents.
|
||||
// ---------------------------------------
|
||||
flatbuffers::FlatBufferBuilder fbb;
|
||||
fbb.Finish(CppVectorTypeTest::Pack(fbb, &src));
|
||||
|
||||
const auto* fb =
|
||||
flatbuffers::GetRoot<CppVectorTypeTest>(fbb.GetBufferPointer());
|
||||
|
||||
TEST_EQ(fb->ints()->size(), 3u);
|
||||
TEST_EQ(fb->ints()->Get(0), 1);
|
||||
TEST_EQ(fb->ints()->Get(1), 2);
|
||||
TEST_EQ(fb->ints()->Get(2), 3);
|
||||
|
||||
TEST_EQ(fb->flags()->size(), 3u);
|
||||
TEST_EQ(fb->flags()->Get(0) != 0, true);
|
||||
TEST_EQ(fb->flags()->Get(1) != 0, false);
|
||||
TEST_EQ(fb->flags()->Get(2) != 0, true);
|
||||
|
||||
TEST_EQ(fb->colors()->size(), 3u);
|
||||
TEST_EQ(fb->colors()->Get(0), CppVectorTypeColor_Red);
|
||||
TEST_EQ(fb->colors()->Get(1), CppVectorTypeColor_Green);
|
||||
TEST_EQ(fb->colors()->Get(2), CppVectorTypeColor_Blue);
|
||||
|
||||
TEST_EQ(fb->strings()->size(), 2u);
|
||||
TEST_EQ_STR(fb->strings()->Get(0)->c_str(), "hello");
|
||||
TEST_EQ_STR(fb->strings()->Get(1)->c_str(), "world");
|
||||
|
||||
TEST_EQ(fb->positions()->size(), 2u);
|
||||
TEST_EQ(fb->positions()->Get(0)->x(), 1.0f);
|
||||
TEST_EQ(fb->positions()->Get(0)->y(), 2.0f);
|
||||
TEST_EQ(fb->positions()->Get(1)->x(), 3.0f);
|
||||
TEST_EQ(fb->positions()->Get(1)->y(), 4.0f);
|
||||
|
||||
TEST_EQ(fb->monsters()->size(), 2u);
|
||||
TEST_EQ(fb->monsters()->Get(0)->id(), 111);
|
||||
TEST_EQ(fb->monsters()->Get(1)->id(), 222);
|
||||
|
||||
// ---------------------------------------
|
||||
// 4) Unpack back into a fresh native object and verify a full round-trip
|
||||
// through the custom vector container.
|
||||
// ---------------------------------------
|
||||
CppVectorTypeTestT dst;
|
||||
fb->UnPackTo(&dst);
|
||||
|
||||
TEST_EQ(dst == src, true);
|
||||
|
||||
TEST_EQ(dst.ints.size(), 3u);
|
||||
TEST_EQ(dst.ints[0], 1);
|
||||
TEST_EQ(dst.ints[1], 2);
|
||||
TEST_EQ(dst.ints[2], 3);
|
||||
|
||||
TEST_EQ(dst.flags.size(), 3u);
|
||||
TEST_EQ(dst.flags[0], true);
|
||||
TEST_EQ(dst.flags[1], false);
|
||||
TEST_EQ(dst.flags[2], true);
|
||||
|
||||
TEST_EQ(dst.colors.size(), 3u);
|
||||
TEST_EQ(dst.colors[0], CppVectorTypeColor_Red);
|
||||
TEST_EQ(dst.colors[1], CppVectorTypeColor_Green);
|
||||
TEST_EQ(dst.colors[2], CppVectorTypeColor_Blue);
|
||||
|
||||
TEST_EQ(dst.strings.size(), 2u);
|
||||
TEST_EQ_STR(dst.strings[0].c_str(), "hello");
|
||||
TEST_EQ_STR(dst.strings[1].c_str(), "world");
|
||||
|
||||
TEST_EQ(dst.positions.size(), 2u);
|
||||
TEST_EQ(dst.positions[0].x(), 1.0f);
|
||||
TEST_EQ(dst.positions[0].y(), 2.0f);
|
||||
TEST_EQ(dst.positions[1].x(), 3.0f);
|
||||
TEST_EQ(dst.positions[1].y(), 4.0f);
|
||||
|
||||
TEST_EQ(dst.monsters.size(), 2u);
|
||||
TEST_ASSERT(dst.monsters[0] != nullptr);
|
||||
TEST_ASSERT(dst.monsters[1] != nullptr);
|
||||
TEST_EQ(dst.monsters[0]->id, 111);
|
||||
TEST_EQ(dst.monsters[1]->id, 222);
|
||||
}
|
||||
|
||||
} // namespace tests
|
||||
} // namespace flatbuffers
|
||||
@@ -1,12 +0,0 @@
|
||||
#ifndef TESTS_CPP_VECTOR_TYPE_TEST_H
|
||||
#define TESTS_CPP_VECTOR_TYPE_TEST_H
|
||||
|
||||
namespace flatbuffers {
|
||||
namespace tests {
|
||||
|
||||
void CppVectorTypeTest();
|
||||
|
||||
} // namespace tests
|
||||
} // namespace flatbuffers
|
||||
|
||||
#endif // TESTS_CPP_VECTOR_TYPE_TEST_H
|
||||
@@ -1,16 +1,16 @@
|
||||
// Automatically generated by the Flatbuffers compiler. Do not modify.
|
||||
// @generated
|
||||
pub mod my_game {
|
||||
use super::*;
|
||||
pub mod other_name_space {
|
||||
use super::*;
|
||||
mod from_include_generated;
|
||||
pub use self::from_include_generated::*;
|
||||
mod unused_generated;
|
||||
pub use self::unused_generated::*;
|
||||
mod table_b_generated;
|
||||
pub use self::table_b_generated::*;
|
||||
} // other_name_space
|
||||
pub mod other_name_space {
|
||||
use super::*;
|
||||
mod from_include_generated;
|
||||
pub use self::from_include_generated::*;
|
||||
mod unused_generated;
|
||||
pub use self::unused_generated::*;
|
||||
mod table_b_generated;
|
||||
pub use self::table_b_generated::*;
|
||||
} // other_name_space
|
||||
} // my_game
|
||||
mod table_a_generated;
|
||||
pub use self::table_a_generated::*;
|
||||
|
||||
@@ -2,56 +2,65 @@
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
use super::*;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MIN_FROM_INCLUDE: i64 = 0;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MAX_FROM_INCLUDE: i64 = 0;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
#[allow(non_camel_case_types)]
|
||||
pub const ENUM_VALUES_FROM_INCLUDE: [FromInclude; 1] = [
|
||||
FromInclude::IncludeVal,
|
||||
FromInclude::IncludeVal,
|
||||
];
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
|
||||
#[repr(transparent)]
|
||||
pub struct FromInclude(pub i64);
|
||||
|
||||
#[allow(non_upper_case_globals)]
|
||||
impl FromInclude {
|
||||
pub const IncludeVal: Self = Self(0);
|
||||
pub const IncludeVal: Self = Self(0);
|
||||
|
||||
pub const ENUM_MIN: i64 = 0;
|
||||
pub const ENUM_MAX: i64 = 0;
|
||||
pub const ENUM_VALUES: &'static [Self] = &[
|
||||
Self::IncludeVal,
|
||||
];
|
||||
/// Returns the variant's name or "" if unknown.
|
||||
pub fn variant_name(self) -> Option<&'static str> {
|
||||
match self {
|
||||
Self::IncludeVal => Some("IncludeVal"),
|
||||
_ => None,
|
||||
pub const ENUM_MIN: i64 = 0;
|
||||
pub const ENUM_MAX: i64 = 0;
|
||||
pub const ENUM_VALUES: &'static [Self] = &[
|
||||
Self::IncludeVal,
|
||||
];
|
||||
|
||||
/// Returns the variant's name or "" if unknown.
|
||||
pub fn variant_name(self) -> Option<&'static str> {
|
||||
match self {
|
||||
Self::IncludeVal => Some("IncludeVal"),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for FromInclude {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
if let Some(name) = self.variant_name() {
|
||||
f.write_str(name)
|
||||
} else {
|
||||
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
if let Some(name) = self.variant_name() {
|
||||
f.write_str(name)
|
||||
} else {
|
||||
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for FromInclude {
|
||||
type Inner = Self;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
let b = unsafe { ::flatbuffers::read_scalar_at::<i64>(buf, loc) };
|
||||
Self(b)
|
||||
}
|
||||
type Inner = Self;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
let b = unsafe { ::flatbuffers::read_scalar_at::<i64>(buf, loc) };
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Push for FromInclude {
|
||||
type Output = FromInclude;
|
||||
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
unsafe { ::flatbuffers::emplace_scalar::<i64>(dst, self.0) };
|
||||
@@ -59,26 +68,28 @@ impl ::flatbuffers::Push for FromInclude {
|
||||
}
|
||||
|
||||
impl ::flatbuffers::EndianScalar for FromInclude {
|
||||
type Scalar = i64;
|
||||
#[inline]
|
||||
fn to_little_endian(self) -> i64 {
|
||||
self.0.to_le()
|
||||
}
|
||||
#[inline]
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
fn from_little_endian(v: i64) -> Self {
|
||||
let b = i64::from_le(v);
|
||||
Self(b)
|
||||
}
|
||||
type Scalar = i64;
|
||||
|
||||
#[inline]
|
||||
fn to_little_endian(self) -> i64 {
|
||||
self.0.to_le()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
fn from_little_endian(v: i64) -> Self {
|
||||
let b = i64::from_le(v);
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Verifiable for FromInclude {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
i64::run_verifier(v, pos)
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
i64::run_verifier(v, pos)
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {}
|
||||
|
||||
@@ -2,136 +2,147 @@
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
use super::*;
|
||||
pub enum TableBOffset {}
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
|
||||
pub enum TableBOffset {}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
pub struct TableB<'a> {
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> {
|
||||
type Inner = TableB<'a>;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
type Inner = TableB<'a>;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> TableB<'a> {
|
||||
pub const VT_A: ::flatbuffers::VOffsetT = 4;
|
||||
pub const VT_A: ::flatbuffers::VOffsetT = 4;
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.OtherNameSpace.TableB"
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
TableB { _tab: table }
|
||||
}
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args TableBArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<TableB<'bldr>> {
|
||||
let mut builder = TableBBuilder::new(_fbb);
|
||||
if let Some(x) = args.a { builder.add_a(x); }
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> TableBT {
|
||||
let a = self.a().map(|x| {
|
||||
alloc::boxed::Box::new(x.unpack())
|
||||
});
|
||||
TableBT {
|
||||
a,
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.OtherNameSpace.TableB"
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn a(&self) -> Option<super::super::TableA<'a>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<super::super::TableA>>(TableB::VT_A, None)}
|
||||
}
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
TableB { _tab: table }
|
||||
}
|
||||
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args TableBArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<TableB<'bldr>> {
|
||||
let mut builder = TableBBuilder::new(_fbb);
|
||||
if let Some(x) = args.a { builder.add_a(x); }
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> TableBT {
|
||||
let a = self.a().map(|x| {
|
||||
alloc::boxed::Box::new(x.unpack())
|
||||
});
|
||||
TableBT {
|
||||
a,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn a(&self) -> Option<super::super::TableA<'a>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<super::super::TableA>>(TableB::VT_A, None)}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Verifiable for TableB<'_> {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<super::super::TableA>>("a", Self::VT_A, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<super::super::TableA>>("a", Self::VT_A, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TableBArgs<'a> {
|
||||
pub a: Option<::flatbuffers::WIPOffset<super::super::TableA<'a>>>,
|
||||
}
|
||||
|
||||
impl<'a> Default for TableBArgs<'a> {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
TableBArgs {
|
||||
a: None,
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
TableBArgs {
|
||||
a: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TableBBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
}
|
||||
|
||||
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> {
|
||||
#[inline]
|
||||
pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset<super::super::TableA<'b >>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
|
||||
}
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
TableBBuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
#[inline]
|
||||
pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset<super::super::TableA<'b >>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
TableBBuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<TableB<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<TableB<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for TableB<'_> {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("TableB");
|
||||
ds.field("a", &self.a());
|
||||
ds.finish()
|
||||
}
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("TableB");
|
||||
ds.field("a", &self.a());
|
||||
ds.finish()
|
||||
}
|
||||
}
|
||||
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct TableBT {
|
||||
pub a: Option<alloc::boxed::Box<super::super::TableAT>>,
|
||||
pub a: Option<alloc::boxed::Box<super::super::TableAT>>,
|
||||
}
|
||||
|
||||
impl Default for TableBT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
a: None,
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
a: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl TableBT {
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<TableB<'b>> {
|
||||
let a = self.a.as_ref().map(|x|{
|
||||
x.pack(_fbb)
|
||||
});
|
||||
TableB::create(_fbb, &TableBArgs{
|
||||
a,
|
||||
})
|
||||
}
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<TableB<'b>> {
|
||||
let a = self.a.as_ref().map(|x|{
|
||||
x.pack(_fbb)
|
||||
});
|
||||
TableB::create(_fbb, &TableBArgs{
|
||||
a,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,45 +2,55 @@
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
use super::*;
|
||||
|
||||
// struct Unused, aligned to 4
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
pub struct Unused(pub [u8; 4]);
|
||||
impl Default for Unused {
|
||||
fn default() -> Self {
|
||||
Self([0; 4])
|
||||
}
|
||||
|
||||
impl Default for Unused {
|
||||
fn default() -> Self {
|
||||
Self([0; 4])
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for Unused {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
f.debug_struct("Unused")
|
||||
.field("a", &self.a())
|
||||
.finish()
|
||||
}
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
f.debug_struct("Unused")
|
||||
.field("a", &self.a())
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for Unused {}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for Unused {
|
||||
type Inner = &'a Unused;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { <&'a Unused>::follow(buf, loc) }
|
||||
}
|
||||
type Inner = &'a Unused;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { <&'a Unused>::follow(buf, loc) }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for &'a Unused {
|
||||
type Inner = &'a Unused;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { ::flatbuffers::follow_cast_ref::<Unused>(buf, loc) }
|
||||
}
|
||||
type Inner = &'a Unused;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { ::flatbuffers::follow_cast_ref::<Unused>(buf, loc) }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'b> ::flatbuffers::Push for Unused {
|
||||
type Output = Unused;
|
||||
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
let src = unsafe { ::core::slice::from_raw_parts(self as *const Unused as *const u8, <Self as ::flatbuffers::Push>::size()) };
|
||||
dst.copy_from_slice(src);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn alignment() -> ::flatbuffers::PushAlignment {
|
||||
::flatbuffers::PushAlignment::new(4)
|
||||
@@ -48,73 +58,80 @@ impl<'b> ::flatbuffers::Push for Unused {
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Verifiable for Unused {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.in_buffer::<Self>(pos)
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.in_buffer::<Self>(pos)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Unused {
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn new(
|
||||
a: i32,
|
||||
) -> Self {
|
||||
let mut s = Self([0; 4]);
|
||||
s.set_a(a);
|
||||
s
|
||||
}
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.OtherNameSpace.Unused"
|
||||
}
|
||||
|
||||
pub fn a(&self) -> i32 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<i32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[0..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_a(&mut self, x: i32) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[0..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn new(
|
||||
a: i32,
|
||||
) -> Self {
|
||||
let mut s = Self([0; 4]);
|
||||
s.set_a(a);
|
||||
s
|
||||
}
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> UnusedT {
|
||||
UnusedT {
|
||||
a: self.a(),
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.OtherNameSpace.Unused"
|
||||
}
|
||||
|
||||
pub fn a(&self) -> i32 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<i32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[0..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_a(&mut self, x: i32) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[0..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> UnusedT {
|
||||
UnusedT {
|
||||
a: self.a(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct UnusedT {
|
||||
pub a: i32,
|
||||
pub a: i32,
|
||||
}
|
||||
impl UnusedT {
|
||||
pub fn pack(&self) -> Unused {
|
||||
Unused::new(
|
||||
self.a,
|
||||
)
|
||||
}
|
||||
impl Default for UnusedT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
a: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl UnusedT {
|
||||
pub fn pack(&self) -> Unused {
|
||||
Unused::new(
|
||||
self.a,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,136 +2,147 @@
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
use super::*;
|
||||
pub enum TableAOffset {}
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
|
||||
pub enum TableAOffset {}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
pub struct TableA<'a> {
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for TableA<'a> {
|
||||
type Inner = TableA<'a>;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
type Inner = TableA<'a>;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> TableA<'a> {
|
||||
pub const VT_B: ::flatbuffers::VOffsetT = 4;
|
||||
pub const VT_B: ::flatbuffers::VOffsetT = 4;
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"TableA"
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
TableA { _tab: table }
|
||||
}
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args TableAArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<TableA<'bldr>> {
|
||||
let mut builder = TableABuilder::new(_fbb);
|
||||
if let Some(x) = args.b { builder.add_b(x); }
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> TableAT {
|
||||
let b = self.b().map(|x| {
|
||||
alloc::boxed::Box::new(x.unpack())
|
||||
});
|
||||
TableAT {
|
||||
b,
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"TableA"
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>(TableA::VT_B, None)}
|
||||
}
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
TableA { _tab: table }
|
||||
}
|
||||
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args TableAArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<TableA<'bldr>> {
|
||||
let mut builder = TableABuilder::new(_fbb);
|
||||
if let Some(x) = args.b { builder.add_b(x); }
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> TableAT {
|
||||
let b = self.b().map(|x| {
|
||||
alloc::boxed::Box::new(x.unpack())
|
||||
});
|
||||
TableAT {
|
||||
b,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>(TableA::VT_B, None)}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Verifiable for TableA<'_> {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>("b", Self::VT_B, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>("b", Self::VT_B, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TableAArgs<'a> {
|
||||
pub b: Option<::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'a>>>,
|
||||
}
|
||||
|
||||
impl<'a> Default for TableAArgs<'a> {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
TableAArgs {
|
||||
b: None,
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
TableAArgs {
|
||||
b: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TableABuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
}
|
||||
|
||||
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableABuilder<'a, 'b, A> {
|
||||
#[inline]
|
||||
pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
|
||||
}
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
TableABuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
#[inline]
|
||||
pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
TableABuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<TableA<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<TableA<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for TableA<'_> {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("TableA");
|
||||
ds.field("b", &self.b());
|
||||
ds.finish()
|
||||
}
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("TableA");
|
||||
ds.field("b", &self.b());
|
||||
ds.finish()
|
||||
}
|
||||
}
|
||||
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct TableAT {
|
||||
pub b: Option<alloc::boxed::Box<my_game::other_name_space::TableBT>>,
|
||||
pub b: Option<alloc::boxed::Box<my_game::other_name_space::TableBT>>,
|
||||
}
|
||||
|
||||
impl Default for TableAT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
b: None,
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
b: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl TableAT {
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<TableA<'b>> {
|
||||
let b = self.b.as_ref().map(|x|{
|
||||
x.pack(_fbb)
|
||||
});
|
||||
TableA::create(_fbb, &TableAArgs{
|
||||
b,
|
||||
})
|
||||
}
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<TableA<'b>> {
|
||||
let b = self.b.as_ref().map(|x|{
|
||||
x.pack(_fbb)
|
||||
});
|
||||
TableA::create(_fbb, &TableAArgs{
|
||||
b,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
+450
-404
@@ -1,479 +1,525 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
// @generated
|
||||
|
||||
extern crate alloc;
|
||||
|
||||
pub enum TableAOffset {}
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
pub struct TableA<'a> {
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for TableA<'a> {
|
||||
type Inner = TableA<'a>;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
type Inner = TableA<'a>;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> TableA<'a> {
|
||||
pub const VT_B: ::flatbuffers::VOffsetT = 4;
|
||||
pub const VT_B: ::flatbuffers::VOffsetT = 4;
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"TableA"
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
TableA { _tab: table }
|
||||
}
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args TableAArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<TableA<'bldr>> {
|
||||
let mut builder = TableABuilder::new(_fbb);
|
||||
if let Some(x) = args.b { builder.add_b(x); }
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> TableAT {
|
||||
let b = self.b().map(|x| {
|
||||
alloc::boxed::Box::new(x.unpack())
|
||||
});
|
||||
TableAT {
|
||||
b,
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"TableA"
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>(TableA::VT_B, None)}
|
||||
}
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
TableA { _tab: table }
|
||||
}
|
||||
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args TableAArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<TableA<'bldr>> {
|
||||
let mut builder = TableABuilder::new(_fbb);
|
||||
if let Some(x) = args.b { builder.add_b(x); }
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> TableAT {
|
||||
let b = self.b().map(|x| {
|
||||
alloc::boxed::Box::new(x.unpack())
|
||||
});
|
||||
TableAT {
|
||||
b,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>(TableA::VT_B, None)}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Verifiable for TableA<'_> {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>("b", Self::VT_B, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>("b", Self::VT_B, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TableAArgs<'a> {
|
||||
pub b: Option<::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'a>>>,
|
||||
}
|
||||
|
||||
impl<'a> Default for TableAArgs<'a> {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
TableAArgs {
|
||||
b: None,
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
TableAArgs {
|
||||
b: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TableABuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
}
|
||||
|
||||
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableABuilder<'a, 'b, A> {
|
||||
#[inline]
|
||||
pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
|
||||
}
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
TableABuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
#[inline]
|
||||
pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
TableABuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<TableA<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<TableA<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for TableA<'_> {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("TableA");
|
||||
ds.field("b", &self.b());
|
||||
ds.finish()
|
||||
}
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("TableA");
|
||||
ds.field("b", &self.b());
|
||||
ds.finish()
|
||||
}
|
||||
}
|
||||
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct TableAT {
|
||||
pub b: Option<alloc::boxed::Box<my_game::other_name_space::TableBT>>,
|
||||
pub b: Option<alloc::boxed::Box<my_game::other_name_space::TableBT>>,
|
||||
}
|
||||
|
||||
impl Default for TableAT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
b: None,
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
b: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl TableAT {
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<TableA<'b>> {
|
||||
let b = self.b.as_ref().map(|x|{
|
||||
x.pack(_fbb)
|
||||
});
|
||||
TableA::create(_fbb, &TableAArgs{
|
||||
b,
|
||||
})
|
||||
}
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<TableA<'b>> {
|
||||
let b = self.b.as_ref().map(|x|{
|
||||
x.pack(_fbb)
|
||||
});
|
||||
TableA::create(_fbb, &TableAArgs{
|
||||
b,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unused_imports, dead_code)]
|
||||
pub mod my_game {
|
||||
extern crate alloc;
|
||||
|
||||
extern crate alloc;
|
||||
#[allow(unused_imports, dead_code)]
|
||||
pub mod other_name_space {
|
||||
#[allow(unused_imports, dead_code)]
|
||||
pub mod other_name_space {
|
||||
extern crate alloc;
|
||||
|
||||
extern crate alloc;
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MIN_FROM_INCLUDE: i64 = 0;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MIN_FROM_INCLUDE: i64 = 0;
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MAX_FROM_INCLUDE: i64 = 0;
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
#[allow(non_camel_case_types)]
|
||||
pub const ENUM_VALUES_FROM_INCLUDE: [FromInclude; 1] = [
|
||||
FromInclude::IncludeVal,
|
||||
];
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MAX_FROM_INCLUDE: i64 = 0;
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
|
||||
#[repr(transparent)]
|
||||
pub struct FromInclude(pub i64);
|
||||
#[allow(non_upper_case_globals)]
|
||||
impl FromInclude {
|
||||
pub const IncludeVal: Self = Self(0);
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
#[allow(non_camel_case_types)]
|
||||
pub const ENUM_VALUES_FROM_INCLUDE: [FromInclude; 1] = [
|
||||
FromInclude::IncludeVal,
|
||||
];
|
||||
|
||||
pub const ENUM_MIN: i64 = 0;
|
||||
pub const ENUM_MAX: i64 = 0;
|
||||
pub const ENUM_VALUES: &'static [Self] = &[
|
||||
Self::IncludeVal,
|
||||
];
|
||||
/// Returns the variant's name or "" if unknown.
|
||||
pub fn variant_name(self) -> Option<&'static str> {
|
||||
match self {
|
||||
Self::IncludeVal => Some("IncludeVal"),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
impl ::core::fmt::Debug for FromInclude {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
if let Some(name) = self.variant_name() {
|
||||
f.write_str(name)
|
||||
} else {
|
||||
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<'a> ::flatbuffers::Follow<'a> for FromInclude {
|
||||
type Inner = Self;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
let b = unsafe { ::flatbuffers::read_scalar_at::<i64>(buf, loc) };
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
|
||||
#[repr(transparent)]
|
||||
pub struct FromInclude(pub i64);
|
||||
|
||||
impl ::flatbuffers::Push for FromInclude {
|
||||
type Output = FromInclude;
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
unsafe { ::flatbuffers::emplace_scalar::<i64>(dst, self.0) };
|
||||
}
|
||||
}
|
||||
#[allow(non_upper_case_globals)]
|
||||
impl FromInclude {
|
||||
pub const IncludeVal: Self = Self(0);
|
||||
|
||||
impl ::flatbuffers::EndianScalar for FromInclude {
|
||||
type Scalar = i64;
|
||||
#[inline]
|
||||
fn to_little_endian(self) -> i64 {
|
||||
self.0.to_le()
|
||||
}
|
||||
#[inline]
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
fn from_little_endian(v: i64) -> Self {
|
||||
let b = i64::from_le(v);
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
pub const ENUM_MIN: i64 = 0;
|
||||
pub const ENUM_MAX: i64 = 0;
|
||||
pub const ENUM_VALUES: &'static [Self] = &[
|
||||
Self::IncludeVal,
|
||||
];
|
||||
|
||||
impl<'a> ::flatbuffers::Verifiable for FromInclude {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
i64::run_verifier(v, pos)
|
||||
}
|
||||
}
|
||||
/// Returns the variant's name or "" if unknown.
|
||||
pub fn variant_name(self) -> Option<&'static str> {
|
||||
match self {
|
||||
Self::IncludeVal => Some("IncludeVal"),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {}
|
||||
// struct Unused, aligned to 4
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
pub struct Unused(pub [u8; 4]);
|
||||
impl Default for Unused {
|
||||
fn default() -> Self {
|
||||
Self([0; 4])
|
||||
}
|
||||
}
|
||||
impl ::core::fmt::Debug for Unused {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
f.debug_struct("Unused")
|
||||
.field("a", &self.a())
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
impl ::core::fmt::Debug for FromInclude {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
if let Some(name) = self.variant_name() {
|
||||
f.write_str(name)
|
||||
} else {
|
||||
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for Unused {}
|
||||
impl<'a> ::flatbuffers::Follow<'a> for Unused {
|
||||
type Inner = &'a Unused;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { <&'a Unused>::follow(buf, loc) }
|
||||
}
|
||||
}
|
||||
impl<'a> ::flatbuffers::Follow<'a> for &'a Unused {
|
||||
type Inner = &'a Unused;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { ::flatbuffers::follow_cast_ref::<Unused>(buf, loc) }
|
||||
}
|
||||
}
|
||||
impl<'b> ::flatbuffers::Push for Unused {
|
||||
type Output = Unused;
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
let src = unsafe { ::core::slice::from_raw_parts(self as *const Unused as *const u8, <Self as ::flatbuffers::Push>::size()) };
|
||||
dst.copy_from_slice(src);
|
||||
}
|
||||
#[inline]
|
||||
fn alignment() -> ::flatbuffers::PushAlignment {
|
||||
::flatbuffers::PushAlignment::new(4)
|
||||
}
|
||||
}
|
||||
impl<'a> ::flatbuffers::Follow<'a> for FromInclude {
|
||||
type Inner = Self;
|
||||
|
||||
impl<'a> ::flatbuffers::Verifiable for Unused {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.in_buffer::<Self>(pos)
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
let b = unsafe { ::flatbuffers::read_scalar_at::<i64>(buf, loc) };
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Unused {
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn new(
|
||||
a: i32,
|
||||
) -> Self {
|
||||
let mut s = Self([0; 4]);
|
||||
s.set_a(a);
|
||||
s
|
||||
}
|
||||
impl ::flatbuffers::Push for FromInclude {
|
||||
type Output = FromInclude;
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.OtherNameSpace.Unused"
|
||||
}
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
unsafe { ::flatbuffers::emplace_scalar::<i64>(dst, self.0) };
|
||||
}
|
||||
}
|
||||
|
||||
pub fn a(&self) -> i32 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<i32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[0..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
impl ::flatbuffers::EndianScalar for FromInclude {
|
||||
type Scalar = i64;
|
||||
|
||||
pub fn set_a(&mut self, x: i32) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[0..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
fn to_little_endian(self) -> i64 {
|
||||
self.0.to_le()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> UnusedT {
|
||||
UnusedT {
|
||||
a: self.a(),
|
||||
}
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
fn from_little_endian(v: i64) -> Self {
|
||||
let b = i64::from_le(v);
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
pub struct UnusedT {
|
||||
pub a: i32,
|
||||
}
|
||||
impl UnusedT {
|
||||
pub fn pack(&self) -> Unused {
|
||||
Unused::new(
|
||||
self.a,
|
||||
)
|
||||
}
|
||||
}
|
||||
impl<'a> ::flatbuffers::Verifiable for FromInclude {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
i64::run_verifier(v, pos)
|
||||
}
|
||||
}
|
||||
|
||||
pub enum TableBOffset {}
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {}
|
||||
|
||||
pub struct TableB<'a> {
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
}
|
||||
// struct Unused, aligned to 4
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
pub struct Unused(pub [u8; 4]);
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> {
|
||||
type Inner = TableB<'a>;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
}
|
||||
impl Default for Unused {
|
||||
fn default() -> Self {
|
||||
Self([0; 4])
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> TableB<'a> {
|
||||
pub const VT_A: ::flatbuffers::VOffsetT = 4;
|
||||
impl ::core::fmt::Debug for Unused {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
f.debug_struct("Unused")
|
||||
.field("a", &self.a())
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.OtherNameSpace.TableB"
|
||||
}
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for Unused {}
|
||||
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
TableB { _tab: table }
|
||||
}
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args TableBArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<TableB<'bldr>> {
|
||||
let mut builder = TableBBuilder::new(_fbb);
|
||||
if let Some(x) = args.a { builder.add_a(x); }
|
||||
builder.finish()
|
||||
}
|
||||
impl<'a> ::flatbuffers::Follow<'a> for Unused {
|
||||
type Inner = &'a Unused;
|
||||
|
||||
pub fn unpack(&self) -> TableBT {
|
||||
let a = self.a().map(|x| {
|
||||
alloc::boxed::Box::new(x.unpack())
|
||||
});
|
||||
TableBT {
|
||||
a,
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { <&'a Unused>::follow(buf, loc) }
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn a(&self) -> Option<super::super::TableA<'a>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<super::super::TableA>>(TableB::VT_A, None)}
|
||||
}
|
||||
}
|
||||
impl<'a> ::flatbuffers::Follow<'a> for &'a Unused {
|
||||
type Inner = &'a Unused;
|
||||
|
||||
impl ::flatbuffers::Verifiable for TableB<'_> {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<super::super::TableA>>("a", Self::VT_A, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
pub struct TableBArgs<'a> {
|
||||
pub a: Option<::flatbuffers::WIPOffset<super::super::TableA<'a>>>,
|
||||
}
|
||||
impl<'a> Default for TableBArgs<'a> {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
TableBArgs {
|
||||
a: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { ::flatbuffers::follow_cast_ref::<Unused>(buf, loc) }
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TableBBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
}
|
||||
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> {
|
||||
#[inline]
|
||||
pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset<super::super::TableA<'b >>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
|
||||
}
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
TableBBuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<TableB<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
impl<'b> ::flatbuffers::Push for Unused {
|
||||
type Output = Unused;
|
||||
|
||||
impl ::core::fmt::Debug for TableB<'_> {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("TableB");
|
||||
ds.field("a", &self.a());
|
||||
ds.finish()
|
||||
}
|
||||
}
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct TableBT {
|
||||
pub a: Option<alloc::boxed::Box<super::super::TableAT>>,
|
||||
}
|
||||
impl Default for TableBT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
a: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
impl TableBT {
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<TableB<'b>> {
|
||||
let a = self.a.as_ref().map(|x|{
|
||||
x.pack(_fbb)
|
||||
});
|
||||
TableB::create(_fbb, &TableBArgs{
|
||||
a,
|
||||
})
|
||||
}
|
||||
}
|
||||
} // pub mod OtherNameSpace
|
||||
} // pub mod MyGame
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
let src = unsafe { ::core::slice::from_raw_parts(self as *const Unused as *const u8, <Self as ::flatbuffers::Push>::size()) };
|
||||
dst.copy_from_slice(src);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn alignment() -> ::flatbuffers::PushAlignment {
|
||||
::flatbuffers::PushAlignment::new(4)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Verifiable for Unused {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.in_buffer::<Self>(pos)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Unused {
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn new(
|
||||
a: i32,
|
||||
) -> Self {
|
||||
let mut s = Self([0; 4]);
|
||||
s.set_a(a);
|
||||
s
|
||||
}
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.OtherNameSpace.Unused"
|
||||
}
|
||||
|
||||
pub fn a(&self) -> i32 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<i32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[0..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_a(&mut self, x: i32) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[0..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> UnusedT {
|
||||
UnusedT {
|
||||
a: self.a(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct UnusedT {
|
||||
pub a: i32,
|
||||
}
|
||||
impl Default for UnusedT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
a: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl UnusedT {
|
||||
pub fn pack(&self) -> Unused {
|
||||
Unused::new(
|
||||
self.a,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
pub enum TableBOffset {}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
pub struct TableB<'a> {
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> {
|
||||
type Inner = TableB<'a>;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> TableB<'a> {
|
||||
pub const VT_A: ::flatbuffers::VOffsetT = 4;
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.OtherNameSpace.TableB"
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
TableB { _tab: table }
|
||||
}
|
||||
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args TableBArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<TableB<'bldr>> {
|
||||
let mut builder = TableBBuilder::new(_fbb);
|
||||
if let Some(x) = args.a { builder.add_a(x); }
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> TableBT {
|
||||
let a = self.a().map(|x| {
|
||||
alloc::boxed::Box::new(x.unpack())
|
||||
});
|
||||
TableBT {
|
||||
a,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn a(&self) -> Option<super::super::TableA<'a>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<super::super::TableA>>(TableB::VT_A, None)}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Verifiable for TableB<'_> {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<super::super::TableA>>("a", Self::VT_A, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TableBArgs<'a> {
|
||||
pub a: Option<::flatbuffers::WIPOffset<super::super::TableA<'a>>>,
|
||||
}
|
||||
|
||||
impl<'a> Default for TableBArgs<'a> {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
TableBArgs {
|
||||
a: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TableBBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
}
|
||||
|
||||
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> {
|
||||
#[inline]
|
||||
pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset<super::super::TableA<'b >>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
TableBBuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<TableB<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for TableB<'_> {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("TableB");
|
||||
ds.field("a", &self.a());
|
||||
ds.finish()
|
||||
}
|
||||
}
|
||||
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct TableBT {
|
||||
pub a: Option<alloc::boxed::Box<super::super::TableAT>>,
|
||||
}
|
||||
|
||||
impl Default for TableBT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
a: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl TableBT {
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<TableB<'b>> {
|
||||
let a = self.a.as_ref().map(|x|{
|
||||
x.pack(_fbb)
|
||||
});
|
||||
TableB::create(_fbb, &TableBArgs{
|
||||
a,
|
||||
})
|
||||
}
|
||||
}
|
||||
} // pub mod OtherNameSpace
|
||||
} // pub mod MyGame
|
||||
|
||||
@@ -1,16 +1,16 @@
|
||||
// Automatically generated by the Flatbuffers compiler. Do not modify.
|
||||
// @generated
|
||||
pub mod my_game {
|
||||
use super::*;
|
||||
pub mod other_name_space {
|
||||
use super::*;
|
||||
mod from_include_generated;
|
||||
pub use self::from_include_generated::*;
|
||||
mod unused_generated;
|
||||
pub use self::unused_generated::*;
|
||||
mod table_b_generated;
|
||||
pub use self::table_b_generated::*;
|
||||
} // other_name_space
|
||||
pub mod other_name_space {
|
||||
use super::*;
|
||||
mod from_include_generated;
|
||||
pub use self::from_include_generated::*;
|
||||
mod unused_generated;
|
||||
pub use self::unused_generated::*;
|
||||
mod table_b_generated;
|
||||
pub use self::table_b_generated::*;
|
||||
} // other_name_space
|
||||
} // my_game
|
||||
mod table_a_generated;
|
||||
pub use self::table_a_generated::*;
|
||||
|
||||
@@ -2,56 +2,65 @@
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
use super::*;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MIN_FROM_INCLUDE: i64 = 0;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MAX_FROM_INCLUDE: i64 = 0;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
#[allow(non_camel_case_types)]
|
||||
pub const ENUM_VALUES_FROM_INCLUDE: [FromInclude; 1] = [
|
||||
FromInclude::IncludeVal,
|
||||
FromInclude::IncludeVal,
|
||||
];
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
|
||||
#[repr(transparent)]
|
||||
pub struct FromInclude(pub i64);
|
||||
|
||||
#[allow(non_upper_case_globals)]
|
||||
impl FromInclude {
|
||||
pub const IncludeVal: Self = Self(0);
|
||||
pub const IncludeVal: Self = Self(0);
|
||||
|
||||
pub const ENUM_MIN: i64 = 0;
|
||||
pub const ENUM_MAX: i64 = 0;
|
||||
pub const ENUM_VALUES: &'static [Self] = &[
|
||||
Self::IncludeVal,
|
||||
];
|
||||
/// Returns the variant's name or "" if unknown.
|
||||
pub fn variant_name(self) -> Option<&'static str> {
|
||||
match self {
|
||||
Self::IncludeVal => Some("IncludeVal"),
|
||||
_ => None,
|
||||
pub const ENUM_MIN: i64 = 0;
|
||||
pub const ENUM_MAX: i64 = 0;
|
||||
pub const ENUM_VALUES: &'static [Self] = &[
|
||||
Self::IncludeVal,
|
||||
];
|
||||
|
||||
/// Returns the variant's name or "" if unknown.
|
||||
pub fn variant_name(self) -> Option<&'static str> {
|
||||
match self {
|
||||
Self::IncludeVal => Some("IncludeVal"),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for FromInclude {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
if let Some(name) = self.variant_name() {
|
||||
f.write_str(name)
|
||||
} else {
|
||||
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
if let Some(name) = self.variant_name() {
|
||||
f.write_str(name)
|
||||
} else {
|
||||
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for FromInclude {
|
||||
type Inner = Self;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
let b = unsafe { ::flatbuffers::read_scalar_at::<i64>(buf, loc) };
|
||||
Self(b)
|
||||
}
|
||||
type Inner = Self;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
let b = unsafe { ::flatbuffers::read_scalar_at::<i64>(buf, loc) };
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Push for FromInclude {
|
||||
type Output = FromInclude;
|
||||
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
unsafe { ::flatbuffers::emplace_scalar::<i64>(dst, self.0) };
|
||||
@@ -59,26 +68,28 @@ impl ::flatbuffers::Push for FromInclude {
|
||||
}
|
||||
|
||||
impl ::flatbuffers::EndianScalar for FromInclude {
|
||||
type Scalar = i64;
|
||||
#[inline]
|
||||
fn to_little_endian(self) -> i64 {
|
||||
self.0.to_le()
|
||||
}
|
||||
#[inline]
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
fn from_little_endian(v: i64) -> Self {
|
||||
let b = i64::from_le(v);
|
||||
Self(b)
|
||||
}
|
||||
type Scalar = i64;
|
||||
|
||||
#[inline]
|
||||
fn to_little_endian(self) -> i64 {
|
||||
self.0.to_le()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
fn from_little_endian(v: i64) -> Self {
|
||||
let b = i64::from_le(v);
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Verifiable for FromInclude {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
i64::run_verifier(v, pos)
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
i64::run_verifier(v, pos)
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {}
|
||||
|
||||
@@ -2,136 +2,147 @@
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
use super::*;
|
||||
pub enum TableBOffset {}
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
|
||||
pub enum TableBOffset {}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
pub struct TableB<'a> {
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> {
|
||||
type Inner = TableB<'a>;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
type Inner = TableB<'a>;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> TableB<'a> {
|
||||
pub const VT_A: ::flatbuffers::VOffsetT = 4;
|
||||
pub const VT_A: ::flatbuffers::VOffsetT = 4;
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.OtherNameSpace.TableB"
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
TableB { _tab: table }
|
||||
}
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args TableBArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<TableB<'bldr>> {
|
||||
let mut builder = TableBBuilder::new(_fbb);
|
||||
if let Some(x) = args.a { builder.add_a(x); }
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> TableBT {
|
||||
let a = self.a().map(|x| {
|
||||
alloc::boxed::Box::new(x.unpack())
|
||||
});
|
||||
TableBT {
|
||||
a,
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.OtherNameSpace.TableB"
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn a(&self) -> Option<super::super::TableA<'a>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<super::super::TableA>>(TableB::VT_A, None)}
|
||||
}
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
TableB { _tab: table }
|
||||
}
|
||||
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args TableBArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<TableB<'bldr>> {
|
||||
let mut builder = TableBBuilder::new(_fbb);
|
||||
if let Some(x) = args.a { builder.add_a(x); }
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> TableBT {
|
||||
let a = self.a().map(|x| {
|
||||
alloc::boxed::Box::new(x.unpack())
|
||||
});
|
||||
TableBT {
|
||||
a,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn a(&self) -> Option<super::super::TableA<'a>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<super::super::TableA>>(TableB::VT_A, None)}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Verifiable for TableB<'_> {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<super::super::TableA>>("a", Self::VT_A, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<super::super::TableA>>("a", Self::VT_A, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TableBArgs<'a> {
|
||||
pub a: Option<::flatbuffers::WIPOffset<super::super::TableA<'a>>>,
|
||||
}
|
||||
|
||||
impl<'a> Default for TableBArgs<'a> {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
TableBArgs {
|
||||
a: None,
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
TableBArgs {
|
||||
a: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TableBBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
}
|
||||
|
||||
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> {
|
||||
#[inline]
|
||||
pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset<super::super::TableA<'b >>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
|
||||
}
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
TableBBuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
#[inline]
|
||||
pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset<super::super::TableA<'b >>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
TableBBuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<TableB<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<TableB<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for TableB<'_> {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("TableB");
|
||||
ds.field("a", &self.a());
|
||||
ds.finish()
|
||||
}
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("TableB");
|
||||
ds.field("a", &self.a());
|
||||
ds.finish()
|
||||
}
|
||||
}
|
||||
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct TableBT {
|
||||
pub a: Option<alloc::boxed::Box<super::super::TableAT>>,
|
||||
pub a: Option<alloc::boxed::Box<super::super::TableAT>>,
|
||||
}
|
||||
|
||||
impl Default for TableBT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
a: None,
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
a: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl TableBT {
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<TableB<'b>> {
|
||||
let a = self.a.as_ref().map(|x|{
|
||||
x.pack(_fbb)
|
||||
});
|
||||
TableB::create(_fbb, &TableBArgs{
|
||||
a,
|
||||
})
|
||||
}
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<TableB<'b>> {
|
||||
let a = self.a.as_ref().map(|x|{
|
||||
x.pack(_fbb)
|
||||
});
|
||||
TableB::create(_fbb, &TableBArgs{
|
||||
a,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,45 +2,55 @@
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
use super::*;
|
||||
|
||||
// struct Unused, aligned to 4
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
pub struct Unused(pub [u8; 4]);
|
||||
impl Default for Unused {
|
||||
fn default() -> Self {
|
||||
Self([0; 4])
|
||||
}
|
||||
|
||||
impl Default for Unused {
|
||||
fn default() -> Self {
|
||||
Self([0; 4])
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for Unused {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
f.debug_struct("Unused")
|
||||
.field("a", &self.a())
|
||||
.finish()
|
||||
}
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
f.debug_struct("Unused")
|
||||
.field("a", &self.a())
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for Unused {}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for Unused {
|
||||
type Inner = &'a Unused;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { <&'a Unused>::follow(buf, loc) }
|
||||
}
|
||||
type Inner = &'a Unused;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { <&'a Unused>::follow(buf, loc) }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for &'a Unused {
|
||||
type Inner = &'a Unused;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { ::flatbuffers::follow_cast_ref::<Unused>(buf, loc) }
|
||||
}
|
||||
type Inner = &'a Unused;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { ::flatbuffers::follow_cast_ref::<Unused>(buf, loc) }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'b> ::flatbuffers::Push for Unused {
|
||||
type Output = Unused;
|
||||
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
let src = unsafe { ::core::slice::from_raw_parts(self as *const Unused as *const u8, <Self as ::flatbuffers::Push>::size()) };
|
||||
dst.copy_from_slice(src);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn alignment() -> ::flatbuffers::PushAlignment {
|
||||
::flatbuffers::PushAlignment::new(4)
|
||||
@@ -48,73 +58,80 @@ impl<'b> ::flatbuffers::Push for Unused {
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Verifiable for Unused {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.in_buffer::<Self>(pos)
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.in_buffer::<Self>(pos)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Unused {
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn new(
|
||||
a: i32,
|
||||
) -> Self {
|
||||
let mut s = Self([0; 4]);
|
||||
s.set_a(a);
|
||||
s
|
||||
}
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.OtherNameSpace.Unused"
|
||||
}
|
||||
|
||||
pub fn a(&self) -> i32 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<i32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[0..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_a(&mut self, x: i32) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[0..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn new(
|
||||
a: i32,
|
||||
) -> Self {
|
||||
let mut s = Self([0; 4]);
|
||||
s.set_a(a);
|
||||
s
|
||||
}
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> UnusedT {
|
||||
UnusedT {
|
||||
a: self.a(),
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.OtherNameSpace.Unused"
|
||||
}
|
||||
|
||||
pub fn a(&self) -> i32 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<i32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[0..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_a(&mut self, x: i32) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[0..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> UnusedT {
|
||||
UnusedT {
|
||||
a: self.a(),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct UnusedT {
|
||||
pub a: i32,
|
||||
pub a: i32,
|
||||
}
|
||||
impl UnusedT {
|
||||
pub fn pack(&self) -> Unused {
|
||||
Unused::new(
|
||||
self.a,
|
||||
)
|
||||
}
|
||||
impl Default for UnusedT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
a: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl UnusedT {
|
||||
pub fn pack(&self) -> Unused {
|
||||
Unused::new(
|
||||
self.a,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,136 +2,147 @@
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
use super::*;
|
||||
pub enum TableAOffset {}
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
|
||||
pub enum TableAOffset {}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
pub struct TableA<'a> {
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for TableA<'a> {
|
||||
type Inner = TableA<'a>;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
type Inner = TableA<'a>;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> TableA<'a> {
|
||||
pub const VT_B: ::flatbuffers::VOffsetT = 4;
|
||||
pub const VT_B: ::flatbuffers::VOffsetT = 4;
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"TableA"
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
TableA { _tab: table }
|
||||
}
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args TableAArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<TableA<'bldr>> {
|
||||
let mut builder = TableABuilder::new(_fbb);
|
||||
if let Some(x) = args.b { builder.add_b(x); }
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> TableAT {
|
||||
let b = self.b().map(|x| {
|
||||
alloc::boxed::Box::new(x.unpack())
|
||||
});
|
||||
TableAT {
|
||||
b,
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"TableA"
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>(TableA::VT_B, None)}
|
||||
}
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
TableA { _tab: table }
|
||||
}
|
||||
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args TableAArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<TableA<'bldr>> {
|
||||
let mut builder = TableABuilder::new(_fbb);
|
||||
if let Some(x) = args.b { builder.add_b(x); }
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> TableAT {
|
||||
let b = self.b().map(|x| {
|
||||
alloc::boxed::Box::new(x.unpack())
|
||||
});
|
||||
TableAT {
|
||||
b,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>(TableA::VT_B, None)}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Verifiable for TableA<'_> {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>("b", Self::VT_B, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>("b", Self::VT_B, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TableAArgs<'a> {
|
||||
pub b: Option<::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'a>>>,
|
||||
}
|
||||
|
||||
impl<'a> Default for TableAArgs<'a> {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
TableAArgs {
|
||||
b: None,
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
TableAArgs {
|
||||
b: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TableABuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
}
|
||||
|
||||
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableABuilder<'a, 'b, A> {
|
||||
#[inline]
|
||||
pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
|
||||
}
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
TableABuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
#[inline]
|
||||
pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
TableABuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<TableA<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<TableA<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for TableA<'_> {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("TableA");
|
||||
ds.field("b", &self.b());
|
||||
ds.finish()
|
||||
}
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("TableA");
|
||||
ds.field("b", &self.b());
|
||||
ds.finish()
|
||||
}
|
||||
}
|
||||
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct TableAT {
|
||||
pub b: Option<alloc::boxed::Box<my_game::other_name_space::TableBT>>,
|
||||
pub b: Option<alloc::boxed::Box<my_game::other_name_space::TableBT>>,
|
||||
}
|
||||
|
||||
impl Default for TableAT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
b: None,
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
b: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl TableAT {
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<TableA<'b>> {
|
||||
let b = self.b.as_ref().map(|x|{
|
||||
x.pack(_fbb)
|
||||
});
|
||||
TableA::create(_fbb, &TableAArgs{
|
||||
b,
|
||||
})
|
||||
}
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<TableA<'b>> {
|
||||
let b = self.b.as_ref().map(|x|{
|
||||
x.pack(_fbb)
|
||||
});
|
||||
TableA::create(_fbb, &TableAArgs{
|
||||
b,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
+450
-404
@@ -1,479 +1,525 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
// @generated
|
||||
|
||||
extern crate alloc;
|
||||
|
||||
pub enum TableAOffset {}
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
pub struct TableA<'a> {
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for TableA<'a> {
|
||||
type Inner = TableA<'a>;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
type Inner = TableA<'a>;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> TableA<'a> {
|
||||
pub const VT_B: ::flatbuffers::VOffsetT = 4;
|
||||
pub const VT_B: ::flatbuffers::VOffsetT = 4;
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"TableA"
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
TableA { _tab: table }
|
||||
}
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args TableAArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<TableA<'bldr>> {
|
||||
let mut builder = TableABuilder::new(_fbb);
|
||||
if let Some(x) = args.b { builder.add_b(x); }
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> TableAT {
|
||||
let b = self.b().map(|x| {
|
||||
alloc::boxed::Box::new(x.unpack())
|
||||
});
|
||||
TableAT {
|
||||
b,
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"TableA"
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>(TableA::VT_B, None)}
|
||||
}
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
TableA { _tab: table }
|
||||
}
|
||||
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args TableAArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<TableA<'bldr>> {
|
||||
let mut builder = TableABuilder::new(_fbb);
|
||||
if let Some(x) = args.b { builder.add_b(x); }
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> TableAT {
|
||||
let b = self.b().map(|x| {
|
||||
alloc::boxed::Box::new(x.unpack())
|
||||
});
|
||||
TableAT {
|
||||
b,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>(TableA::VT_B, None)}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Verifiable for TableA<'_> {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>("b", Self::VT_B, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<my_game::other_name_space::TableB>>("b", Self::VT_B, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TableAArgs<'a> {
|
||||
pub b: Option<::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'a>>>,
|
||||
}
|
||||
|
||||
impl<'a> Default for TableAArgs<'a> {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
TableAArgs {
|
||||
b: None,
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
TableAArgs {
|
||||
b: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TableABuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
}
|
||||
|
||||
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableABuilder<'a, 'b, A> {
|
||||
#[inline]
|
||||
pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
|
||||
}
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
TableABuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
#[inline]
|
||||
pub fn add_b(&mut self, b: ::flatbuffers::WIPOffset<my_game::other_name_space::TableB<'b >>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<my_game::other_name_space::TableB>>(TableA::VT_B, b);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableABuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
TableABuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<TableA<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<TableA<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for TableA<'_> {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("TableA");
|
||||
ds.field("b", &self.b());
|
||||
ds.finish()
|
||||
}
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("TableA");
|
||||
ds.field("b", &self.b());
|
||||
ds.finish()
|
||||
}
|
||||
}
|
||||
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct TableAT {
|
||||
pub b: Option<alloc::boxed::Box<my_game::other_name_space::TableBT>>,
|
||||
pub b: Option<alloc::boxed::Box<my_game::other_name_space::TableBT>>,
|
||||
}
|
||||
|
||||
impl Default for TableAT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
b: None,
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
b: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl TableAT {
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<TableA<'b>> {
|
||||
let b = self.b.as_ref().map(|x|{
|
||||
x.pack(_fbb)
|
||||
});
|
||||
TableA::create(_fbb, &TableAArgs{
|
||||
b,
|
||||
})
|
||||
}
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<TableA<'b>> {
|
||||
let b = self.b.as_ref().map(|x|{
|
||||
x.pack(_fbb)
|
||||
});
|
||||
TableA::create(_fbb, &TableAArgs{
|
||||
b,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unused_imports, dead_code)]
|
||||
pub mod my_game {
|
||||
extern crate alloc;
|
||||
|
||||
extern crate alloc;
|
||||
#[allow(unused_imports, dead_code)]
|
||||
pub mod other_name_space {
|
||||
#[allow(unused_imports, dead_code)]
|
||||
pub mod other_name_space {
|
||||
extern crate alloc;
|
||||
|
||||
extern crate alloc;
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MIN_FROM_INCLUDE: i64 = 0;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MIN_FROM_INCLUDE: i64 = 0;
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MAX_FROM_INCLUDE: i64 = 0;
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
#[allow(non_camel_case_types)]
|
||||
pub const ENUM_VALUES_FROM_INCLUDE: [FromInclude; 1] = [
|
||||
FromInclude::IncludeVal,
|
||||
];
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MAX_FROM_INCLUDE: i64 = 0;
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
|
||||
#[repr(transparent)]
|
||||
pub struct FromInclude(pub i64);
|
||||
#[allow(non_upper_case_globals)]
|
||||
impl FromInclude {
|
||||
pub const IncludeVal: Self = Self(0);
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
#[allow(non_camel_case_types)]
|
||||
pub const ENUM_VALUES_FROM_INCLUDE: [FromInclude; 1] = [
|
||||
FromInclude::IncludeVal,
|
||||
];
|
||||
|
||||
pub const ENUM_MIN: i64 = 0;
|
||||
pub const ENUM_MAX: i64 = 0;
|
||||
pub const ENUM_VALUES: &'static [Self] = &[
|
||||
Self::IncludeVal,
|
||||
];
|
||||
/// Returns the variant's name or "" if unknown.
|
||||
pub fn variant_name(self) -> Option<&'static str> {
|
||||
match self {
|
||||
Self::IncludeVal => Some("IncludeVal"),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
impl ::core::fmt::Debug for FromInclude {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
if let Some(name) = self.variant_name() {
|
||||
f.write_str(name)
|
||||
} else {
|
||||
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<'a> ::flatbuffers::Follow<'a> for FromInclude {
|
||||
type Inner = Self;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
let b = unsafe { ::flatbuffers::read_scalar_at::<i64>(buf, loc) };
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
|
||||
#[repr(transparent)]
|
||||
pub struct FromInclude(pub i64);
|
||||
|
||||
impl ::flatbuffers::Push for FromInclude {
|
||||
type Output = FromInclude;
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
unsafe { ::flatbuffers::emplace_scalar::<i64>(dst, self.0) };
|
||||
}
|
||||
}
|
||||
#[allow(non_upper_case_globals)]
|
||||
impl FromInclude {
|
||||
pub const IncludeVal: Self = Self(0);
|
||||
|
||||
impl ::flatbuffers::EndianScalar for FromInclude {
|
||||
type Scalar = i64;
|
||||
#[inline]
|
||||
fn to_little_endian(self) -> i64 {
|
||||
self.0.to_le()
|
||||
}
|
||||
#[inline]
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
fn from_little_endian(v: i64) -> Self {
|
||||
let b = i64::from_le(v);
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
pub const ENUM_MIN: i64 = 0;
|
||||
pub const ENUM_MAX: i64 = 0;
|
||||
pub const ENUM_VALUES: &'static [Self] = &[
|
||||
Self::IncludeVal,
|
||||
];
|
||||
|
||||
impl<'a> ::flatbuffers::Verifiable for FromInclude {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
i64::run_verifier(v, pos)
|
||||
}
|
||||
}
|
||||
/// Returns the variant's name or "" if unknown.
|
||||
pub fn variant_name(self) -> Option<&'static str> {
|
||||
match self {
|
||||
Self::IncludeVal => Some("IncludeVal"),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {}
|
||||
// struct Unused, aligned to 4
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
pub struct Unused(pub [u8; 4]);
|
||||
impl Default for Unused {
|
||||
fn default() -> Self {
|
||||
Self([0; 4])
|
||||
}
|
||||
}
|
||||
impl ::core::fmt::Debug for Unused {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
f.debug_struct("Unused")
|
||||
.field("a", &self.a())
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
impl ::core::fmt::Debug for FromInclude {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
if let Some(name) = self.variant_name() {
|
||||
f.write_str(name)
|
||||
} else {
|
||||
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for Unused {}
|
||||
impl<'a> ::flatbuffers::Follow<'a> for Unused {
|
||||
type Inner = &'a Unused;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { <&'a Unused>::follow(buf, loc) }
|
||||
}
|
||||
}
|
||||
impl<'a> ::flatbuffers::Follow<'a> for &'a Unused {
|
||||
type Inner = &'a Unused;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { ::flatbuffers::follow_cast_ref::<Unused>(buf, loc) }
|
||||
}
|
||||
}
|
||||
impl<'b> ::flatbuffers::Push for Unused {
|
||||
type Output = Unused;
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
let src = unsafe { ::core::slice::from_raw_parts(self as *const Unused as *const u8, <Self as ::flatbuffers::Push>::size()) };
|
||||
dst.copy_from_slice(src);
|
||||
}
|
||||
#[inline]
|
||||
fn alignment() -> ::flatbuffers::PushAlignment {
|
||||
::flatbuffers::PushAlignment::new(4)
|
||||
}
|
||||
}
|
||||
impl<'a> ::flatbuffers::Follow<'a> for FromInclude {
|
||||
type Inner = Self;
|
||||
|
||||
impl<'a> ::flatbuffers::Verifiable for Unused {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.in_buffer::<Self>(pos)
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
let b = unsafe { ::flatbuffers::read_scalar_at::<i64>(buf, loc) };
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Unused {
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn new(
|
||||
a: i32,
|
||||
) -> Self {
|
||||
let mut s = Self([0; 4]);
|
||||
s.set_a(a);
|
||||
s
|
||||
}
|
||||
impl ::flatbuffers::Push for FromInclude {
|
||||
type Output = FromInclude;
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.OtherNameSpace.Unused"
|
||||
}
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
unsafe { ::flatbuffers::emplace_scalar::<i64>(dst, self.0) };
|
||||
}
|
||||
}
|
||||
|
||||
pub fn a(&self) -> i32 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<i32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[0..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
impl ::flatbuffers::EndianScalar for FromInclude {
|
||||
type Scalar = i64;
|
||||
|
||||
pub fn set_a(&mut self, x: i32) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[0..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
fn to_little_endian(self) -> i64 {
|
||||
self.0.to_le()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> UnusedT {
|
||||
UnusedT {
|
||||
a: self.a(),
|
||||
}
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
fn from_little_endian(v: i64) -> Self {
|
||||
let b = i64::from_le(v);
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
pub struct UnusedT {
|
||||
pub a: i32,
|
||||
}
|
||||
impl UnusedT {
|
||||
pub fn pack(&self) -> Unused {
|
||||
Unused::new(
|
||||
self.a,
|
||||
)
|
||||
}
|
||||
}
|
||||
impl<'a> ::flatbuffers::Verifiable for FromInclude {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
i64::run_verifier(v, pos)
|
||||
}
|
||||
}
|
||||
|
||||
pub enum TableBOffset {}
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for FromInclude {}
|
||||
|
||||
pub struct TableB<'a> {
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
}
|
||||
// struct Unused, aligned to 4
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
pub struct Unused(pub [u8; 4]);
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> {
|
||||
type Inner = TableB<'a>;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
}
|
||||
impl Default for Unused {
|
||||
fn default() -> Self {
|
||||
Self([0; 4])
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> TableB<'a> {
|
||||
pub const VT_A: ::flatbuffers::VOffsetT = 4;
|
||||
impl ::core::fmt::Debug for Unused {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
f.debug_struct("Unused")
|
||||
.field("a", &self.a())
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.OtherNameSpace.TableB"
|
||||
}
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for Unused {}
|
||||
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
TableB { _tab: table }
|
||||
}
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args TableBArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<TableB<'bldr>> {
|
||||
let mut builder = TableBBuilder::new(_fbb);
|
||||
if let Some(x) = args.a { builder.add_a(x); }
|
||||
builder.finish()
|
||||
}
|
||||
impl<'a> ::flatbuffers::Follow<'a> for Unused {
|
||||
type Inner = &'a Unused;
|
||||
|
||||
pub fn unpack(&self) -> TableBT {
|
||||
let a = self.a().map(|x| {
|
||||
alloc::boxed::Box::new(x.unpack())
|
||||
});
|
||||
TableBT {
|
||||
a,
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { <&'a Unused>::follow(buf, loc) }
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn a(&self) -> Option<super::super::TableA<'a>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<super::super::TableA>>(TableB::VT_A, None)}
|
||||
}
|
||||
}
|
||||
impl<'a> ::flatbuffers::Follow<'a> for &'a Unused {
|
||||
type Inner = &'a Unused;
|
||||
|
||||
impl ::flatbuffers::Verifiable for TableB<'_> {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<super::super::TableA>>("a", Self::VT_A, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
pub struct TableBArgs<'a> {
|
||||
pub a: Option<::flatbuffers::WIPOffset<super::super::TableA<'a>>>,
|
||||
}
|
||||
impl<'a> Default for TableBArgs<'a> {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
TableBArgs {
|
||||
a: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
unsafe { ::flatbuffers::follow_cast_ref::<Unused>(buf, loc) }
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TableBBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
}
|
||||
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> {
|
||||
#[inline]
|
||||
pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset<super::super::TableA<'b >>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
|
||||
}
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
TableBBuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<TableB<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
impl<'b> ::flatbuffers::Push for Unused {
|
||||
type Output = Unused;
|
||||
|
||||
impl ::core::fmt::Debug for TableB<'_> {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("TableB");
|
||||
ds.field("a", &self.a());
|
||||
ds.finish()
|
||||
}
|
||||
}
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct TableBT {
|
||||
pub a: Option<alloc::boxed::Box<super::super::TableAT>>,
|
||||
}
|
||||
impl Default for TableBT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
a: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
impl TableBT {
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<TableB<'b>> {
|
||||
let a = self.a.as_ref().map(|x|{
|
||||
x.pack(_fbb)
|
||||
});
|
||||
TableB::create(_fbb, &TableBArgs{
|
||||
a,
|
||||
})
|
||||
}
|
||||
}
|
||||
} // pub mod OtherNameSpace
|
||||
} // pub mod MyGame
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
let src = unsafe { ::core::slice::from_raw_parts(self as *const Unused as *const u8, <Self as ::flatbuffers::Push>::size()) };
|
||||
dst.copy_from_slice(src);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn alignment() -> ::flatbuffers::PushAlignment {
|
||||
::flatbuffers::PushAlignment::new(4)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Verifiable for Unused {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.in_buffer::<Self>(pos)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Unused {
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn new(
|
||||
a: i32,
|
||||
) -> Self {
|
||||
let mut s = Self([0; 4]);
|
||||
s.set_a(a);
|
||||
s
|
||||
}
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.OtherNameSpace.Unused"
|
||||
}
|
||||
|
||||
pub fn a(&self) -> i32 {
|
||||
let mut mem = ::core::mem::MaybeUninit::<<i32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
::flatbuffers::EndianScalar::from_little_endian(unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
self.0[0..].as_ptr(),
|
||||
mem.as_mut_ptr() as *mut u8,
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
mem.assume_init()
|
||||
})
|
||||
}
|
||||
|
||||
pub fn set_a(&mut self, x: i32) {
|
||||
let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
|
||||
// Safety:
|
||||
// Created from a valid Table for this object
|
||||
// Which contains a valid value in this slot
|
||||
unsafe {
|
||||
::core::ptr::copy_nonoverlapping(
|
||||
&x_le as *const _ as *const u8,
|
||||
self.0[0..].as_mut_ptr(),
|
||||
::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> UnusedT {
|
||||
UnusedT {
|
||||
a: self.a(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct UnusedT {
|
||||
pub a: i32,
|
||||
}
|
||||
impl Default for UnusedT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
a: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl UnusedT {
|
||||
pub fn pack(&self) -> Unused {
|
||||
Unused::new(
|
||||
self.a,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
pub enum TableBOffset {}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
pub struct TableB<'a> {
|
||||
pub _tab: ::flatbuffers::Table<'a>,
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for TableB<'a> {
|
||||
type Inner = TableB<'a>;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> TableB<'a> {
|
||||
pub const VT_A: ::flatbuffers::VOffsetT = 4;
|
||||
|
||||
pub const fn get_fully_qualified_name() -> &'static str {
|
||||
"MyGame.OtherNameSpace.TableB"
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
|
||||
TableB { _tab: table }
|
||||
}
|
||||
|
||||
#[allow(unused_mut)]
|
||||
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
|
||||
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
|
||||
args: &'args TableBArgs<'args>
|
||||
) -> ::flatbuffers::WIPOffset<TableB<'bldr>> {
|
||||
let mut builder = TableBBuilder::new(_fbb);
|
||||
if let Some(x) = args.a { builder.add_a(x); }
|
||||
builder.finish()
|
||||
}
|
||||
|
||||
pub fn unpack(&self) -> TableBT {
|
||||
let a = self.a().map(|x| {
|
||||
alloc::boxed::Box::new(x.unpack())
|
||||
});
|
||||
TableBT {
|
||||
a,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn a(&self) -> Option<super::super::TableA<'a>> {
|
||||
// Safety:
|
||||
// Created from valid Table for this object
|
||||
// which contains a valid value in this slot
|
||||
unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<super::super::TableA>>(TableB::VT_A, None)}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Verifiable for TableB<'_> {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
v.visit_table(pos)?
|
||||
.visit_field::<::flatbuffers::ForwardsUOffset<super::super::TableA>>("a", Self::VT_A, false)?
|
||||
.finish();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TableBArgs<'a> {
|
||||
pub a: Option<::flatbuffers::WIPOffset<super::super::TableA<'a>>>,
|
||||
}
|
||||
|
||||
impl<'a> Default for TableBArgs<'a> {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
TableBArgs {
|
||||
a: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TableBBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
|
||||
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
|
||||
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
|
||||
}
|
||||
|
||||
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TableBBuilder<'a, 'b, A> {
|
||||
#[inline]
|
||||
pub fn add_a(&mut self, a: ::flatbuffers::WIPOffset<super::super::TableA<'b >>) {
|
||||
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<super::super::TableA>>(TableB::VT_A, a);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TableBBuilder<'a, 'b, A> {
|
||||
let start = _fbb.start_table();
|
||||
TableBBuilder {
|
||||
fbb_: _fbb,
|
||||
start_: start,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn finish(self) -> ::flatbuffers::WIPOffset<TableB<'a>> {
|
||||
let o = self.fbb_.end_table(self.start_);
|
||||
::flatbuffers::WIPOffset::new(o.value())
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for TableB<'_> {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
|
||||
let mut ds = f.debug_struct("TableB");
|
||||
ds.field("a", &self.a());
|
||||
ds.finish()
|
||||
}
|
||||
}
|
||||
|
||||
#[non_exhaustive]
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct TableBT {
|
||||
pub a: Option<alloc::boxed::Box<super::super::TableAT>>,
|
||||
}
|
||||
|
||||
impl Default for TableBT {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
a: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl TableBT {
|
||||
pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
|
||||
&self,
|
||||
_fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
|
||||
) -> ::flatbuffers::WIPOffset<TableB<'b>> {
|
||||
let a = self.a.as_ref().map(|x|{
|
||||
x.pack(_fbb)
|
||||
});
|
||||
TableB::create(_fbb, &TableBArgs{
|
||||
a,
|
||||
})
|
||||
}
|
||||
}
|
||||
} // pub mod OtherNameSpace
|
||||
} // pub mod MyGame
|
||||
|
||||
@@ -2,64 +2,73 @@
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
use super::*;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MIN_ABC: i32 = 0;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MAX_ABC: i32 = 2;
|
||||
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
#[allow(non_camel_case_types)]
|
||||
pub const ENUM_VALUES_ABC: [ABC; 3] = [
|
||||
ABC::void,
|
||||
ABC::where_,
|
||||
ABC::stackalloc,
|
||||
ABC::void,
|
||||
ABC::where_,
|
||||
ABC::stackalloc,
|
||||
];
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
|
||||
#[repr(transparent)]
|
||||
pub struct ABC(pub i32);
|
||||
|
||||
#[allow(non_upper_case_globals)]
|
||||
impl ABC {
|
||||
pub const void: Self = Self(0);
|
||||
pub const where_: Self = Self(1);
|
||||
pub const stackalloc: Self = Self(2);
|
||||
pub const void: Self = Self(0);
|
||||
pub const where_: Self = Self(1);
|
||||
pub const stackalloc: Self = Self(2);
|
||||
|
||||
pub const ENUM_MIN: i32 = 0;
|
||||
pub const ENUM_MAX: i32 = 2;
|
||||
pub const ENUM_VALUES: &'static [Self] = &[
|
||||
Self::void,
|
||||
Self::where_,
|
||||
Self::stackalloc,
|
||||
];
|
||||
/// Returns the variant's name or "" if unknown.
|
||||
pub fn variant_name(self) -> Option<&'static str> {
|
||||
match self {
|
||||
Self::void => Some("void"),
|
||||
Self::where_ => Some("where_"),
|
||||
Self::stackalloc => Some("stackalloc"),
|
||||
_ => None,
|
||||
pub const ENUM_MIN: i32 = 0;
|
||||
pub const ENUM_MAX: i32 = 2;
|
||||
pub const ENUM_VALUES: &'static [Self] = &[
|
||||
Self::void,
|
||||
Self::where_,
|
||||
Self::stackalloc,
|
||||
];
|
||||
|
||||
/// Returns the variant's name or "" if unknown.
|
||||
pub fn variant_name(self) -> Option<&'static str> {
|
||||
match self {
|
||||
Self::void => Some("void"),
|
||||
Self::where_ => Some("where_"),
|
||||
Self::stackalloc => Some("stackalloc"),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ::core::fmt::Debug for ABC {
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
if let Some(name) = self.variant_name() {
|
||||
f.write_str(name)
|
||||
} else {
|
||||
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
|
||||
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
|
||||
if let Some(name) = self.variant_name() {
|
||||
f.write_str(name)
|
||||
} else {
|
||||
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Follow<'a> for ABC {
|
||||
type Inner = Self;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
let b = unsafe { ::flatbuffers::read_scalar_at::<i32>(buf, loc) };
|
||||
Self(b)
|
||||
}
|
||||
type Inner = Self;
|
||||
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
let b = unsafe { ::flatbuffers::read_scalar_at::<i32>(buf, loc) };
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::Push for ABC {
|
||||
type Output = ABC;
|
||||
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
unsafe { ::flatbuffers::emplace_scalar::<i32>(dst, self.0) };
|
||||
@@ -67,26 +76,28 @@ impl ::flatbuffers::Push for ABC {
|
||||
}
|
||||
|
||||
impl ::flatbuffers::EndianScalar for ABC {
|
||||
type Scalar = i32;
|
||||
#[inline]
|
||||
fn to_little_endian(self) -> i32 {
|
||||
self.0.to_le()
|
||||
}
|
||||
#[inline]
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
fn from_little_endian(v: i32) -> Self {
|
||||
let b = i32::from_le(v);
|
||||
Self(b)
|
||||
}
|
||||
type Scalar = i32;
|
||||
|
||||
#[inline]
|
||||
fn to_little_endian(self) -> i32 {
|
||||
self.0.to_le()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
fn from_little_endian(v: i32) -> Self {
|
||||
let b = i32::from_le(v);
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> ::flatbuffers::Verifiable for ABC {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
i32::run_verifier(v, pos)
|
||||
}
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut ::flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
|
||||
i32::run_verifier(v, pos)
|
||||
}
|
||||
}
|
||||
|
||||
impl ::flatbuffers::SimpleToVerifyInSlice for ABC {}
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user