Lines Matching +full:unused +full:- +full:private +full:- +full:field
8 * http://www.apache.org/licenses/LICENSE-2.0
42 /*variables=*/Case::kUnknown, // Unused. in RustDefaultConfig()
61 // https://doc.rust-lang.org/book/second-edition/appendix-01-keywords.html in RustKeywords()
144 // Encapsulate all logical field types in this enum. This allows us to write
145 // field logic based on type switches, instead of branches on the properties
148 // declaration here. could we use the `-Wswitch-enum` warning to
187 if (type.struct_def->fixed) { in GetFullType()
242 if (type.enum_def->is_union) { in GetFullType()
248 FLATBUFFERS_ASSERT(false && "unknown union field type"); in GetFullType()
275 // TableArgs make required non-scalars "Option<_>".
277 static bool IsOptionalToBuilder(const FieldDef &field) { in IsOptionalToBuilder() argument
278 return field.IsOptional() || !IsScalar(field.value.type.base_type); in IsOptionalToBuilder()
300 for (auto it = symbol.defined_namespace->components.begin(); in GenerateRustModuleRootFile()
301 it != symbol.defined_namespace->components.end(); it++) { in GenerateRustModuleRootFile()
303 current_module = ¤t_module->sub_modules[ns_component]; in GenerateRustModuleRootFile()
305 current_module->generated_files.push_back( in GenerateRustModuleRootFile()
311 code += "pub mod " + it->first + " {"; in GenerateRustModuleRootFile()
314 it->second.GenerateImports(code); in GenerateRustModuleRootFile()
316 code += "} // " + it->first; in GenerateRustModuleRootFile()
410 parser_.enums_, [&](const EnumDef &e) { this->GenEnum(e); }) && in GenerateIndividualFiles()
414 this->GenStruct(s); in GenerateIndividualFiles()
416 this->GenTable(s); in GenerateIndividualFiles()
417 if (this->parser_.opts.generate_object_based_api) { in GenerateIndividualFiles()
418 this->GenTableObject(s); in GenerateIndividualFiles()
421 if (this->parser_.root_struct_def_ == &s) { in GenerateIndividualFiles()
422 this->GenRootTableFuncs(s); in GenerateIndividualFiles()
444 // permit re-opening modules. in GenerateOneFile()
502 private:
534 const auto &field = **it; in TableBuilderArgsNeedsLifetime() local
535 if (field.deprecated) { continue; } in TableBuilderArgsNeedsLifetime()
537 if (TableBuilderTypeNeedsLifetime(field.value.type)) { return true; } in TableBuilderArgsNeedsLifetime()
569 // example: f(A::B::C, A::B::C) -> (none) in GetRelativeNamespaceTraversal()
570 // example: f(A::B::C, A::B) -> super:: in GetRelativeNamespaceTraversal()
571 // example: f(A::B::C, A::B::D) -> super::D in GetRelativeNamespaceTraversal()
572 // example: f(A::B::C, A) -> super::super:: in GetRelativeNamespaceTraversal()
573 // example: f(A::B::C, D) -> super::super::super::D in GetRelativeNamespaceTraversal()
574 // example: f(A::B::C, D::E) -> super::super::super::D::E in GetRelativeNamespaceTraversal()
575 // example: f(A, D::E) -> super::D::E in GetRelativeNamespaceTraversal()
581 if (src) s = src->components; in GetRelativeNamespaceTraversal()
582 if (dst) d = dst->components; in GetRelativeNamespaceTraversal()
614 // clang-format off in GetTypeBasic()
622 // clang-format on in GetTypeBasic()
636 // clang-format off in GetEnumTypeForDecl()
644 // clang-format on in GetEnumTypeForDecl()
670 return WrapInNameSpace(type.struct_def->defined_namespace, in GetTypeGet()
671 type.struct_def->name) + in GetTypeGet()
675 return WrapInNameSpace(type.struct_def->defined_namespace, in GetTypeGet()
676 type.struct_def->name); in GetTypeGet()
699 std::function<void(const EnumVal &)> wrapped = [&](const EnumVal &unused) { in ForAllEnumValues() argument
700 (void)unused; in ForAllEnumValues()
711 (enum_def.attributes.Lookup("private") != nullptr); in GenEnum()
726 // matches Flatbuffers c-modeled enums where variants are associated in GenEnum()
735 this->GenComment(ev.doc_comment, " "); in GenEnum()
746 // Normal, c-modelled enums. in GenEnum()
782 this->GenComment(ev.doc_comment); in GenEnum()
793 code_ += " pub fn variant_name(self) -> Option<&'static str> {"; in GenEnum()
806 " fn fmt(&self, f: &mut core::fmt::Formatter) ->" in GenEnum()
823 " fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>"; in GenEnum()
844 code_ += " unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {"; in GenEnum()
881 code_ += " fn to_little_endian(self) -> {{BASE_TYPE}} {"; in GenEnum()
886 code_ += " fn from_little_endian(v: {{BASE_TYPE}}) -> Self {"; in GenEnum()
910 // Generate verifier - deferring to the base type. in GenEnum()
915 code_ += " ) -> Result<(), flatbuffers::InvalidFlatbuffer> {"; in GenEnum()
970 code_ += " fn default() -> Self {"; in GenUnionObject()
980 code_ += " pub fn {{ENUM_FN}}_type(&self) -> {{ENUM_TY}} {"; in GenUnionObject()
994 " -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>" in GenUnionObject()
1012 "pub fn take_{{U_ELEMENT_NAME}}(&mut self) -> " in GenUnionObject()
1030 "pub fn as_{{U_ELEMENT_NAME}}(&self) -> " in GenUnionObject()
1041 "pub fn as_{{U_ELEMENT_NAME}}_mut(&mut self) -> " in GenUnionObject()
1052 std::string GetDefaultValue(const FieldDef &field, in GetDefaultValue() argument
1058 if (!IsScalar(field.value.type.base_type) || field.IsOptional()) { in GetDefaultValue()
1064 if (field.IsOptional() && !IsUnion(field.value.type)) { return "None"; } in GetDefaultValue()
1066 switch (GetFullType(field.value.type)) { in GetDefaultValue()
1068 return field.value.constant; in GetDefaultValue()
1072 (field.value.type.base_type == BASE_TYPE_FLOAT) ? "f32::" : "f64::"; in GetDefaultValue()
1073 if (StringIsFlatbufferNan(field.value.constant)) { in GetDefaultValue()
1075 } else if (StringIsFlatbufferPositiveInfinity(field.value.constant)) { in GetDefaultValue()
1077 } else if (StringIsFlatbufferNegativeInfinity(field.value.constant)) { in GetDefaultValue()
1080 return field.value.constant; in GetDefaultValue()
1083 return field.value.constant == "0" ? "false" : "true"; in GetDefaultValue()
1087 auto ev = field.value.type.enum_def->FindByValue(field.value.constant); in GetDefaultValue()
1090 field.value.type.enum_def->defined_namespace, in GetDefaultValue()
1091 namer_.EnumVariant(*field.value.type.enum_def, *ev)); in GetDefaultValue()
1094 return ObjectFieldType(field, true) + "::NONE"; in GetDefaultValue()
1099 // value of field.value.constant is `0`, which is non-sensical except in GetDefaultValue()
1103 field.IsRequired() ? "\"\"" : "\"" + field.value.constant + "\""; in GetDefaultValue()
1144 // 2) return a hardcoded value because the relevant vtable field is not in
1146 // 3) return a hardcoded value because the vtable field value is set to zero.
1147 std::string TableBuilderArgsDefnType(const FieldDef &field, in TableBuilderArgsDefnType() argument
1149 const Type &type = field.value.type; in TableBuilderArgsDefnType()
1151 return IsOptionalToBuilder(field) ? "Option<" + s + ">" : s; in TableBuilderArgsDefnType()
1221 std::string ObjectFieldType(const FieldDef &field, bool in_a_table) { in ObjectFieldType() argument
1222 const Type &type = field.value.type; in ObjectFieldType()
1247 // newtype-struct-variants. in ObjectFieldType()
1299 if (in_a_table && !IsUnion(type) && field.IsOptional()) { in ObjectFieldType()
1306 std::string TableBuilderArgsAddFuncType(const FieldDef &field, in TableBuilderArgsAddFuncType() argument
1308 const Type &type = field.value.type; in TableBuilderArgsAddFuncType()
1310 switch (GetFullType(field.value.type)) { in TableBuilderArgsAddFuncType()
1387 std::string TableBuilderArgsAddFuncBody(const FieldDef &field) { in TableBuilderArgsAddFuncBody() argument
1388 const Type &type = field.value.type; in TableBuilderArgsAddFuncBody()
1390 switch (GetFullType(field.value.type)) { in TableBuilderArgsAddFuncBody()
1394 const auto typname = GetTypeBasic(field.value.type); in TableBuilderArgsAddFuncBody()
1395 return (field.IsOptional() ? "self.fbb_.push_slot_always::<" in TableBuilderArgsAddFuncBody()
1402 return (field.IsOptional() ? "self.fbb_.push_slot_always::<" in TableBuilderArgsAddFuncBody()
1439 std::string GenTableAccessorFuncReturnType(const FieldDef &field, in GenTableAccessorFuncReturnType() argument
1441 const Type &type = field.value.type; in GenTableAccessorFuncReturnType()
1443 return field.IsOptional() ? "Option<" + s + ">" : s; in GenTableAccessorFuncReturnType()
1446 switch (GetFullType(field.value.type)) { in GenTableAccessorFuncReturnType()
1518 const auto WrapForwardsUOffset = [](std::string ty) -> std::string { in FollowType()
1521 const auto WrapVector = [&](std::string ty) -> std::string { in FollowType()
1524 const auto WrapArray = [&](std::string ty, uint16_t length) -> std::string { in FollowType()
1593 std::string GenTableAccessorFuncBody(const FieldDef &field, in GenTableAccessorFuncBody() argument
1595 const std::string vt_offset = namer_.LegacyRustFieldOffsetName(field); in GenTableAccessorFuncBody()
1596 const std::string typname = FollowType(field.value.type, lifetime); in GenTableAccessorFuncBody()
1597 // Default-y fields (scalars so far) are neither optional nor required. in GenTableAccessorFuncBody()
1599 !(field.IsOptional() || field.IsRequired()) in GenTableAccessorFuncBody()
1600 ? "Some(" + GetDefaultValue(field, kAccessor) + ")" in GenTableAccessorFuncBody()
1602 const std::string unwrap = field.IsOptional() ? "" : ".unwrap()"; in GenTableAccessorFuncBody()
1609 // Generates a fully-qualified name getter for use with --gen-name-strings
1613 struct_def.defined_namespace->GetFullyQualifiedName(name); in GenFullyQualifiedNameGetter()
1614 code_ += " pub const fn get_fully_qualified_name() -> &'static str {"; in GenFullyQualifiedNameGetter()
1633 WrapInNameSpace(ev.union_type.struct_def->defined_namespace, in ForAllUnionVariantsBesidesNone()
1634 ev.union_type.struct_def->name)); in ForAllUnionVariantsBesidesNone()
1645 auto go = [&](const FieldDef &field) { in ForAllTableFields() argument
1646 if (field.deprecated) return; in ForAllTableFields()
1647 code_.SetValue("OFFSET_NAME", namer_.LegacyRustFieldOffsetName(field)); in ForAllTableFields()
1648 code_.SetValue("OFFSET_VALUE", NumToString(field.value.offset)); in ForAllTableFields()
1649 code_.SetValue("FIELD", namer_.Field(field)); in ForAllTableFields()
1650 code_.SetValue("BLDR_DEF_VAL", GetDefaultValue(field, kBuilder)); in ForAllTableFields()
1651 code_.SetValue("DISCRIMINANT", namer_.LegacyRustUnionTypeMethod(field)); in ForAllTableFields()
1653 cb(field); in ForAllTableFields()
1668 (struct_def.attributes.Lookup("private") != nullptr); in GenTable()
1688 code_ += " unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {"; in GenTable()
1695 // Generate field id constants. in GenTable()
1696 ForAllTableFields(struct_def, [&](const FieldDef &unused) { in GenTable() argument
1697 (void)unused; in GenTable()
1710 " pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> " in GenTable()
1727 code_ += " ) -> flatbuffers::WIPOffset<{{STRUCT_TY}}<'bldr>> {"; in GenTable()
1734 [&](const FieldDef &field) { in GenTable() argument
1736 size != SizeOf(field.value.type.base_type)) in GenTable()
1738 if (IsOptionalToBuilder(field)) { in GenTable()
1740 " if let Some(x) = args.{{FIELD}} " in GenTable()
1741 "{ builder.add_{{FIELD}}(x); }"; in GenTable()
1743 code_ += " builder.add_{{FIELD}}(args.{{FIELD}});"; in GenTable()
1756 code_ += " pub fn unpack(&self) -> {{STRUCT_OTY}} {"; in GenTable()
1757 ForAllObjectTableFields(struct_def, [&](const FieldDef &field) { in GenTable() argument
1758 const Type &type = field.value.type; in GenTable()
1764 code_ += " let {{FIELD}} = self.{{FIELD}}();"; in GenTable()
1773 namer_.LegacyRustUnionTypeMethod(field)); in GenTable()
1775 code_ += " let {{FIELD}} = match self.{{UNION_TYPE_METHOD}}() {"; in GenTable()
1781 code_ += " self.{{FIELD}}_as_{{U_ELEMENT_NAME}}()"; in GenTable()
1793 // The rest of the types need special handling based on if the field in GenTable()
1835 if (field.IsOptional()) { in GenTable()
1836 code_ += " let {{FIELD}} = self.{{FIELD}}().map(|x| {"; in GenTable()
1840 code_ += " let {{FIELD}} = {"; in GenTable()
1841 code_ += " let x = self.{{FIELD}}();"; in GenTable()
1847 ForAllObjectTableFields(struct_def, [&](const FieldDef &field) { in GenTable() argument
1848 if (field.value.type.base_type == BASE_TYPE_UTYPE) return; in GenTable()
1849 code_ += " {{FIELD}},"; in GenTable()
1860 // pub fn name(&'a self) -> Option<user_facing_type> { in GenTable()
1865 // pub fn name(&'a self) -> user_facing_type { in GenTable()
1868 ForAllTableFields(struct_def, [&](const FieldDef &field) { in GenTable() argument
1870 GenTableAccessorFuncReturnType(field, "'a")); in GenTable()
1872 this->GenComment(field.doc_comment); in GenTable()
1874 code_ += "pub fn {{FIELD}}(&self) -> {{RETURN_TYPE}} {"; in GenTable()
1878 code_ += " " + GenTableAccessorFuncBody(field, "'a"); in GenTable()
1881 // Generate a comparison function for this field if it is a key. in GenTable()
1882 if (field.key) { GenKeyFieldMethods(field); } in GenTable()
1884 // Generate a nested flatbuffer field, if applicable. in GenTable()
1885 auto nested = field.attributes.Lookup("nested_flatbuffer"); in GenTable()
1887 std::string qualified_name = nested->constant; in GenTable()
1888 auto nested_root = parser_.LookupStruct(nested->constant); in GenTable()
1890 qualified_name = parser_.current_namespace_->GetFullyQualifiedName( in GenTable()
1891 nested->constant); in GenTable()
1897 code_ += "pub fn {{FIELD}}_nested_flatbuffer(&'a self) -> \\"; in GenTable()
1898 if (field.IsRequired()) { in GenTable()
1900 code_ += " let data = self.{{FIELD}}();"; in GenTable()
1910 code_ += " self.{{FIELD}}().map(|data| {"; in GenTable()
1925 ForAllTableFields(struct_def, [&](const FieldDef &field) { in GenTable() argument
1926 if (field.value.type.base_type != BASE_TYPE_UNION) return; in GenTable()
1928 *field.value.type.enum_def, [&](const EnumVal &unused) { in GenTable() argument
1929 (void)unused; in GenTable()
1933 "pub fn {{FIELD}}_as_{{U_ELEMENT_NAME}}(&self) -> " in GenTable()
1935 // If the user defined schemas name a field that clashes with a in GenTable()
1936 // language reserved word, flatc will try to escape the field name in GenTable()
1945 // To avoid this problem the type field name is used unescaped here: in GenTable()
1951 if (field.IsRequired()) { in GenTable()
1952 code_ += " let u = self.{{FIELD}}();"; in GenTable()
1960 code_ += " self.{{FIELD}}().map(|t| {"; in GenTable()
1984 code_ += " ) -> Result<(), flatbuffers::InvalidFlatbuffer> {"; in GenTable()
1989 ForAllTableFields(struct_def, [&](const FieldDef &field) { in GenTable() argument
1990 if (GetFullType(field.value.type) == ftUnionKey) return; in GenTable()
1992 code_.SetValue("IS_REQ", field.IsRequired() ? "true" : "false"); in GenTable()
1993 if (GetFullType(field.value.type) != ftUnionValue) { in GenTable()
1995 code_.SetValue("TY", FollowType(field.value.type, "'_")); in GenTable()
1997 "\n .visit_field::<{{TY}}>(\"{{FIELD}}\", " in GenTable()
2002 const EnumDef &union_def = *field.value.type.enum_def; in GenTable()
2005 namer_.LegacyRustUnionTypeOffsetName(field)); in GenTable()
2007 namer_.LegacyRustUnionTypeMethod(field)); in GenTable()
2011 "\"{{FIELD}}\", Self::{{OFFSET_NAME}}, {{IS_REQ}}, " in GenTable()
2014 ForAllUnionVariantsBesidesNone(union_def, [&](const EnumVal &unused) { in GenTable() argument
2015 (void)unused; in GenTable()
2034 ForAllTableFields(struct_def, [&](const FieldDef &field) { in GenTable() argument
2035 code_.SetValue("PARAM_TYPE", TableBuilderArgsDefnType(field, "'a")); in GenTable()
2036 code_ += " pub {{FIELD}}: {{PARAM_TYPE}},"; in GenTable()
2043 code_ += " fn default() -> Self {"; in GenTable()
2045 ForAllTableFields(struct_def, [&](const FieldDef &field) { in GenTable() argument
2046 code_ += " {{FIELD}}: {{BLDR_DEF_VAL}},\\"; in GenTable()
2047 code_ += field.IsRequired() ? " // required field" : ""; in GenTable()
2060 " fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>"; in GenTable()
2072 ForAllTableFields(struct_def, [&](const FieldDef &field) { in GenTable() argument
2073 const Type &type = field.value.type; in GenTable()
2078 code_.SetValue("FIELD", namer_.Field(field)); in GenTable()
2080 namer_.LegacyRustUnionTypeMethod(field)); in GenTable()
2085 code_.SetValue("FIELD", namer_.Field(field)); in GenTable()
2089 "self.{{FIELD}}_as_{{U_ELEMENT_NAME}}()"; in GenTable()
2093 code_ += " s.serialize_field(\"{{FIELD}}\", &f)?;"; in GenTable()
2100 " s.serialize_field(\"{{FIELD}}\", " in GenTable()
2101 "&self.{{FIELD}}())?;"; in GenTable()
2104 if (field.IsOptional()) { in GenTable()
2105 code_ += " if let Some(f) = self.{{FIELD}}() {"; in GenTable()
2106 code_ += " s.serialize_field(\"{{FIELD}}\", &f)?;"; in GenTable()
2108 code_ += " s.skip_field(\"{{FIELD}}\")?;"; in GenTable()
2112 " s.serialize_field(\"{{FIELD}}\", " in GenTable()
2113 "&self.{{FIELD}}())?;"; in GenTable()
2138 ForAllTableFields(struct_def, [&](const FieldDef &field) { in GenTable() argument
2139 const bool is_scalar = IsScalar(field.value.type.base_type); in GenTable()
2140 std::string offset = namer_.LegacyRustFieldOffsetName(field); in GenTable()
2153 code_.SetValue("FIELD_TYPE", TableBuilderArgsAddFuncType(field, "'b ")); in GenTable()
2154 code_.SetValue("FUNC_BODY", TableBuilderArgsAddFuncBody(field)); in GenTable()
2157 "pub fn add_{{FIELD}}(&mut self, {{FIELD}}: " in GenTable()
2159 if (is_scalar && !field.IsOptional()) { in GenTable()
2161 " {{FUNC_BODY}}({{FIELD_OFFSET}}, {{FIELD}}, " in GenTable()
2164 code_ += " {{FUNC_BODY}}({{FIELD_OFFSET}}, {{FIELD}});"; in GenTable()
2172 " pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> " in GenTable()
2185 " pub fn finish(self) -> " in GenTable()
2189 ForAllTableFields(struct_def, [&](const FieldDef &field) { in GenTable() argument
2190 if (!field.IsRequired()) return; in GenTable()
2193 "\"{{FIELD}}\");"; in GenTable()
2203 ") -> core::fmt::Result {"; in GenTable()
2205 ForAllTableFields(struct_def, [&](const FieldDef &field) { in GenTable() argument
2206 if (GetFullType(field.value.type) == ftUnionValue) { in GenTable()
2208 code_.SetValue("KEY_TYPE", GenTableAccessorFuncReturnType(field, "")); in GenTable()
2215 *field.value.type.enum_def, [&](const EnumVal &unused) { in GenTable() argument
2216 (void)unused; in GenTable()
2220 "self.{{FIELD}}_as_" in GenTable()
2222 code_ += " ds.field(\"{{FIELD}}\", &x)"; in GenTable()
2224 code_ += " ds.field(\"{{FIELD}}\", {{UNION_ERR}})"; in GenTable()
2230 code_ += " ds.field(\"{{FIELD}}\", &x)"; in GenTable()
2235 code_ += " ds.field(\"{{FIELD}}\", &self.{{FIELD}}());"; in GenTable()
2251 ForAllObjectTableFields(table, [&](const FieldDef &field) { in GenTableObject() argument
2253 // skip making a field for the discriminant. in GenTableObject()
2254 if (field.value.type.base_type == BASE_TYPE_UTYPE) return; in GenTableObject()
2255 code_ += "pub {{FIELD}}: {{FIELD_OTY}},"; in GenTableObject()
2260 code_ += " fn default() -> Self {"; in GenTableObject()
2262 ForAllObjectTableFields(table, [&](const FieldDef &field) { in GenTableObject() argument
2263 if (field.value.type.base_type == BASE_TYPE_UTYPE) return; in GenTableObject()
2264 std::string default_value = GetDefaultValue(field, kObject); in GenTableObject()
2265 code_ += " {{FIELD}}: " + default_value + ","; in GenTableObject()
2279 code_ += " ) -> flatbuffers::WIPOffset<{{STRUCT_TY}}<'b>> {"; in GenTableObject()
2280 // First we generate variables for each field and then later assemble them in GenTableObject()
2282 ForAllObjectTableFields(table, [&](const FieldDef &field) { in GenTableObject() argument
2283 const Type &type = field.value.type; in GenTableObject()
2289 code_ += " let {{FIELD}} = self.{{FIELD}};"; in GenTableObject()
2295 namer_.Method(*field.value.type.enum_def)); in GenTableObject()
2297 namer_.LegacyRustUnionTypeMethod(field)); in GenTableObject()
2300 "self.{{FIELD}}.{{ENUM_METHOD}}_type();"; in GenTableObject()
2301 code_ += " let {{FIELD}} = self.{{FIELD}}.pack(_fbb);"; in GenTableObject()
2307 MapNativeTableField(field, "_fbb.create_string(x)"); in GenTableObject()
2312 if (field.IsRequired()) { in GenTableObject()
2313 code_ += " let {{FIELD}}_tmp = Some(self.{{FIELD}}.pack());"; in GenTableObject()
2316 " let {{FIELD}}_tmp = self.{{FIELD}}" in GenTableObject()
2319 code_ += " let {{FIELD}} = {{FIELD}}_tmp.as_ref();"; in GenTableObject()
2324 MapNativeTableField(field, "x.pack(_fbb)"); in GenTableObject()
2331 MapNativeTableField(field, "_fbb.create_vector(x)"); in GenTableObject()
2336 field, in GenTableObject()
2345 MapNativeTableField(field, in GenTableObject()
2353 field, in GenTableObject()
2371 ForAllObjectTableFields(table, [&](const FieldDef &field) { in GenTableObject() argument
2372 (void)field; // Unused. in GenTableObject()
2373 code_ += " {{FIELD}},"; in GenTableObject()
2383 const FieldDef &field = **it; in ForAllObjectTableFields() local
2384 if (field.deprecated) continue; in ForAllObjectTableFields()
2385 code_.SetValue("FIELD", namer_.Field(field)); in ForAllObjectTableFields()
2386 code_.SetValue("FIELD_OTY", ObjectFieldType(field, true)); in ForAllObjectTableFields()
2388 cb(field); in ForAllObjectTableFields()
2392 void MapNativeTableField(const FieldDef &field, const std::string &expr) { in MapNativeTableField() argument
2393 if (field.IsOptional()) { in MapNativeTableField()
2394 code_ += " let {{FIELD}} = self.{{FIELD}}.as_ref().map(|x|{"; in MapNativeTableField()
2400 code_ += " let {{FIELD}} = Some({"; in MapNativeTableField()
2401 code_ += " let x = &self.{{FIELD}};"; in MapNativeTableField()
2408 // must only be called if the field key is defined.
2409 void GenKeyFieldMethods(const FieldDef &field) { in GenKeyFieldMethods() argument
2410 FLATBUFFERS_ASSERT(field.key); in GenKeyFieldMethods()
2412 code_.SetValue("KEY_TYPE", GenTableAccessorFuncReturnType(field, "")); in GenKeyFieldMethods()
2413 code_.SetValue("REF", IsString(field.value.type) ? "" : "&"); in GenKeyFieldMethods()
2417 "pub fn key_compare_less_than(&self, o: &{{STRUCT_TY}}) -> " in GenKeyFieldMethods()
2419 code_ += " self.{{FIELD}}() < o.{{FIELD}}()"; in GenKeyFieldMethods()
2424 "pub fn key_compare_with_value(&self, val: {{KEY_TYPE}}) -> " in GenKeyFieldMethods()
2426 code_ += " let key = self.{{FIELD}}();"; in GenKeyFieldMethods()
2449 "-> Result<{{STRUCT_TY}}, flatbuffers::InvalidFlatbuffer> {"; in GenRootTableFuncs()
2461 "(buf: &[u8]) -> Result<{{STRUCT_TY}}, " in GenRootTableFuncs()
2477 ") -> Result<{{STRUCT_TY}}<'b>, flatbuffers::InvalidFlatbuffer>" in GenRootTableFuncs()
2494 ") -> Result<{{STRUCT_TY}}<'b>, flatbuffers::InvalidFlatbuffer>" in GenRootTableFuncs()
2511 "(buf: &[u8]) -> {{STRUCT_TY}} {"; in GenRootTableFuncs()
2524 "_unchecked(buf: &[u8]) -> {{STRUCT_TY}} {"; in GenRootTableFuncs()
2540 code_ += "(buf: &[u8]) -> bool {"; in GenRootTableFuncs()
2547 code_ += "_buffer_has_identifier(buf: &[u8]) -> bool {"; in GenRootTableFuncs()
2592 const FieldDef &field, std::string *code_ptr, int *id, in GenPadding() argument
2594 if (field.padding) { in GenPadding()
2596 if (static_cast<int>(field.padding) & (1 << i)) { in GenPadding()
2600 assert(!(field.padding & ~0xF)); in GenPadding()
2615 std::function<void(const FieldDef &field)> cb) { in ForAllStructFields()
2619 const auto &field = **it; in ForAllStructFields() local
2620 code_.SetValue("FIELD_TYPE", GetTypeGet(field.value.type)); in ForAllStructFields()
2621 code_.SetValue("FIELD_OTY", ObjectFieldType(field, false)); in ForAllStructFields()
2622 code_.SetValue("FIELD", namer_.Field(field)); in ForAllStructFields()
2626 IsStruct(field.value.type) || IsArray(field.value.type) ? "&" : ""); in ForAllStructFields()
2628 cb(field); in ForAllStructFields()
2630 const size_t size = InlineSize(field.value.type); in ForAllStructFields()
2631 offset_to_field += size + field.padding; in ForAllStructFields()
2638 (struct_def.attributes.Lookup("private") != nullptr); in GenStruct()
2641 // Variables are private because they contain little endian data on all in GenStruct()
2648 // We represent Flatbuffers-structs in Rust-u8-arrays since the data may be in GenStruct()
2659 code_ += " fn default() -> Self { "; in GenStruct()
2668 ") -> core::fmt::Result {"; in GenStruct()
2670 ForAllStructFields(struct_def, [&](const FieldDef &unused) { in GenStruct() argument
2671 (void)unused; in GenStruct()
2672 code_ += " .field(\"{{FIELD}}\", &self.{{FIELD}}())"; in GenStruct()
2679 // Generate impls for SafeSliceAccess (because all structs are endian-safe), in GenStruct()
2686 code_ += " unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {"; in GenStruct()
2693 code_ += " unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {"; in GenStruct()
2715 code_ += " ) -> Result<(), flatbuffers::InvalidFlatbuffer> {"; in GenStruct()
2728 " fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>"; in GenStruct()
2740 ForAllStructFields(struct_def, [&](const FieldDef &unused) { in GenStruct() argument
2741 (void)unused; in GenStruct()
2743 " s.serialize_field(\"{{FIELD}}\", " in GenStruct()
2744 "&self.{{FIELD}}())?;"; in GenStruct()
2756 ForAllStructFields(struct_def, [&](const FieldDef &unused) { in GenStruct() argument
2757 (void)unused; in GenStruct()
2758 code_ += " {{FIELD}}: {{REF}}{{FIELD_TYPE}},"; in GenStruct()
2760 code_ += " ) -> Self {"; in GenStruct()
2762 ForAllStructFields(struct_def, [&](const FieldDef &unused) { in GenStruct() argument
2763 (void)unused; in GenStruct()
2764 code_ += " s.set_{{FIELD}}({{FIELD}});"; in GenStruct()
2775 ForAllStructFields(struct_def, [&](const FieldDef &field) { in GenStruct() argument
2776 this->GenComment(field.doc_comment); in GenStruct()
2778 if (IsStruct(field.value.type)) { in GenStruct()
2779 code_ += "pub fn {{FIELD}}(&self) -> &{{FIELD_TYPE}} {"; in GenStruct()
2787 } else if (IsArray(field.value.type)) { in GenStruct()
2789 NumToString(field.value.type.fixed_length)); in GenStruct()
2790 code_.SetValue("ARRAY_ITEM", GetTypeGet(field.value.type.VectorType())); in GenStruct()
2792 "pub fn {{FIELD}}(&'a self) -> " in GenStruct()
2801 code_ += "pub fn {{FIELD}}(&self) -> {{FIELD_TYPE}} {"; in GenStruct()
2821 if (IsStruct(field.value.type)) { in GenStruct()
2822 code_.SetValue("FIELD_SIZE", NumToString(InlineSize(field.value.type))); in GenStruct()
2824 code_ += "pub fn set_{{FIELD}}(&mut self, x: &{{FIELD_TYPE}}) {"; in GenStruct()
2828 } else if (IsArray(field.value.type)) { in GenStruct()
2829 if (GetFullType(field.value.type) == ftArrayOfBuiltin) { in GenStruct()
2831 GetTypeGet(field.value.type.VectorType())); in GenStruct()
2834 NumToString(InlineSize(field.value.type.VectorType()))); in GenStruct()
2836 "pub fn set_{{FIELD}}(&mut self, items: &{{FIELD_TYPE}}) " in GenStruct()
2846 NumToString(InlineSize(field.value.type))); in GenStruct()
2847 code_ += "pub fn set_{{FIELD}}(&mut self, x: &{{FIELD_TYPE}}) {"; in GenStruct()
2860 code_ += "pub fn set_{{FIELD}}(&mut self, x: {{FIELD_TYPE}}) {"; in GenStruct()
2877 // Generate a comparison function for this field if it is a key. in GenStruct()
2878 if (field.key) { GenKeyFieldMethods(field); } in GenStruct()
2884 code_ += " pub fn unpack(&self) -> {{STRUCT_OTY}} {"; in GenStruct()
2886 ForAllStructFields(struct_def, [&](const FieldDef &field) { in GenStruct() argument
2887 if (IsArray(field.value.type)) { in GenStruct()
2888 if (GetFullType(field.value.type) == ftArrayOfStruct) { in GenStruct()
2890 " {{FIELD}}: { let {{FIELD}} = " in GenStruct()
2891 "self.{{FIELD}}(); flatbuffers::array_init(|i| " in GenStruct()
2892 "{{FIELD}}.get(i).unpack()) },"; in GenStruct()
2894 code_ += " {{FIELD}}: self.{{FIELD}}().into(),"; in GenStruct()
2897 std::string unpack = IsStruct(field.value.type) ? ".unpack()" : ""; in GenStruct()
2898 code_ += " {{FIELD}}: self.{{FIELD}}()" + unpack + ","; in GenStruct()
2913 ForAllStructFields(struct_def, [&](const FieldDef &field) { in GenStruct() argument
2914 (void)field; // unused. in GenStruct()
2915 code_ += "pub {{FIELD}}: {{FIELD_OTY}},"; in GenStruct()
2921 code_ += " pub fn pack(&self) -> {{STRUCT_TY}} {"; in GenStruct()
2923 ForAllStructFields(struct_def, [&](const FieldDef &field) { in GenStruct() argument
2924 if (IsStruct(field.value.type)) { in GenStruct()
2925 code_ += " &self.{{FIELD}}.pack(),"; in GenStruct()
2926 } else if (IsArray(field.value.type)) { in GenStruct()
2927 if (GetFullType(field.value.type) == ftArrayOfStruct) { in GenStruct()
2930 "self.{{FIELD}}[i].pack()),"; in GenStruct()
2932 code_ += " &self.{{FIELD}},"; in GenStruct()
2935 code_ += " self.{{FIELD}},"; in GenStruct()
2954 if (it->second.empty()) continue; in GenNamespaceImports()
2955 auto noext = flatbuffers::StripExtension(it->second); in GenNamespaceImports()
2997 size_t old_size = cur_name_space_ ? cur_name_space_->components.size() : 0; in SetNameSpace()
2998 size_t new_size = ns ? ns->components.size() : 0; in SetNameSpace()
3002 ns->components[common_prefix_size] == in SetNameSpace()
3003 cur_name_space_->components[common_prefix_size]) { in SetNameSpace()
3009 for (size_t j = old_size; j > common_prefix_size; --j) { in SetNameSpace()
3010 code_ += "} // pub mod " + cur_name_space_->components[j - 1]; in SetNameSpace()
3018 code_ += "pub mod " + namer_.Namespace(ns->components[j]) + " {"; in SetNameSpace()
3027 private:
3112 // TODO(rw): Generated code should generate endian-safe Debug impls.
3113 // TODO(rw): Generated code could use a Rust-only enum type to access unions,
3121 // are crate-relative which may undesirable.