BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-07-03 16:04:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor idl_gen_rust and Rust generated code to use consistent whitespace (#6809)

Browse Source 
* Remove dead code in idl_gen_rust

* Use 2space indentation in mod.rs

* use In/DecrementIdentValue in idl_gen_rust

Fix some whitespace too in generated code.

* make default fn 2space ident

* More 2space formatting

* git clang format

* make vs2015 happy

Co-authored-by: Casper Neo <cneo@google.com>
This commit is contained in:
Casper
2021-08-23 18:53:10 -04:00
committed by GitHub
parent 273f6084e5
commit f89e0b1a6c
42 changed files with 1904 additions and 1879 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
samples/rust_generated/my_game/sample/monster_generated.rs
View File

@@ -20,6 +20,17 @@ impl<'a> flatbuffers::Follow<'a> for Monster<'a> {
} }
impl<'a> Monster<'a> { 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 fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"MyGame.Sample.Monster" "MyGame.Sample.Monster"
} }
@@ -31,7 +42,8 @@ impl<'a> Monster<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args MonsterArgs<'args>) -> flatbuffers::WIPOffset<Monster<'bldr>> { args: &'args MonsterArgs<'args>
) -> flatbuffers::WIPOffset<Monster<'bldr>> {
let mut builder = MonsterBuilder::new(_fbb); let mut builder = MonsterBuilder::new(_fbb);
if let Some(x) = args.path { builder.add_path(x); } 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.equipped { builder.add_equipped(x); }
@@ -86,16 +98,6 @@ impl<'a> Monster<'a> {
path, path,
} }
} }
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;
#[inline] #[inline]
pub fn pos(&self) -> Option<&'a Vec3> { pub fn pos(&self) -> Option<&'a Vec3> {

8
samples/rust_generated/my_game/sample/weapon_generated.rs
View File

@@ -20,6 +20,9 @@ impl<'a> flatbuffers::Follow<'a> for Weapon<'a> {
} }
impl<'a> Weapon<'a> { impl<'a> Weapon<'a> {
pub const VT_NAME: flatbuffers::VOffsetT = 4;
pub const VT_DAMAGE: flatbuffers::VOffsetT = 6;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"MyGame.Sample.Weapon" "MyGame.Sample.Weapon"
} }
@@ -31,7 +34,8 @@ impl<'a> Weapon<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args WeaponArgs<'args>) -> flatbuffers::WIPOffset<Weapon<'bldr>> { args: &'args WeaponArgs<'args>
) -> flatbuffers::WIPOffset<Weapon<'bldr>> {
let mut builder = WeaponBuilder::new(_fbb); let mut builder = WeaponBuilder::new(_fbb);
if let Some(x) = args.name { builder.add_name(x); } if let Some(x) = args.name { builder.add_name(x); }
builder.add_damage(args.damage); builder.add_damage(args.damage);
@@ -48,8 +52,6 @@ impl<'a> Weapon<'a> {
damage, damage,
} }
} }
pub const VT_NAME: flatbuffers::VOffsetT = 4;
pub const VT_DAMAGE: flatbuffers::VOffsetT = 6;
#[inline] #[inline]
pub fn name(&self) -> Option<&'a str> { pub fn name(&self) -> Option<&'a str> {

189
src/idl_gen_rust.cpp
View File

@@ -182,31 +182,9 @@ FullType GetFullType(const Type &type) {
return ftBool; return ftBool;
} }
// If the second parameter is false then wrap the first with Option<...>
std::string WrapInOptionIfNotRequired(std::string s, bool required) {
if (required) {
return s;
} else {
return "Option<" + s + ">";
}
}
// If the second parameter is false then add .unwrap()
std::string AddUnwrapIfRequired(std::string s, bool required) {
if (required) {
return s + ".unwrap()";
} else {
return s;
}
}
bool IsBitFlagsEnum(const EnumDef &enum_def) { bool IsBitFlagsEnum(const EnumDef &enum_def) {
return enum_def.attributes.Lookup("bit_flags") != nullptr; return enum_def.attributes.Lookup("bit_flags") != nullptr;
} }
bool IsBitFlagsEnum(const FieldDef &field) {
EnumDef *ed = field.value.type.enum_def;
return ed && IsBitFlagsEnum(*ed);
}
// TableArgs make required non-scalars "Option<_>". // TableArgs make required non-scalars "Option<_>".
// TODO(cneo): Rework how we do defaults and stuff. // TODO(cneo): Rework how we do defaults and stuff.
@@ -384,6 +362,7 @@ class RustGenerator : public BaseGenerator {
// clang-format on // clang-format on
}; };
for (auto kw = keywords; *kw; kw++) keywords_.insert(*kw); for (auto kw = keywords; *kw; kw++) keywords_.insert(*kw);
code_.SetPadding(" ");
} }
bool generate() { bool generate() {
@@ -639,9 +618,9 @@ class RustGenerator : public BaseGenerator {
// Generate a comment from the schema. // Generate a comment from the schema.
void GenComment(const std::vector<std::string> &dc, const char *prefix = "") { void GenComment(const std::vector<std::string> &dc, const char *prefix = "") {
std::string text; for (auto it = dc.begin(); it != dc.end(); it++) {
::flatbuffers::GenComment(dc, &text, nullptr, prefix); code_ += std::string(prefix) + "///" + *it;
code_ += text + "\\"; }
} }
// Return a Rust type from the table in idl.h. // Return a Rust type from the table in idl.h.
@@ -738,7 +717,9 @@ class RustGenerator : public BaseGenerator {
const auto &ev = **it; const auto &ev = **it;
code_.SetValue("VARIANT", Name(ev)); code_.SetValue("VARIANT", Name(ev));
code_.SetValue("VALUE", enum_def.ToString(ev)); code_.SetValue("VALUE", enum_def.ToString(ev));
code_.IncrementIdentLevel();
cb(ev); cb(ev);
code_.DecrementIdentLevel();
} }
} }
void ForAllEnumValues(const EnumDef &enum_def, std::function<void()> cb) { void ForAllEnumValues(const EnumDef &enum_def, std::function<void()> cb) {
@@ -806,7 +787,7 @@ class RustGenerator : public BaseGenerator {
code_ += "pub const ENUM_VALUES_{{ENUM_NAME_CAPS}}: [{{ENUM_NAME}}; " + code_ += "pub const ENUM_VALUES_{{ENUM_NAME_CAPS}}: [{{ENUM_NAME}}; " +
num_fields + "] = ["; num_fields + "] = [";
ForAllEnumValues1(enum_def, [&](const EnumVal &ev) { ForAllEnumValues1(enum_def, [&](const EnumVal &ev) {
code_ += " " + GetEnumValue(enum_def, ev) + ","; code_ += GetEnumValue(enum_def, ev) + ",";
}); });
code_ += "];"; code_ += "];";
code_ += ""; code_ += "";
@@ -823,8 +804,8 @@ class RustGenerator : public BaseGenerator {
code_ += "#[allow(non_upper_case_globals)]"; code_ += "#[allow(non_upper_case_globals)]";
code_ += "impl {{ENUM_NAME}} {"; code_ += "impl {{ENUM_NAME}} {";
ForAllEnumValues1(enum_def, [&](const EnumVal &ev) { ForAllEnumValues1(enum_def, [&](const EnumVal &ev) {
this->GenComment(ev.doc_comment, " "); this->GenComment(ev.doc_comment);
code_ += " pub const {{VARIANT}}: Self = Self({{VALUE}});"; code_ += "pub const {{VARIANT}}: Self = Self({{VALUE}});";
}); });
code_ += ""; code_ += "";
// Generate Associated constants // Generate Associated constants
@@ -933,7 +914,9 @@ class RustGenerator : public BaseGenerator {
code_.SetValue("U_ELEMENT_NAME", MakeSnakeCase(Name(enum_val))); code_.SetValue("U_ELEMENT_NAME", MakeSnakeCase(Name(enum_val)));
code_.SetValue("U_ELEMENT_TABLE_TYPE", code_.SetValue("U_ELEMENT_TABLE_TYPE",
NamespacedNativeName(*enum_val.union_type.struct_def)); NamespacedNativeName(*enum_val.union_type.struct_def));
code_.IncrementIdentLevel();
cb(); cb();
code_.DecrementIdentLevel();
} }
} }
void GenUnionObject(const EnumDef &enum_def) { void GenUnionObject(const EnumDef &enum_def) {
@@ -949,7 +932,7 @@ class RustGenerator : public BaseGenerator {
code_ += "pub enum {{NATIVE_NAME}} {"; code_ += "pub enum {{NATIVE_NAME}} {";
code_ += " NONE,"; code_ += " NONE,";
ForAllUnionObjectVariantsBesidesNone(enum_def, [&] { ForAllUnionObjectVariantsBesidesNone(enum_def, [&] {
code_ += " {{NATIVE_VARIANT}}(Box<{{U_ELEMENT_TABLE_TYPE}}>),"; code_ += "{{NATIVE_VARIANT}}(Box<{{U_ELEMENT_TABLE_TYPE}}>),";
}); });
code_ += "}"; code_ += "}";
// Generate Default (NONE). // Generate Default (NONE).
@@ -982,9 +965,8 @@ class RustGenerator : public BaseGenerator {
code_ += " match self {"; code_ += " match self {";
code_ += " Self::NONE => None,"; code_ += " Self::NONE => None,";
ForAllUnionObjectVariantsBesidesNone(enum_def, [&] { ForAllUnionObjectVariantsBesidesNone(enum_def, [&] {
code_ += code_ += " Self::{{NATIVE_VARIANT}}(v) => \\";
" Self::{{NATIVE_VARIANT}}(v) => " code_ += "Some(v.pack(fbb).as_union_value()),";
"Some(v.pack(fbb).as_union_value()),";
}); });
code_ += " }"; code_ += " }";
code_ += " }"; code_ += " }";
@@ -993,10 +975,10 @@ class RustGenerator : public BaseGenerator {
ForAllUnionObjectVariantsBesidesNone(enum_def, [&] { ForAllUnionObjectVariantsBesidesNone(enum_def, [&] {
// Move accessor. // Move accessor.
code_ += code_ +=
" /// If the union variant matches, return the owned " "/// If the union variant matches, return the owned "
"{{U_ELEMENT_TABLE_TYPE}}, setting the union to NONE."; "{{U_ELEMENT_TABLE_TYPE}}, setting the union to NONE.";
code_ += code_ +=
" pub fn take_{{U_ELEMENT_NAME}}(&mut self) -> " "pub fn take_{{U_ELEMENT_NAME}}(&mut self) -> "
"Option<Box<{{U_ELEMENT_TABLE_TYPE}}>> {"; "Option<Box<{{U_ELEMENT_TABLE_TYPE}}>> {";
code_ += " if let Self::{{NATIVE_VARIANT}}(_) = self {"; code_ += " if let Self::{{NATIVE_VARIANT}}(_) = self {";
code_ += " let v = std::mem::replace(self, Self::NONE);"; code_ += " let v = std::mem::replace(self, Self::NONE);";
@@ -1008,29 +990,29 @@ class RustGenerator : public BaseGenerator {
code_ += " } else {"; code_ += " } else {";
code_ += " None"; code_ += " None";
code_ += " }"; code_ += " }";
code_ += " }"; code_ += "}";
// Immutable reference accessor. // Immutable reference accessor.
code_ += code_ +=
" /// If the union variant matches, return a reference to the " "/// If the union variant matches, return a reference to the "
"{{U_ELEMENT_TABLE_TYPE}}."; "{{U_ELEMENT_TABLE_TYPE}}.";
code_ += code_ +=
" pub fn as_{{U_ELEMENT_NAME}}(&self) -> " "pub fn as_{{U_ELEMENT_NAME}}(&self) -> "
"Option<&{{U_ELEMENT_TABLE_TYPE}}> {"; "Option<&{{U_ELEMENT_TABLE_TYPE}}> {";
code_ += code_ +=
" if let Self::{{NATIVE_VARIANT}}(v) = self " " if let Self::{{NATIVE_VARIANT}}(v) = self "
"{ Some(v.as_ref()) } else { None }"; "{ Some(v.as_ref()) } else { None }";
code_ += " }"; code_ += "}";
// Mutable reference accessor. // Mutable reference accessor.
code_ += code_ +=
" /// If the union variant matches, return a mutable reference" "/// If the union variant matches, return a mutable reference"
" to the {{U_ELEMENT_TABLE_TYPE}}."; " to the {{U_ELEMENT_TABLE_TYPE}}.";
code_ += code_ +=
" pub fn as_{{U_ELEMENT_NAME}}_mut(&mut self) -> " "pub fn as_{{U_ELEMENT_NAME}}_mut(&mut self) -> "
"Option<&mut {{U_ELEMENT_TABLE_TYPE}}> {"; "Option<&mut {{U_ELEMENT_TABLE_TYPE}}> {";
code_ += code_ +=
" if let Self::{{NATIVE_VARIANT}}(v) = self " " if let Self::{{NATIVE_VARIANT}}(v) = self "
"{ Some(v.as_mut()) } else { None }"; "{ Some(v.as_mut()) } else { None }";
code_ += " }"; code_ += "}";
}); });
code_ += "}"; // End union methods impl. code_ += "}"; // End union methods impl.
} }
@@ -1600,9 +1582,10 @@ class RustGenerator : public BaseGenerator {
// Generates a fully-qualified name getter for use with --gen-name-strings // Generates a fully-qualified name getter for use with --gen-name-strings
void GenFullyQualifiedNameGetter(const StructDef &struct_def, void GenFullyQualifiedNameGetter(const StructDef &struct_def,
const std::string &name) { const std::string &name) {
const std::string fully_qualified_name =
struct_def.defined_namespace->GetFullyQualifiedName(name);
code_ += " pub const fn get_fully_qualified_name() -> &'static str {"; code_ += " pub const fn get_fully_qualified_name() -> &'static str {";
code_ += " \"" + code_ += " \"" + fully_qualified_name + "\"";
struct_def.defined_namespace->GetFullyQualifiedName(name) + "\"";
code_ += " }"; code_ += " }";
code_ += ""; code_ += "";
} }
@@ -1639,7 +1622,9 @@ class RustGenerator : public BaseGenerator {
code_.SetValue("FIELD_NAME", Name(field)); code_.SetValue("FIELD_NAME", Name(field));
code_.SetValue("BLDR_DEF_VAL", GetDefaultValue(field, kBuilder)); code_.SetValue("BLDR_DEF_VAL", GetDefaultValue(field, kBuilder));
code_.SetValue("DISCRIMINANT", UnionTypeFieldName(field)); code_.SetValue("DISCRIMINANT", UnionTypeFieldName(field));
code_.IncrementIdentLevel();
cb(field); cb(field);
code_.DecrementIdentLevel();
}; };
const auto &fields = struct_def.fields.vec; const auto &fields = struct_def.fields.vec;
if (reversed) { if (reversed) {
@@ -1677,6 +1662,15 @@ class RustGenerator : public BaseGenerator {
code_ += ""; code_ += "";
code_ += "impl<'a> {{STRUCT_NAME}}<'a> {"; code_ += "impl<'a> {{STRUCT_NAME}}<'a> {";
// Generate field id constants.
ForAllTableFields(struct_def, [&](const FieldDef &unused) {
(void)unused;
code_ +=
"pub const {{OFFSET_NAME}}: flatbuffers::VOffsetT = "
"{{OFFSET_VALUE}};";
});
code_ += "";
if (parser_.opts.generate_name_strings) { if (parser_.opts.generate_name_strings) {
GenFullyQualifiedNameGetter(struct_def, struct_def.name); GenFullyQualifiedNameGetter(struct_def, struct_def.name);
} }
@@ -1695,12 +1689,9 @@ class RustGenerator : public BaseGenerator {
TableBuilderArgsNeedsLifetime(struct_def) ? "<'args>" : ""); TableBuilderArgsNeedsLifetime(struct_def) ? "<'args>" : "");
code_ += " #[allow(unused_mut)]"; code_ += " #[allow(unused_mut)]";
code_ += " pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>("; code_ += " pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(";
code_ += code_ += " _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,";
" _fbb: " code_ += " {{MAYBE_US}}args: &'args {{STRUCT_NAME}}Args{{MAYBE_LT}}";
"&'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,"; code_ += " ) -> flatbuffers::WIPOffset<{{STRUCT_NAME}}<'bldr>> {";
code_ +=
" {{MAYBE_US}}args: &'args {{STRUCT_NAME}}Args{{MAYBE_LT}})"
" -> flatbuffers::WIPOffset<{{STRUCT_NAME}}<'bldr>> {";
code_ += " let mut builder = {{STRUCT_NAME}}Builder::new(_fbb);"; code_ += " let mut builder = {{STRUCT_NAME}}Builder::new(_fbb);";
for (size_t size = struct_def.sortbysize ? sizeof(largest_scalar_t) : 1; for (size_t size = struct_def.sortbysize ? sizeof(largest_scalar_t) : 1;
@@ -1746,18 +1737,13 @@ class RustGenerator : public BaseGenerator {
code_.SetValue("ENUM_NAME", WrapInNameSpace(enum_def)); code_.SetValue("ENUM_NAME", WrapInNameSpace(enum_def));
code_.SetValue("NATIVE_ENUM_NAME", NamespacedNativeName(enum_def)); code_.SetValue("NATIVE_ENUM_NAME", NamespacedNativeName(enum_def));
code_ += code_ +=
" let {{FIELD_NAME}} = match " " let {{FIELD_NAME}} = match self.{{FIELD_NAME}}_type() {";
"self.{{FIELD_NAME}}_type() {"; code_ += " {{ENUM_NAME}}::NONE => {{NATIVE_ENUM_NAME}}::NONE,";
code_ +=
" {{ENUM_NAME}}::NONE =>"
" {{NATIVE_ENUM_NAME}}::NONE,";
ForAllUnionObjectVariantsBesidesNone(enum_def, [&] { ForAllUnionObjectVariantsBesidesNone(enum_def, [&] {
code_ += code_ +=
" {{ENUM_NAME}}::{{VARIANT_NAME}} => " " {{ENUM_NAME}}::{{VARIANT_NAME}} => "
"{{NATIVE_ENUM_NAME}}::{{NATIVE_VARIANT}}(Box::new("; "{{NATIVE_ENUM_NAME}}::{{NATIVE_VARIANT}}(Box::new(";
code_ += code_ += " self.{{FIELD_NAME}}_as_{{U_ELEMENT_NAME}}()";
" self.{{FIELD_NAME}}_as_"
"{{U_ELEMENT_NAME}}()";
code_ += code_ +=
" .expect(\"Invalid union table, " " .expect(\"Invalid union table, "
"expected `{{ENUM_NAME}}::{{VARIANT_NAME}}`.\")"; "expected `{{ENUM_NAME}}::{{VARIANT_NAME}}`.\")";
@@ -1840,13 +1826,6 @@ class RustGenerator : public BaseGenerator {
code_ += " }"; code_ += " }";
} }
// Generate field id constants.
ForAllTableFields(struct_def, [&](const FieldDef &unused) {
(void)unused;
code_ +=
" pub const {{OFFSET_NAME}}: flatbuffers::VOffsetT = "
"{{OFFSET_VALUE}};";
});
if (struct_def.fields.vec.size() > 0) code_ += ""; if (struct_def.fields.vec.size() > 0) code_ += "";
// Generate the accessors. Each has one of two forms: // Generate the accessors. Each has one of two forms:
@@ -1864,11 +1843,11 @@ class RustGenerator : public BaseGenerator {
code_.SetValue("RETURN_TYPE", code_.SetValue("RETURN_TYPE",
GenTableAccessorFuncReturnType(field, "'a")); GenTableAccessorFuncReturnType(field, "'a"));
this->GenComment(field.doc_comment, " "); this->GenComment(field.doc_comment);
code_ += " #[inline]"; code_ += "#[inline]";
code_ += " pub fn {{FIELD_NAME}}(&self) -> {{RETURN_TYPE}} {"; code_ += "pub fn {{FIELD_NAME}}(&self) -> {{RETURN_TYPE}} {";
code_ += " " + GenTableAccessorFuncBody(field, "'a"); code_ += " " + GenTableAccessorFuncBody(field, "'a");
code_ += " }"; code_ += "}";
// Generate a comparison function for this field if it is a key. // Generate a comparison function for this field if it is a key.
if (field.key) { GenKeyFieldMethods(field); } if (field.key) { GenKeyFieldMethods(field); }
@@ -1886,7 +1865,7 @@ class RustGenerator : public BaseGenerator {
FLATBUFFERS_ASSERT(nested_root); // Guaranteed to exist by parser. FLATBUFFERS_ASSERT(nested_root); // Guaranteed to exist by parser.
code_.SetValue("NESTED", WrapInNameSpace(*nested_root)); code_.SetValue("NESTED", WrapInNameSpace(*nested_root));
code_ += " pub fn {{FIELD_NAME}}_nested_flatbuffer(&'a self) -> \\"; code_ += "pub fn {{FIELD_NAME}}_nested_flatbuffer(&'a self) -> \\";
if (field.IsRequired()) { if (field.IsRequired()) {
code_ += "{{NESTED}}<'a> {"; code_ += "{{NESTED}}<'a> {";
code_ += " let data = self.{{FIELD_NAME}}();"; code_ += " let data = self.{{FIELD_NAME}}();";
@@ -1903,7 +1882,7 @@ class RustGenerator : public BaseGenerator {
"::follow(data, 0)"; "::follow(data, 0)";
code_ += " })"; code_ += " })";
} }
code_ += " }"; code_ += "}";
} }
}); });
@@ -1913,10 +1892,10 @@ class RustGenerator : public BaseGenerator {
ForAllUnionVariantsBesidesNone( ForAllUnionVariantsBesidesNone(
*field.value.type.enum_def, [&](const EnumVal &unused) { *field.value.type.enum_def, [&](const EnumVal &unused) {
(void)unused; (void)unused;
code_ += " #[inline]"; code_ += "#[inline]";
code_ += " #[allow(non_snake_case)]"; code_ += "#[allow(non_snake_case)]";
code_ += code_ +=
" pub fn {{FIELD_NAME}}_as_{{U_ELEMENT_NAME}}(&self) -> " "pub fn {{FIELD_NAME}}_as_{{U_ELEMENT_NAME}}(&self) -> "
"Option<{{U_ELEMENT_TABLE_TYPE}}<'a>> {"; "Option<{{U_ELEMENT_TABLE_TYPE}}<'a>> {";
// If the user defined schemas name a field that clashes with a // If the user defined schemas name a field that clashes with a
// language reserved word, flatc will try to escape the field name // language reserved word, flatc will try to escape the field name
@@ -1936,8 +1915,7 @@ class RustGenerator : public BaseGenerator {
// as of April 10, 2020 // as of April 10, 2020
if (field.IsRequired()) { if (field.IsRequired()) {
code_ += " let u = self.{{FIELD_NAME}}();"; code_ += " let u = self.{{FIELD_NAME}}();";
code_ += code_ += " Some({{U_ELEMENT_TABLE_TYPE}}::init_from_table(u))";
" Some({{U_ELEMENT_TABLE_TYPE}}::init_from_table(u))";
} else { } else {
code_ += code_ +=
" self.{{FIELD_NAME}}().map(" " self.{{FIELD_NAME}}().map("
@@ -1946,7 +1924,7 @@ class RustGenerator : public BaseGenerator {
code_ += " } else {"; code_ += " } else {";
code_ += " None"; code_ += " None";
code_ += " }"; code_ += " }";
code_ += " }"; code_ += "}";
code_ += ""; code_ += "";
}); });
}); });
@@ -2055,9 +2033,9 @@ class RustGenerator : public BaseGenerator {
code_.SetValue("FIELD_OFFSET", Name(struct_def) + "::" + offset); code_.SetValue("FIELD_OFFSET", Name(struct_def) + "::" + offset);
code_.SetValue("FIELD_TYPE", TableBuilderArgsAddFuncType(field, "'b ")); code_.SetValue("FIELD_TYPE", TableBuilderArgsAddFuncType(field, "'b "));
code_.SetValue("FUNC_BODY", TableBuilderArgsAddFuncBody(field)); code_.SetValue("FUNC_BODY", TableBuilderArgsAddFuncBody(field));
code_ += " #[inline]"; code_ += "#[inline]";
code_ += code_ +=
" pub fn add_{{FIELD_NAME}}(&mut self, {{FIELD_NAME}}: " "pub fn add_{{FIELD_NAME}}(&mut self, {{FIELD_NAME}}: "
"{{FIELD_TYPE}}) {"; "{{FIELD_TYPE}}) {";
if (is_scalar && !field.IsOptional()) { if (is_scalar && !field.IsOptional()) {
code_ += code_ +=
@@ -2066,7 +2044,7 @@ class RustGenerator : public BaseGenerator {
} else { } else {
code_ += " {{FUNC_BODY}}({{FIELD_OFFSET}}, {{FIELD_NAME}});"; code_ += " {{FUNC_BODY}}({{FIELD_OFFSET}}, {{FIELD_NAME}});";
} }
code_ += " }"; code_ += "}";
}); });
// Struct initializer (all fields required); // Struct initializer (all fields required);
@@ -2124,8 +2102,7 @@ class RustGenerator : public BaseGenerator {
"{{U_ELEMENT_NAME}}() {"; "{{U_ELEMENT_NAME}}() {";
code_ += " ds.field(\"{{FIELD_NAME}}\", &x)"; code_ += " ds.field(\"{{FIELD_NAME}}\", &x)";
code_ += " } else {"; code_ += " } else {";
code_ += code_ += " ds.field(\"{{FIELD_NAME}}\", {{UNION_ERR}})";
" ds.field(\"{{FIELD_NAME}}\", {{UNION_ERR}})";
code_ += " }"; code_ += " }";
code_ += " },"; code_ += " },";
}); });
@@ -2156,7 +2133,7 @@ class RustGenerator : public BaseGenerator {
// Union objects combine both the union discriminant and value, so we // Union objects combine both the union discriminant and value, so we
// skip making a field for the discriminant. // skip making a field for the discriminant.
if (field.value.type.base_type == BASE_TYPE_UTYPE) return; if (field.value.type.base_type == BASE_TYPE_UTYPE) return;
code_ += " pub {{FIELD_NAME}}: {{FIELD_OBJECT_TYPE}},"; code_ += "pub {{FIELD_NAME}}: {{FIELD_OBJECT_TYPE}},";
}); });
code_ += "}"; code_ += "}";
@@ -2213,8 +2190,7 @@ class RustGenerator : public BaseGenerator {
// Hold the struct in a variable so we can reference it. // Hold the struct in a variable so we can reference it.
if (field.IsRequired()) { if (field.IsRequired()) {
code_ += code_ +=
" let {{FIELD_NAME}}_tmp = " " let {{FIELD_NAME}}_tmp = Some(self.{{FIELD_NAME}}.pack());";
"Some(self.{{FIELD_NAME}}.pack());";
} else { } else {
code_ += code_ +=
" let {{FIELD_NAME}}_tmp = self.{{FIELD_NAME}}" " let {{FIELD_NAME}}_tmp = self.{{FIELD_NAME}}"
@@ -2288,7 +2264,9 @@ class RustGenerator : public BaseGenerator {
if (field.deprecated) continue; if (field.deprecated) continue;
code_.SetValue("FIELD_NAME", Name(field)); code_.SetValue("FIELD_NAME", Name(field));
code_.SetValue("FIELD_OBJECT_TYPE", ObjectFieldType(field, true)); code_.SetValue("FIELD_OBJECT_TYPE", ObjectFieldType(field, true));
code_.IncrementIdentLevel();
cb(field); cb(field);
code_.DecrementIdentLevel();
} }
} }
void MapNativeTableField(const FieldDef &field, const std::string &expr) { void MapNativeTableField(const FieldDef &field, const std::string &expr) {
@@ -2314,20 +2292,20 @@ class RustGenerator : public BaseGenerator {
code_.SetValue("KEY_TYPE", GenTableAccessorFuncReturnType(field, "")); code_.SetValue("KEY_TYPE", GenTableAccessorFuncReturnType(field, ""));
code_.SetValue("REF", IsString(field.value.type) ? "" : "&"); code_.SetValue("REF", IsString(field.value.type) ? "" : "&");
code_ += " #[inline]"; code_ += "#[inline]";
code_ += code_ +=
" pub fn key_compare_less_than(&self, o: &{{STRUCT_NAME}}) -> " "pub fn key_compare_less_than(&self, o: &{{STRUCT_NAME}}) -> "
" bool {"; "bool {";
code_ += " self.{{FIELD_NAME}}() < o.{{FIELD_NAME}}()"; code_ += " self.{{FIELD_NAME}}() < o.{{FIELD_NAME}}()";
code_ += " }"; code_ += "}";
code_ += ""; code_ += "";
code_ += " #[inline]"; code_ += "#[inline]";
code_ += code_ +=
" pub fn key_compare_with_value(&self, val: {{KEY_TYPE}}) -> " "pub fn key_compare_with_value(&self, val: {{KEY_TYPE}}) -> "
" ::std::cmp::Ordering {"; "::std::cmp::Ordering {";
code_ += " let key = self.{{FIELD_NAME}}();"; code_ += " let key = self.{{FIELD_NAME}}();";
code_ += " key.cmp({{REF}}val)"; code_ += " key.cmp({{REF}}val)";
code_ += " }"; code_ += "}";
} }
// Generate functions for accessing the root table object. This function // Generate functions for accessing the root table object. This function
@@ -2553,7 +2531,9 @@ class RustGenerator : public BaseGenerator {
code_.SetValue( code_.SetValue(
"REF", "REF",
IsStruct(field.value.type) || IsArray(field.value.type) ? "&" : ""); IsStruct(field.value.type) || IsArray(field.value.type) ? "&" : "");
code_.IncrementIdentLevel();
cb(field); cb(field);
code_.DecrementIdentLevel();
const size_t size = InlineSize(field.value.type); const size_t size = InlineSize(field.value.type);
offset_to_field += size + field.padding; offset_to_field += size + field.padding;
} }
@@ -2681,10 +2661,10 @@ class RustGenerator : public BaseGenerator {
// Generate accessor methods for the struct. // Generate accessor methods for the struct.
ForAllStructFields(struct_def, [&](const FieldDef &field) { ForAllStructFields(struct_def, [&](const FieldDef &field) {
this->GenComment(field.doc_comment, " "); this->GenComment(field.doc_comment);
// Getter. // Getter.
if (IsStruct(field.value.type)) { if (IsStruct(field.value.type)) {
code_ += " pub fn {{FIELD_NAME}}(&self) -> &{{FIELD_TYPE}} {"; code_ += "pub fn {{FIELD_NAME}}(&self) -> &{{FIELD_TYPE}} {";
code_ += code_ +=
" unsafe {" " unsafe {"
" &*(self.0[{{FIELD_OFFSET}}..].as_ptr() as *const" " &*(self.0[{{FIELD_OFFSET}}..].as_ptr() as *const"
@@ -2694,11 +2674,11 @@ class RustGenerator : public BaseGenerator {
NumToString(field.value.type.fixed_length)); NumToString(field.value.type.fixed_length));
code_.SetValue("ARRAY_ITEM", GetTypeGet(field.value.type.VectorType())); code_.SetValue("ARRAY_ITEM", GetTypeGet(field.value.type.VectorType()));
code_ += code_ +=
" pub fn {{FIELD_NAME}}(&'a self) -> " "pub fn {{FIELD_NAME}}(&'a self) -> "
"flatbuffers::Array<'a, {{ARRAY_ITEM}}, {{ARRAY_SIZE}}> {"; "flatbuffers::Array<'a, {{ARRAY_ITEM}}, {{ARRAY_SIZE}}> {";
code_ += " flatbuffers::Array::follow(&self.0, {{FIELD_OFFSET}})"; code_ += " flatbuffers::Array::follow(&self.0, {{FIELD_OFFSET}})";
} else { } else {
code_ += " pub fn {{FIELD_NAME}}(&self) -> {{FIELD_TYPE}} {"; code_ += "pub fn {{FIELD_NAME}}(&self) -> {{FIELD_TYPE}} {";
code_ += code_ +=
" let mut mem = core::mem::MaybeUninit::" " let mut mem = core::mem::MaybeUninit::"
"<{{FIELD_TYPE}}>::uninit();"; "<{{FIELD_TYPE}}>::uninit();";
@@ -2711,12 +2691,12 @@ class RustGenerator : public BaseGenerator {
code_ += " mem.assume_init()"; code_ += " mem.assume_init()";
code_ += " }.from_little_endian()"; code_ += " }.from_little_endian()";
} }
code_ += " }\n"; code_ += "}\n";
// Setter. // Setter.
if (IsStruct(field.value.type)) { if (IsStruct(field.value.type)) {
code_.SetValue("FIELD_SIZE", NumToString(InlineSize(field.value.type))); code_.SetValue("FIELD_SIZE", NumToString(InlineSize(field.value.type)));
code_ += " #[allow(clippy::identity_op)]"; // If FIELD_OFFSET=0. code_ += "#[allow(clippy::identity_op)]"; // If FIELD_OFFSET=0.
code_ += " pub fn set_{{FIELD_NAME}}(&mut self, x: &{{FIELD_TYPE}}) {"; code_ += "pub fn set_{{FIELD_NAME}}(&mut self, x: &{{FIELD_TYPE}}) {";
code_ += code_ +=
" self.0[{{FIELD_OFFSET}}..{{FIELD_OFFSET}} + {{FIELD_SIZE}}]" " self.0[{{FIELD_OFFSET}}..{{FIELD_OFFSET}} + {{FIELD_SIZE}}]"
".copy_from_slice(&x.0)"; ".copy_from_slice(&x.0)";
@@ -2728,7 +2708,7 @@ class RustGenerator : public BaseGenerator {
"ARRAY_ITEM_SIZE", "ARRAY_ITEM_SIZE",
NumToString(InlineSize(field.value.type.VectorType()))); NumToString(InlineSize(field.value.type.VectorType())));
code_ += code_ +=
" pub fn set_{{FIELD_NAME}}(&mut self, items: &{{FIELD_TYPE}}) " "pub fn set_{{FIELD_NAME}}(&mut self, items: &{{FIELD_TYPE}}) "
"{"; "{";
code_ += code_ +=
" flatbuffers::emplace_scalar_array(&mut self.0, " " flatbuffers::emplace_scalar_array(&mut self.0, "
@@ -2736,8 +2716,7 @@ class RustGenerator : public BaseGenerator {
} else { } else {
code_.SetValue("FIELD_SIZE", code_.SetValue("FIELD_SIZE",
NumToString(InlineSize(field.value.type))); NumToString(InlineSize(field.value.type)));
code_ += code_ += "pub fn set_{{FIELD_NAME}}(&mut self, x: &{{FIELD_TYPE}}) {";
" pub fn set_{{FIELD_NAME}}(&mut self, x: &{{FIELD_TYPE}}) {";
code_ += " unsafe {"; code_ += " unsafe {";
code_ += " std::ptr::copy("; code_ += " std::ptr::copy(";
code_ += " x.as_ptr() as *const u8,"; code_ += " x.as_ptr() as *const u8,";
@@ -2747,7 +2726,7 @@ class RustGenerator : public BaseGenerator {
code_ += " }"; code_ += " }";
} }
} else { } else {
code_ += " pub fn set_{{FIELD_NAME}}(&mut self, x: {{FIELD_TYPE}}) {"; code_ += "pub fn set_{{FIELD_NAME}}(&mut self, x: {{FIELD_TYPE}}) {";
code_ += " let x_le = x.to_little_endian();"; code_ += " let x_le = x.to_little_endian();";
code_ += " unsafe {"; code_ += " unsafe {";
code_ += " core::ptr::copy_nonoverlapping("; code_ += " core::ptr::copy_nonoverlapping(";
@@ -2757,7 +2736,7 @@ class RustGenerator : public BaseGenerator {
code_ += " );"; code_ += " );";
code_ += " }"; code_ += " }";
} }
code_ += " }\n"; code_ += "}\n";
// Generate a comparison function for this field if it is a key. // Generate a comparison function for this field if it is a key.
if (field.key) { GenKeyFieldMethods(field); } if (field.key) { GenKeyFieldMethods(field); }
@@ -2797,7 +2776,7 @@ class RustGenerator : public BaseGenerator {
code_ += "pub struct {{NATIVE_STRUCT_NAME}} {"; code_ += "pub struct {{NATIVE_STRUCT_NAME}} {";
ForAllStructFields(struct_def, [&](const FieldDef &field) { ForAllStructFields(struct_def, [&](const FieldDef &field) {
(void)field; // unused. (void)field; // unused.
code_ += " pub {{FIELD_NAME}}: {{FIELD_OBJECT_TYPE}},"; code_ += "pub {{FIELD_NAME}}: {{FIELD_OBJECT_TYPE}},";
}); });
code_ += "}"; code_ += "}";
// The `pack` method that turns the native struct into its Flatbuffers // The `pack` method that turns the native struct into its Flatbuffers

6
tests/arrays_test/my_game/example/array_table_generated.rs
View File

@@ -20,6 +20,8 @@ impl<'a> flatbuffers::Follow<'a> for ArrayTable<'a> {
} }
impl<'a> ArrayTable<'a> { impl<'a> ArrayTable<'a> {
pub const VT_A: flatbuffers::VOffsetT = 4;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"MyGame.Example.ArrayTable" "MyGame.Example.ArrayTable"
} }
@@ -31,7 +33,8 @@ impl<'a> ArrayTable<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args ArrayTableArgs<'args>) -> flatbuffers::WIPOffset<ArrayTable<'bldr>> { args: &'args ArrayTableArgs<'args>
) -> flatbuffers::WIPOffset<ArrayTable<'bldr>> {
let mut builder = ArrayTableBuilder::new(_fbb); let mut builder = ArrayTableBuilder::new(_fbb);
if let Some(x) = args.a { builder.add_a(x); } if let Some(x) = args.a { builder.add_a(x); }
builder.finish() builder.finish()
@@ -45,7 +48,6 @@ impl<'a> ArrayTable<'a> {
a, a,
} }
} }
pub const VT_A: flatbuffers::VOffsetT = 4;
#[inline] #[inline]
pub fn a(&self) -> Option<&'a ArrayStruct> { pub fn a(&self) -> Option<&'a ArrayStruct> {

6
tests/include_test1/my_game/other_name_space/table_b_generated.rs
View File

@@ -20,6 +20,8 @@ impl<'a> flatbuffers::Follow<'a> for TableB<'a> {
} }
impl<'a> TableB<'a> { impl<'a> TableB<'a> {
pub const VT_A: flatbuffers::VOffsetT = 4;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"MyGame.OtherNameSpace.TableB" "MyGame.OtherNameSpace.TableB"
} }
@@ -31,7 +33,8 @@ impl<'a> TableB<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args TableBArgs<'args>) -> flatbuffers::WIPOffset<TableB<'bldr>> { args: &'args TableBArgs<'args>
) -> flatbuffers::WIPOffset<TableB<'bldr>> {
let mut builder = TableBBuilder::new(_fbb); let mut builder = TableBBuilder::new(_fbb);
if let Some(x) = args.a { builder.add_a(x); } if let Some(x) = args.a { builder.add_a(x); }
builder.finish() builder.finish()
@@ -45,7 +48,6 @@ impl<'a> TableB<'a> {
a, a,
} }
} }
pub const VT_A: flatbuffers::VOffsetT = 4;
#[inline] #[inline]
pub fn a(&self) -> Option<super::super::TableA<'a>> { pub fn a(&self) -> Option<super::super::TableA<'a>> {

6
tests/include_test1/table_a_generated.rs
View File

@@ -20,6 +20,8 @@ impl<'a> flatbuffers::Follow<'a> for TableA<'a> {
} }
impl<'a> TableA<'a> { impl<'a> TableA<'a> {
pub const VT_B: flatbuffers::VOffsetT = 4;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"TableA" "TableA"
} }
@@ -31,7 +33,8 @@ impl<'a> TableA<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args TableAArgs<'args>) -> flatbuffers::WIPOffset<TableA<'bldr>> { args: &'args TableAArgs<'args>
) -> flatbuffers::WIPOffset<TableA<'bldr>> {
let mut builder = TableABuilder::new(_fbb); let mut builder = TableABuilder::new(_fbb);
if let Some(x) = args.b { builder.add_b(x); } if let Some(x) = args.b { builder.add_b(x); }
builder.finish() builder.finish()
@@ -45,7 +48,6 @@ impl<'a> TableA<'a> {
b, b,
} }
} }
pub const VT_B: flatbuffers::VOffsetT = 4;
#[inline] #[inline]
pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> { pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {

6
tests/include_test2/my_game/other_name_space/table_b_generated.rs
View File

@@ -20,6 +20,8 @@ impl<'a> flatbuffers::Follow<'a> for TableB<'a> {
} }
impl<'a> TableB<'a> { impl<'a> TableB<'a> {
pub const VT_A: flatbuffers::VOffsetT = 4;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"MyGame.OtherNameSpace.TableB" "MyGame.OtherNameSpace.TableB"
} }
@@ -31,7 +33,8 @@ impl<'a> TableB<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args TableBArgs<'args>) -> flatbuffers::WIPOffset<TableB<'bldr>> { args: &'args TableBArgs<'args>
) -> flatbuffers::WIPOffset<TableB<'bldr>> {
let mut builder = TableBBuilder::new(_fbb); let mut builder = TableBBuilder::new(_fbb);
if let Some(x) = args.a { builder.add_a(x); } if let Some(x) = args.a { builder.add_a(x); }
builder.finish() builder.finish()
@@ -45,7 +48,6 @@ impl<'a> TableB<'a> {
a, a,
} }
} }
pub const VT_A: flatbuffers::VOffsetT = 4;
#[inline] #[inline]
pub fn a(&self) -> Option<super::super::TableA<'a>> { pub fn a(&self) -> Option<super::super::TableA<'a>> {

6
tests/include_test2/table_a_generated.rs
View File

@@ -20,6 +20,8 @@ impl<'a> flatbuffers::Follow<'a> for TableA<'a> {
} }
impl<'a> TableA<'a> { impl<'a> TableA<'a> {
pub const VT_B: flatbuffers::VOffsetT = 4;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"TableA" "TableA"
} }
@@ -31,7 +33,8 @@ impl<'a> TableA<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args TableAArgs<'args>) -> flatbuffers::WIPOffset<TableA<'bldr>> { args: &'args TableAArgs<'args>
) -> flatbuffers::WIPOffset<TableA<'bldr>> {
let mut builder = TableABuilder::new(_fbb); let mut builder = TableABuilder::new(_fbb);
if let Some(x) = args.b { builder.add_b(x); } if let Some(x) = args.b { builder.add_b(x); }
builder.finish() builder.finish()
@@ -45,7 +48,6 @@ impl<'a> TableA<'a> {
b, b,
} }
} }
pub const VT_B: flatbuffers::VOffsetT = 4;
#[inline] #[inline]
pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> { pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {

10
tests/keyword_test/keywords_in_table_generated.rs
View File

@@ -20,6 +20,10 @@ impl<'a> flatbuffers::Follow<'a> for KeywordsInTable<'a> {
} }
impl<'a> KeywordsInTable<'a> { impl<'a> KeywordsInTable<'a> {
pub const VT_IS: flatbuffers::VOffsetT = 4;
pub const VT_PRIVATE: flatbuffers::VOffsetT = 6;
pub const VT_TYPE_: flatbuffers::VOffsetT = 8;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"KeywordsInTable" "KeywordsInTable"
} }
@@ -31,7 +35,8 @@ impl<'a> KeywordsInTable<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args KeywordsInTableArgs) -> flatbuffers::WIPOffset<KeywordsInTable<'bldr>> { args: &'args KeywordsInTableArgs
) -> flatbuffers::WIPOffset<KeywordsInTable<'bldr>> {
let mut builder = KeywordsInTableBuilder::new(_fbb); let mut builder = KeywordsInTableBuilder::new(_fbb);
builder.add_type_(args.type_); builder.add_type_(args.type_);
builder.add_private(args.private); builder.add_private(args.private);
@@ -49,9 +54,6 @@ impl<'a> KeywordsInTable<'a> {
type_, type_,
} }
} }
pub const VT_IS: flatbuffers::VOffsetT = 4;
pub const VT_PRIVATE: flatbuffers::VOffsetT = 6;
pub const VT_TYPE_: flatbuffers::VOffsetT = 8;
#[inline] #[inline]
pub fn is(&self) -> ABC { pub fn is(&self) -> ABC {

104
tests/monster_test/my_game/example/monster_generated.rs
View File

@@ -21,6 +21,57 @@ impl<'a> flatbuffers::Follow<'a> for Monster<'a> {
} }
impl<'a> Monster<'a> { 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_TEST_TYPE: flatbuffers::VOffsetT = 18;
pub const VT_TEST: flatbuffers::VOffsetT = 20;
pub const VT_TEST4: flatbuffers::VOffsetT = 22;
pub const VT_TESTARRAYOFSTRING: flatbuffers::VOffsetT = 24;
pub const VT_TESTARRAYOFTABLES: flatbuffers::VOffsetT = 26;
pub const VT_ENEMY: flatbuffers::VOffsetT = 28;
pub const VT_TESTNESTEDFLATBUFFER: flatbuffers::VOffsetT = 30;
pub const VT_TESTEMPTY: flatbuffers::VOffsetT = 32;
pub const VT_TESTBOOL: flatbuffers::VOffsetT = 34;
pub const VT_TESTHASHS32_FNV1: flatbuffers::VOffsetT = 36;
pub const VT_TESTHASHU32_FNV1: flatbuffers::VOffsetT = 38;
pub const VT_TESTHASHS64_FNV1: flatbuffers::VOffsetT = 40;
pub const VT_TESTHASHU64_FNV1: flatbuffers::VOffsetT = 42;
pub const VT_TESTHASHS32_FNV1A: flatbuffers::VOffsetT = 44;
pub const VT_TESTHASHU32_FNV1A: flatbuffers::VOffsetT = 46;
pub const VT_TESTHASHS64_FNV1A: flatbuffers::VOffsetT = 48;
pub const VT_TESTHASHU64_FNV1A: flatbuffers::VOffsetT = 50;
pub const VT_TESTARRAYOFBOOLS: flatbuffers::VOffsetT = 52;
pub const VT_TESTF: flatbuffers::VOffsetT = 54;
pub const VT_TESTF2: flatbuffers::VOffsetT = 56;
pub const VT_TESTF3: flatbuffers::VOffsetT = 58;
pub const VT_TESTARRAYOFSTRING2: flatbuffers::VOffsetT = 60;
pub const VT_TESTARRAYOFSORTEDSTRUCT: flatbuffers::VOffsetT = 62;
pub const VT_FLEX: flatbuffers::VOffsetT = 64;
pub const VT_TEST5: flatbuffers::VOffsetT = 66;
pub const VT_VECTOR_OF_LONGS: flatbuffers::VOffsetT = 68;
pub const VT_VECTOR_OF_DOUBLES: flatbuffers::VOffsetT = 70;
pub const VT_PARENT_NAMESPACE_TEST: flatbuffers::VOffsetT = 72;
pub const VT_VECTOR_OF_REFERRABLES: flatbuffers::VOffsetT = 74;
pub const VT_SINGLE_WEAK_REFERENCE: flatbuffers::VOffsetT = 76;
pub const VT_VECTOR_OF_WEAK_REFERENCES: flatbuffers::VOffsetT = 78;
pub const VT_VECTOR_OF_STRONG_REFERRABLES: flatbuffers::VOffsetT = 80;
pub const VT_CO_OWNING_REFERENCE: flatbuffers::VOffsetT = 82;
pub const VT_VECTOR_OF_CO_OWNING_REFERENCES: flatbuffers::VOffsetT = 84;
pub const VT_NON_OWNING_REFERENCE: flatbuffers::VOffsetT = 86;
pub const VT_VECTOR_OF_NON_OWNING_REFERENCES: flatbuffers::VOffsetT = 88;
pub const VT_ANY_UNIQUE_TYPE: flatbuffers::VOffsetT = 90;
pub const VT_ANY_UNIQUE: flatbuffers::VOffsetT = 92;
pub const VT_ANY_AMBIGUOUS_TYPE: flatbuffers::VOffsetT = 94;
pub const VT_ANY_AMBIGUOUS: flatbuffers::VOffsetT = 96;
pub const VT_VECTOR_OF_ENUMS: flatbuffers::VOffsetT = 98;
pub const VT_SIGNED_ENUM: flatbuffers::VOffsetT = 100;
pub const VT_TESTREQUIREDNESTEDFLATBUFFER: flatbuffers::VOffsetT = 102;
pub const VT_SCALAR_KEY_SORTED_TABLES: flatbuffers::VOffsetT = 104;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"MyGame.Example.Monster" "MyGame.Example.Monster"
} }
@@ -32,7 +83,8 @@ impl<'a> Monster<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args MonsterArgs<'args>) -> flatbuffers::WIPOffset<Monster<'bldr>> { args: &'args MonsterArgs<'args>
) -> flatbuffers::WIPOffset<Monster<'bldr>> {
let mut builder = MonsterBuilder::new(_fbb); let mut builder = MonsterBuilder::new(_fbb);
builder.add_non_owning_reference(args.non_owning_reference); builder.add_non_owning_reference(args.non_owning_reference);
builder.add_co_owning_reference(args.co_owning_reference); builder.add_co_owning_reference(args.co_owning_reference);
@@ -290,56 +342,6 @@ impl<'a> Monster<'a> {
scalar_key_sorted_tables, scalar_key_sorted_tables,
} }
} }
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_TEST_TYPE: flatbuffers::VOffsetT = 18;
pub const VT_TEST: flatbuffers::VOffsetT = 20;
pub const VT_TEST4: flatbuffers::VOffsetT = 22;
pub const VT_TESTARRAYOFSTRING: flatbuffers::VOffsetT = 24;
pub const VT_TESTARRAYOFTABLES: flatbuffers::VOffsetT = 26;
pub const VT_ENEMY: flatbuffers::VOffsetT = 28;
pub const VT_TESTNESTEDFLATBUFFER: flatbuffers::VOffsetT = 30;
pub const VT_TESTEMPTY: flatbuffers::VOffsetT = 32;
pub const VT_TESTBOOL: flatbuffers::VOffsetT = 34;
pub const VT_TESTHASHS32_FNV1: flatbuffers::VOffsetT = 36;
pub const VT_TESTHASHU32_FNV1: flatbuffers::VOffsetT = 38;
pub const VT_TESTHASHS64_FNV1: flatbuffers::VOffsetT = 40;
pub const VT_TESTHASHU64_FNV1: flatbuffers::VOffsetT = 42;
pub const VT_TESTHASHS32_FNV1A: flatbuffers::VOffsetT = 44;
pub const VT_TESTHASHU32_FNV1A: flatbuffers::VOffsetT = 46;
pub const VT_TESTHASHS64_FNV1A: flatbuffers::VOffsetT = 48;
pub const VT_TESTHASHU64_FNV1A: flatbuffers::VOffsetT = 50;
pub const VT_TESTARRAYOFBOOLS: flatbuffers::VOffsetT = 52;
pub const VT_TESTF: flatbuffers::VOffsetT = 54;
pub const VT_TESTF2: flatbuffers::VOffsetT = 56;
pub const VT_TESTF3: flatbuffers::VOffsetT = 58;
pub const VT_TESTARRAYOFSTRING2: flatbuffers::VOffsetT = 60;
pub const VT_TESTARRAYOFSORTEDSTRUCT: flatbuffers::VOffsetT = 62;
pub const VT_FLEX: flatbuffers::VOffsetT = 64;
pub const VT_TEST5: flatbuffers::VOffsetT = 66;
pub const VT_VECTOR_OF_LONGS: flatbuffers::VOffsetT = 68;
pub const VT_VECTOR_OF_DOUBLES: flatbuffers::VOffsetT = 70;
pub const VT_PARENT_NAMESPACE_TEST: flatbuffers::VOffsetT = 72;
pub const VT_VECTOR_OF_REFERRABLES: flatbuffers::VOffsetT = 74;
pub const VT_SINGLE_WEAK_REFERENCE: flatbuffers::VOffsetT = 76;
pub const VT_VECTOR_OF_WEAK_REFERENCES: flatbuffers::VOffsetT = 78;
pub const VT_VECTOR_OF_STRONG_REFERRABLES: flatbuffers::VOffsetT = 80;
pub const VT_CO_OWNING_REFERENCE: flatbuffers::VOffsetT = 82;
pub const VT_VECTOR_OF_CO_OWNING_REFERENCES: flatbuffers::VOffsetT = 84;
pub const VT_NON_OWNING_REFERENCE: flatbuffers::VOffsetT = 86;
pub const VT_VECTOR_OF_NON_OWNING_REFERENCES: flatbuffers::VOffsetT = 88;
pub const VT_ANY_UNIQUE_TYPE: flatbuffers::VOffsetT = 90;
pub const VT_ANY_UNIQUE: flatbuffers::VOffsetT = 92;
pub const VT_ANY_AMBIGUOUS_TYPE: flatbuffers::VOffsetT = 94;
pub const VT_ANY_AMBIGUOUS: flatbuffers::VOffsetT = 96;
pub const VT_VECTOR_OF_ENUMS: flatbuffers::VOffsetT = 98;
pub const VT_SIGNED_ENUM: flatbuffers::VOffsetT = 100;
pub const VT_TESTREQUIREDNESTEDFLATBUFFER: flatbuffers::VOffsetT = 102;
pub const VT_SCALAR_KEY_SORTED_TABLES: flatbuffers::VOffsetT = 104;
#[inline] #[inline]
pub fn pos(&self) -> Option<&'a Vec3> { pub fn pos(&self) -> Option<&'a Vec3> {

6
tests/monster_test/my_game/example/referrable_generated.rs
View File

@@ -20,6 +20,8 @@ impl<'a> flatbuffers::Follow<'a> for Referrable<'a> {
} }
impl<'a> Referrable<'a> { impl<'a> Referrable<'a> {
pub const VT_ID: flatbuffers::VOffsetT = 4;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"MyGame.Example.Referrable" "MyGame.Example.Referrable"
} }
@@ -31,7 +33,8 @@ impl<'a> Referrable<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args ReferrableArgs) -> flatbuffers::WIPOffset<Referrable<'bldr>> { args: &'args ReferrableArgs
) -> flatbuffers::WIPOffset<Referrable<'bldr>> {
let mut builder = ReferrableBuilder::new(_fbb); let mut builder = ReferrableBuilder::new(_fbb);
builder.add_id(args.id); builder.add_id(args.id);
builder.finish() builder.finish()
@@ -43,7 +46,6 @@ impl<'a> Referrable<'a> {
id, id,
} }
} }
pub const VT_ID: flatbuffers::VOffsetT = 4;
#[inline] #[inline]
pub fn id(&self) -> u64 { pub fn id(&self) -> u64 {

10
tests/monster_test/my_game/example/stat_generated.rs
View File

@@ -20,6 +20,10 @@ impl<'a> flatbuffers::Follow<'a> for Stat<'a> {
} }
impl<'a> Stat<'a> { impl<'a> Stat<'a> {
pub const VT_ID: flatbuffers::VOffsetT = 4;
pub const VT_VAL: flatbuffers::VOffsetT = 6;
pub const VT_COUNT: flatbuffers::VOffsetT = 8;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"MyGame.Example.Stat" "MyGame.Example.Stat"
} }
@@ -31,7 +35,8 @@ impl<'a> Stat<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args StatArgs<'args>) -> flatbuffers::WIPOffset<Stat<'bldr>> { args: &'args StatArgs<'args>
) -> flatbuffers::WIPOffset<Stat<'bldr>> {
let mut builder = StatBuilder::new(_fbb); let mut builder = StatBuilder::new(_fbb);
builder.add_val(args.val); builder.add_val(args.val);
if let Some(x) = args.id { builder.add_id(x); } if let Some(x) = args.id { builder.add_id(x); }
@@ -51,9 +56,6 @@ impl<'a> Stat<'a> {
count, count,
} }
} }
pub const VT_ID: flatbuffers::VOffsetT = 4;
pub const VT_VAL: flatbuffers::VOffsetT = 6;
pub const VT_COUNT: flatbuffers::VOffsetT = 8;
#[inline] #[inline]
pub fn id(&self) -> Option<&'a str> { pub fn id(&self) -> Option<&'a str> {

6
tests/monster_test/my_game/example/test_simple_table_with_enum_generated.rs
View File

@@ -20,6 +20,8 @@ impl<'a> flatbuffers::Follow<'a> for TestSimpleTableWithEnum<'a> {
} }
impl<'a> TestSimpleTableWithEnum<'a> { impl<'a> TestSimpleTableWithEnum<'a> {
pub const VT_COLOR: flatbuffers::VOffsetT = 4;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"MyGame.Example.TestSimpleTableWithEnum" "MyGame.Example.TestSimpleTableWithEnum"
} }
@@ -31,7 +33,8 @@ impl<'a> TestSimpleTableWithEnum<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args TestSimpleTableWithEnumArgs) -> flatbuffers::WIPOffset<TestSimpleTableWithEnum<'bldr>> { args: &'args TestSimpleTableWithEnumArgs
) -> flatbuffers::WIPOffset<TestSimpleTableWithEnum<'bldr>> {
let mut builder = TestSimpleTableWithEnumBuilder::new(_fbb); let mut builder = TestSimpleTableWithEnumBuilder::new(_fbb);
builder.add_color(args.color); builder.add_color(args.color);
builder.finish() builder.finish()
@@ -43,7 +46,6 @@ impl<'a> TestSimpleTableWithEnum<'a> {
color, color,
} }
} }
pub const VT_COLOR: flatbuffers::VOffsetT = 4;
#[inline] #[inline]
pub fn color(&self) -> Color { pub fn color(&self) -> Color {

28
tests/monster_test/my_game/example/type_aliases_generated.rs
View File

@@ -20,6 +20,19 @@ impl<'a> flatbuffers::Follow<'a> for TypeAliases<'a> {
} }
impl<'a> TypeAliases<'a> { impl<'a> TypeAliases<'a> {
pub const VT_I8_: flatbuffers::VOffsetT = 4;
pub const VT_U8_: flatbuffers::VOffsetT = 6;
pub const VT_I16_: flatbuffers::VOffsetT = 8;
pub const VT_U16_: flatbuffers::VOffsetT = 10;
pub const VT_I32_: flatbuffers::VOffsetT = 12;
pub const VT_U32_: flatbuffers::VOffsetT = 14;
pub const VT_I64_: flatbuffers::VOffsetT = 16;
pub const VT_U64_: flatbuffers::VOffsetT = 18;
pub const VT_F32_: flatbuffers::VOffsetT = 20;
pub const VT_F64_: flatbuffers::VOffsetT = 22;
pub const VT_V8: flatbuffers::VOffsetT = 24;
pub const VT_VF64: flatbuffers::VOffsetT = 26;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"MyGame.Example.TypeAliases" "MyGame.Example.TypeAliases"
} }
@@ -31,7 +44,8 @@ impl<'a> TypeAliases<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args TypeAliasesArgs<'args>) -> flatbuffers::WIPOffset<TypeAliases<'bldr>> { args: &'args TypeAliasesArgs<'args>
) -> flatbuffers::WIPOffset<TypeAliases<'bldr>> {
let mut builder = TypeAliasesBuilder::new(_fbb); let mut builder = TypeAliasesBuilder::new(_fbb);
builder.add_f64_(args.f64_); builder.add_f64_(args.f64_);
builder.add_u64_(args.u64_); builder.add_u64_(args.u64_);
@@ -80,18 +94,6 @@ impl<'a> TypeAliases<'a> {
vf64, vf64,
} }
} }
pub const VT_I8_: flatbuffers::VOffsetT = 4;
pub const VT_U8_: flatbuffers::VOffsetT = 6;
pub const VT_I16_: flatbuffers::VOffsetT = 8;
pub const VT_U16_: flatbuffers::VOffsetT = 10;
pub const VT_I32_: flatbuffers::VOffsetT = 12;
pub const VT_U32_: flatbuffers::VOffsetT = 14;
pub const VT_I64_: flatbuffers::VOffsetT = 16;
pub const VT_U64_: flatbuffers::VOffsetT = 18;
pub const VT_F32_: flatbuffers::VOffsetT = 20;
pub const VT_F64_: flatbuffers::VOffsetT = 22;
pub const VT_V8: flatbuffers::VOffsetT = 24;
pub const VT_VF64: flatbuffers::VOffsetT = 26;
#[inline] #[inline]
pub fn i8_(&self) -> i8 { pub fn i8_(&self) -> i8 {

4
tests/monster_test/my_game/example_2/monster_generated.rs
View File

@@ -20,6 +20,7 @@ impl<'a> flatbuffers::Follow<'a> for Monster<'a> {
} }
impl<'a> Monster<'a> { impl<'a> Monster<'a> {
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"MyGame.Example2.Monster" "MyGame.Example2.Monster"
} }
@@ -31,7 +32,8 @@ impl<'a> Monster<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
_args: &'args MonsterArgs) -> flatbuffers::WIPOffset<Monster<'bldr>> { _args: &'args MonsterArgs
) -> flatbuffers::WIPOffset<Monster<'bldr>> {
let mut builder = MonsterBuilder::new(_fbb); let mut builder = MonsterBuilder::new(_fbb);
builder.finish() builder.finish()
} }

4
tests/monster_test/my_game/in_parent_namespace_generated.rs
View File

@@ -20,6 +20,7 @@ impl<'a> flatbuffers::Follow<'a> for InParentNamespace<'a> {
} }
impl<'a> InParentNamespace<'a> { impl<'a> InParentNamespace<'a> {
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"MyGame.InParentNamespace" "MyGame.InParentNamespace"
} }
@@ -31,7 +32,8 @@ impl<'a> InParentNamespace<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
_args: &'args InParentNamespaceArgs) -> flatbuffers::WIPOffset<InParentNamespace<'bldr>> { _args: &'args InParentNamespaceArgs
) -> flatbuffers::WIPOffset<InParentNamespace<'bldr>> {
let mut builder = InParentNamespaceBuilder::new(_fbb); let mut builder = InParentNamespaceBuilder::new(_fbb);
builder.finish() builder.finish()
} }

6
tests/monster_test/my_game/other_name_space/table_b_generated.rs
View File

@@ -20,6 +20,8 @@ impl<'a> flatbuffers::Follow<'a> for TableB<'a> {
} }
impl<'a> TableB<'a> { impl<'a> TableB<'a> {
pub const VT_A: flatbuffers::VOffsetT = 4;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"MyGame.OtherNameSpace.TableB" "MyGame.OtherNameSpace.TableB"
} }
@@ -31,7 +33,8 @@ impl<'a> TableB<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args TableBArgs<'args>) -> flatbuffers::WIPOffset<TableB<'bldr>> { args: &'args TableBArgs<'args>
) -> flatbuffers::WIPOffset<TableB<'bldr>> {
let mut builder = TableBBuilder::new(_fbb); let mut builder = TableBBuilder::new(_fbb);
if let Some(x) = args.a { builder.add_a(x); } if let Some(x) = args.a { builder.add_a(x); }
builder.finish() builder.finish()
@@ -45,7 +48,6 @@ impl<'a> TableB<'a> {
a, a,
} }
} }
pub const VT_A: flatbuffers::VOffsetT = 4;
#[inline] #[inline]
pub fn a(&self) -> Option<super::super::TableA<'a>> { pub fn a(&self) -> Option<super::super::TableA<'a>> {

6
tests/monster_test/table_a_generated.rs
View File

@@ -20,6 +20,8 @@ impl<'a> flatbuffers::Follow<'a> for TableA<'a> {
} }
impl<'a> TableA<'a> { impl<'a> TableA<'a> {
pub const VT_B: flatbuffers::VOffsetT = 4;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"TableA" "TableA"
} }
@@ -31,7 +33,8 @@ impl<'a> TableA<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args TableAArgs<'args>) -> flatbuffers::WIPOffset<TableA<'bldr>> { args: &'args TableAArgs<'args>
) -> flatbuffers::WIPOffset<TableA<'bldr>> {
let mut builder = TableABuilder::new(_fbb); let mut builder = TableABuilder::new(_fbb);
if let Some(x) = args.b { builder.add_b(x); } if let Some(x) = args.b { builder.add_b(x); }
builder.finish() builder.finish()
@@ -45,7 +48,6 @@ impl<'a> TableA<'a> {
b, b,
} }
} }
pub const VT_B: flatbuffers::VOffsetT = 4;
#[inline] #[inline]
pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> { pub fn b(&self) -> Option<my_game::other_name_space::TableB<'a>> {

16
tests/more_defaults/more_defaults_generated.rs
View File

@@ -20,6 +20,13 @@ impl<'a> flatbuffers::Follow<'a> for MoreDefaults<'a> {
} }
impl<'a> MoreDefaults<'a> { impl<'a> MoreDefaults<'a> {
pub const VT_INTS: flatbuffers::VOffsetT = 4;
pub const VT_FLOATS: flatbuffers::VOffsetT = 6;
pub const VT_EMPTY_STRING: flatbuffers::VOffsetT = 8;
pub const VT_SOME_STRING: flatbuffers::VOffsetT = 10;
pub const VT_ABCS: flatbuffers::VOffsetT = 12;
pub const VT_BOOLS: flatbuffers::VOffsetT = 14;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"MoreDefaults" "MoreDefaults"
} }
@@ -31,7 +38,8 @@ impl<'a> MoreDefaults<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args MoreDefaultsArgs<'args>) -> flatbuffers::WIPOffset<MoreDefaults<'bldr>> { args: &'args MoreDefaultsArgs<'args>
) -> flatbuffers::WIPOffset<MoreDefaults<'bldr>> {
let mut builder = MoreDefaultsBuilder::new(_fbb); let mut builder = MoreDefaultsBuilder::new(_fbb);
if let Some(x) = args.bools { builder.add_bools(x); } if let Some(x) = args.bools { builder.add_bools(x); }
if let Some(x) = args.abcs { builder.add_abcs(x); } if let Some(x) = args.abcs { builder.add_abcs(x); }
@@ -76,12 +84,6 @@ impl<'a> MoreDefaults<'a> {
bools, bools,
} }
} }
pub const VT_INTS: flatbuffers::VOffsetT = 4;
pub const VT_FLOATS: flatbuffers::VOffsetT = 6;
pub const VT_EMPTY_STRING: flatbuffers::VOffsetT = 8;
pub const VT_SOME_STRING: flatbuffers::VOffsetT = 10;
pub const VT_ABCS: flatbuffers::VOffsetT = 12;
pub const VT_BOOLS: flatbuffers::VOffsetT = 14;
#[inline] #[inline]
pub fn ints(&self) -> flatbuffers::Vector<'a, i32> { pub fn ints(&self) -> flatbuffers::Vector<'a, i32> {

6
tests/namespace_test/namespace_a/namespace_b/table_in_nested_ns_generated.rs
View File

@@ -20,6 +20,8 @@ impl<'a> flatbuffers::Follow<'a> for TableInNestedNS<'a> {
} }
impl<'a> TableInNestedNS<'a> { impl<'a> TableInNestedNS<'a> {
pub const VT_FOO: flatbuffers::VOffsetT = 4;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"NamespaceA.NamespaceB.TableInNestedNS" "NamespaceA.NamespaceB.TableInNestedNS"
} }
@@ -31,7 +33,8 @@ impl<'a> TableInNestedNS<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args TableInNestedNSArgs) -> flatbuffers::WIPOffset<TableInNestedNS<'bldr>> { args: &'args TableInNestedNSArgs
) -> flatbuffers::WIPOffset<TableInNestedNS<'bldr>> {
let mut builder = TableInNestedNSBuilder::new(_fbb); let mut builder = TableInNestedNSBuilder::new(_fbb);
builder.add_foo(args.foo); builder.add_foo(args.foo);
builder.finish() builder.finish()
@@ -43,7 +46,6 @@ impl<'a> TableInNestedNS<'a> {
foo, foo,
} }
} }
pub const VT_FOO: flatbuffers::VOffsetT = 4;
#[inline] #[inline]
pub fn foo(&self) -> i32 { pub fn foo(&self) -> i32 {

6
tests/namespace_test/namespace_a/second_table_in_a_generated.rs
View File

@@ -20,6 +20,8 @@ impl<'a> flatbuffers::Follow<'a> for SecondTableInA<'a> {
} }
impl<'a> SecondTableInA<'a> { impl<'a> SecondTableInA<'a> {
pub const VT_REFER_TO_C: flatbuffers::VOffsetT = 4;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"NamespaceA.SecondTableInA" "NamespaceA.SecondTableInA"
} }
@@ -31,7 +33,8 @@ impl<'a> SecondTableInA<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args SecondTableInAArgs<'args>) -> flatbuffers::WIPOffset<SecondTableInA<'bldr>> { args: &'args SecondTableInAArgs<'args>
) -> flatbuffers::WIPOffset<SecondTableInA<'bldr>> {
let mut builder = SecondTableInABuilder::new(_fbb); let mut builder = SecondTableInABuilder::new(_fbb);
if let Some(x) = args.refer_to_c { builder.add_refer_to_c(x); } if let Some(x) = args.refer_to_c { builder.add_refer_to_c(x); }
builder.finish() builder.finish()
@@ -45,7 +48,6 @@ impl<'a> SecondTableInA<'a> {
refer_to_c, refer_to_c,
} }
} }
pub const VT_REFER_TO_C: flatbuffers::VOffsetT = 4;
#[inline] #[inline]
pub fn refer_to_c(&self) -> Option<super::namespace_c::TableInC<'a>> { pub fn refer_to_c(&self) -> Option<super::namespace_c::TableInC<'a>> {

14
tests/namespace_test/namespace_a/table_in_first_ns_generated.rs
View File

@@ -20,6 +20,12 @@ impl<'a> flatbuffers::Follow<'a> for TableInFirstNS<'a> {
} }
impl<'a> TableInFirstNS<'a> { impl<'a> TableInFirstNS<'a> {
pub const VT_FOO_TABLE: flatbuffers::VOffsetT = 4;
pub const VT_FOO_ENUM: flatbuffers::VOffsetT = 6;
pub const VT_FOO_UNION_TYPE: flatbuffers::VOffsetT = 8;
pub const VT_FOO_UNION: flatbuffers::VOffsetT = 10;
pub const VT_FOO_STRUCT: flatbuffers::VOffsetT = 12;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"NamespaceA.TableInFirstNS" "NamespaceA.TableInFirstNS"
} }
@@ -31,7 +37,8 @@ impl<'a> TableInFirstNS<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args TableInFirstNSArgs<'args>) -> flatbuffers::WIPOffset<TableInFirstNS<'bldr>> { args: &'args TableInFirstNSArgs<'args>
) -> flatbuffers::WIPOffset<TableInFirstNS<'bldr>> {
let mut builder = TableInFirstNSBuilder::new(_fbb); let mut builder = TableInFirstNSBuilder::new(_fbb);
if let Some(x) = args.foo_struct { builder.add_foo_struct(x); } if let Some(x) = args.foo_struct { builder.add_foo_struct(x); }
if let Some(x) = args.foo_union { builder.add_foo_union(x); } if let Some(x) = args.foo_union { builder.add_foo_union(x); }
@@ -65,11 +72,6 @@ impl<'a> TableInFirstNS<'a> {
foo_struct, foo_struct,
} }
} }
pub const VT_FOO_TABLE: flatbuffers::VOffsetT = 4;
pub const VT_FOO_ENUM: flatbuffers::VOffsetT = 6;
pub const VT_FOO_UNION_TYPE: flatbuffers::VOffsetT = 8;
pub const VT_FOO_UNION: flatbuffers::VOffsetT = 10;
pub const VT_FOO_STRUCT: flatbuffers::VOffsetT = 12;
#[inline] #[inline]
pub fn foo_table(&self) -> Option<namespace_b::TableInNestedNS<'a>> { pub fn foo_table(&self) -> Option<namespace_b::TableInNestedNS<'a>> {

8
tests/namespace_test/namespace_c/table_in_c_generated.rs
View File

@@ -20,6 +20,9 @@ impl<'a> flatbuffers::Follow<'a> for TableInC<'a> {
} }
impl<'a> TableInC<'a> { impl<'a> TableInC<'a> {
pub const VT_REFER_TO_A1: flatbuffers::VOffsetT = 4;
pub const VT_REFER_TO_A2: flatbuffers::VOffsetT = 6;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"NamespaceC.TableInC" "NamespaceC.TableInC"
} }
@@ -31,7 +34,8 @@ impl<'a> TableInC<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args TableInCArgs<'args>) -> flatbuffers::WIPOffset<TableInC<'bldr>> { args: &'args TableInCArgs<'args>
) -> flatbuffers::WIPOffset<TableInC<'bldr>> {
let mut builder = TableInCBuilder::new(_fbb); let mut builder = TableInCBuilder::new(_fbb);
if let Some(x) = args.refer_to_a2 { builder.add_refer_to_a2(x); } if let Some(x) = args.refer_to_a2 { builder.add_refer_to_a2(x); }
if let Some(x) = args.refer_to_a1 { builder.add_refer_to_a1(x); } if let Some(x) = args.refer_to_a1 { builder.add_refer_to_a1(x); }
@@ -50,8 +54,6 @@ impl<'a> TableInC<'a> {
refer_to_a2, refer_to_a2,
} }
} }
pub const VT_REFER_TO_A1: flatbuffers::VOffsetT = 4;
pub const VT_REFER_TO_A2: flatbuffers::VOffsetT = 6;
#[inline] #[inline]
pub fn refer_to_a1(&self) -> Option<super::namespace_a::TableInFirstNS<'a>> { pub fn refer_to_a1(&self) -> Option<super::namespace_a::TableInFirstNS<'a>> {

76
tests/optional_scalars/optional_scalars/scalar_stuff_generated.rs
View File

@@ -20,6 +20,43 @@ impl<'a> flatbuffers::Follow<'a> for ScalarStuff<'a> {
} }
impl<'a> ScalarStuff<'a> { impl<'a> ScalarStuff<'a> {
pub const VT_JUST_I8: flatbuffers::VOffsetT = 4;
pub const VT_MAYBE_I8: flatbuffers::VOffsetT = 6;
pub const VT_DEFAULT_I8: flatbuffers::VOffsetT = 8;
pub const VT_JUST_U8: flatbuffers::VOffsetT = 10;
pub const VT_MAYBE_U8: flatbuffers::VOffsetT = 12;
pub const VT_DEFAULT_U8: flatbuffers::VOffsetT = 14;
pub const VT_JUST_I16: flatbuffers::VOffsetT = 16;
pub const VT_MAYBE_I16: flatbuffers::VOffsetT = 18;
pub const VT_DEFAULT_I16: flatbuffers::VOffsetT = 20;
pub const VT_JUST_U16: flatbuffers::VOffsetT = 22;
pub const VT_MAYBE_U16: flatbuffers::VOffsetT = 24;
pub const VT_DEFAULT_U16: flatbuffers::VOffsetT = 26;
pub const VT_JUST_I32: flatbuffers::VOffsetT = 28;
pub const VT_MAYBE_I32: flatbuffers::VOffsetT = 30;
pub const VT_DEFAULT_I32: flatbuffers::VOffsetT = 32;
pub const VT_JUST_U32: flatbuffers::VOffsetT = 34;
pub const VT_MAYBE_U32: flatbuffers::VOffsetT = 36;
pub const VT_DEFAULT_U32: flatbuffers::VOffsetT = 38;
pub const VT_JUST_I64: flatbuffers::VOffsetT = 40;
pub const VT_MAYBE_I64: flatbuffers::VOffsetT = 42;
pub const VT_DEFAULT_I64: flatbuffers::VOffsetT = 44;
pub const VT_JUST_U64: flatbuffers::VOffsetT = 46;
pub const VT_MAYBE_U64: flatbuffers::VOffsetT = 48;
pub const VT_DEFAULT_U64: flatbuffers::VOffsetT = 50;
pub const VT_JUST_F32: flatbuffers::VOffsetT = 52;
pub const VT_MAYBE_F32: flatbuffers::VOffsetT = 54;
pub const VT_DEFAULT_F32: flatbuffers::VOffsetT = 56;
pub const VT_JUST_F64: flatbuffers::VOffsetT = 58;
pub const VT_MAYBE_F64: flatbuffers::VOffsetT = 60;
pub const VT_DEFAULT_F64: flatbuffers::VOffsetT = 62;
pub const VT_JUST_BOOL: flatbuffers::VOffsetT = 64;
pub const VT_MAYBE_BOOL: flatbuffers::VOffsetT = 66;
pub const VT_DEFAULT_BOOL: flatbuffers::VOffsetT = 68;
pub const VT_JUST_ENUM: flatbuffers::VOffsetT = 70;
pub const VT_MAYBE_ENUM: flatbuffers::VOffsetT = 72;
pub const VT_DEFAULT_ENUM: flatbuffers::VOffsetT = 74;
pub const fn get_fully_qualified_name() -> &'static str { pub const fn get_fully_qualified_name() -> &'static str {
"optional_scalars.ScalarStuff" "optional_scalars.ScalarStuff"
} }
@@ -31,7 +68,8 @@ impl<'a> ScalarStuff<'a> {
#[allow(unused_mut)] #[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args ScalarStuffArgs) -> flatbuffers::WIPOffset<ScalarStuff<'bldr>> { args: &'args ScalarStuffArgs
) -> flatbuffers::WIPOffset<ScalarStuff<'bldr>> {
let mut builder = ScalarStuffBuilder::new(_fbb); let mut builder = ScalarStuffBuilder::new(_fbb);
builder.add_default_f64(args.default_f64); builder.add_default_f64(args.default_f64);
if let Some(x) = args.maybe_f64 { builder.add_maybe_f64(x); } if let Some(x) = args.maybe_f64 { builder.add_maybe_f64(x); }
@@ -148,42 +186,6 @@ impl<'a> ScalarStuff<'a> {
default_enum, default_enum,
} }
} }
pub const VT_JUST_I8: flatbuffers::VOffsetT = 4;
pub const VT_MAYBE_I8: flatbuffers::VOffsetT = 6;
pub const VT_DEFAULT_I8: flatbuffers::VOffsetT = 8;
pub const VT_JUST_U8: flatbuffers::VOffsetT = 10;
pub const VT_MAYBE_U8: flatbuffers::VOffsetT = 12;
pub const VT_DEFAULT_U8: flatbuffers::VOffsetT = 14;
pub const VT_JUST_I16: flatbuffers::VOffsetT = 16;
pub const VT_MAYBE_I16: flatbuffers::VOffsetT = 18;
pub const VT_DEFAULT_I16: flatbuffers::VOffsetT = 20;
pub const VT_JUST_U16: flatbuffers::VOffsetT = 22;
pub const VT_MAYBE_U16: flatbuffers::VOffsetT = 24;
pub const VT_DEFAULT_U16: flatbuffers::VOffsetT = 26;
pub const VT_JUST_I32: flatbuffers::VOffsetT = 28;
pub const VT_MAYBE_I32: flatbuffers::VOffsetT = 30;
pub const VT_DEFAULT_I32: flatbuffers::VOffsetT = 32;
pub const VT_JUST_U32: flatbuffers::VOffsetT = 34;
pub const VT_MAYBE_U32: flatbuffers::VOffsetT = 36;
pub const VT_DEFAULT_U32: flatbuffers::VOffsetT = 38;
pub const VT_JUST_I64: flatbuffers::VOffsetT = 40;
pub const VT_MAYBE_I64: flatbuffers::VOffsetT = 42;
pub const VT_DEFAULT_I64: flatbuffers::VOffsetT = 44;
pub const VT_JUST_U64: flatbuffers::VOffsetT = 46;
pub const VT_MAYBE_U64: flatbuffers::VOffsetT = 48;
pub const VT_DEFAULT_U64: flatbuffers::VOffsetT = 50;
pub const VT_JUST_F32: flatbuffers::VOffsetT = 52;
pub const VT_MAYBE_F32: flatbuffers::VOffsetT = 54;
pub const VT_DEFAULT_F32: flatbuffers::VOffsetT = 56;
pub const VT_JUST_F64: flatbuffers::VOffsetT = 58;
pub const VT_MAYBE_F64: flatbuffers::VOffsetT = 60;
pub const VT_DEFAULT_F64: flatbuffers::VOffsetT = 62;
pub const VT_JUST_BOOL: flatbuffers::VOffsetT = 64;
pub const VT_MAYBE_BOOL: flatbuffers::VOffsetT = 66;
pub const VT_DEFAULT_BOOL: flatbuffers::VOffsetT = 68;
pub const VT_JUST_ENUM: flatbuffers::VOffsetT = 70;
pub const VT_MAYBE_ENUM: flatbuffers::VOffsetT = 72;
pub const VT_DEFAULT_ENUM: flatbuffers::VOffsetT = 74;
#[inline] #[inline]
pub fn just_i8(&self) -> i8 { pub fn just_i8(&self) -> i8 {