From 261cf3b20473abdf95fc34da0827e4986f065c39 Mon Sep 17 00:00:00 2001 From: Casper Date: Tue, 6 Apr 2021 07:23:45 -0400 Subject: [PATCH] Default-empty vectors of enums (#6505) * disable clippy * Vector of enum default * swift and tests * git clang format * Rewrite enum parser checks * Remove Voids from more_defaults * vector enum swift * remove vector accessor from swift * clang format Co-authored-by: Casper Neo --- src/idl_gen_swift.cpp | 6 +- src/idl_parser.cpp | 42 +++--- tests/FlatBuffers.Test.Swift/SwiftTest.sh | 1 + .../FlatbuffersMoreDefaults.swift | 7 + .../monster_test_generated.swift | 10 +- .../more_defaults_generated.swift | 46 +++++- .../optional_scalars_generated.swift | 2 +- .../union_vector_generated.swift | 2 +- tests/more_defaults.fbs | 5 + tests/more_defaults_generated.rs | 140 ++++++++++++++++++ .../tests/more_defaults_test.rs | 4 + tests/test.cpp | 1 + 12 files changed, 238 insertions(+), 28 deletions(-) diff --git a/src/idl_gen_swift.cpp b/src/idl_gen_swift.cpp index afac8451f..14c748b3c 100644 --- a/src/idl_gen_swift.cpp +++ b/src/idl_gen_swift.cpp @@ -848,7 +848,7 @@ class SwiftGenerator : public BaseGenerator { code_.SetValue("ENUM_NAME", NameWrappedInNameSpace(enum_def)); code_.SetValue("BASE_TYPE", GenTypeBasic(enum_def.underlying_type, false)); GenComment(enum_def.doc_comment); - code_ += "{{ACCESS_TYPE}} enum {{ENUM_NAME}}: {{BASE_TYPE}}, Enum { "; + code_ += "{{ACCESS_TYPE}} enum {{ENUM_NAME}}: {{BASE_TYPE}}, Enum {"; Indent(); code_ += "{{ACCESS_TYPE}} typealias T = {{BASE_TYPE}}"; code_ += @@ -1472,7 +1472,9 @@ class SwiftGenerator : public BaseGenerator { auto &value = field.value; FLATBUFFERS_ASSERT(value.type.enum_def); auto &enum_def = *value.type.enum_def; - auto enum_val = enum_def.FindByValue(value.constant); + // Vector of enum defaults are always "[]" which never works. + const std::string constant = IsVector(value.type) ? "0" : value.constant; + auto enum_val = enum_def.FindByValue(constant); std::string name; if (enum_val) { name = Name(*enum_val); diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp index f20b6f9ad..69fa9d139 100644 --- a/src/idl_parser.cpp +++ b/src/idl_parser.cpp @@ -910,24 +910,32 @@ CheckedError Parser::ParseField(StructDef &struct_def) { } if (type.enum_def) { - // The type.base_type can only be scalar, union, array or vector. - // Table, struct or string can't have enum_def. - // Default value of union and vector in NONE, NULL translated to "0". - FLATBUFFERS_ASSERT(IsInteger(type.base_type) || - (type.base_type == BASE_TYPE_UNION) || IsVector(type) || - IsArray(type)); - if (IsVector(type)) { - // Vector can't use initialization list. - FLATBUFFERS_ASSERT(field->value.constant == "0"); + // Verify the enum's type and default value. + const std::string &constant = field->value.constant; + if (type.base_type == BASE_TYPE_UNION) { + if (constant != "0") { return Error("Union defaults must be NONE"); } + } else if (IsVector(type)) { + if (constant != "0" && constant != "[]") { + return Error("Vector defaults may only be `[]`."); + } + } else if (IsArray(type)) { + if (constant != "0") { + return Error("Array defaults are not supported yet."); + } } else { - // All unions should have the NONE ("0") enum value. - auto in_enum = field->IsOptional() || - type.enum_def->attributes.Lookup("bit_flags") || - type.enum_def->FindByValue(field->value.constant); - if (false == in_enum) - return Error("default value of " + field->value.constant + - " for field " + name + " is not part of enum " + - type.enum_def->name); + if (!IsInteger(type.base_type)) { + return Error("Enums must have integer base types"); + } + // Optional and bitflags enums may have default constants that are not + // their specified variants. + if (!field->IsOptional() && + type.enum_def->attributes.Lookup("bit_flags") == nullptr) { + if (type.enum_def->FindByValue(constant) == nullptr) { + return Error("default value of `" + constant + "` for " + "field `" + + name + "` is not part of enum `" + type.enum_def->name + + "`."); + } + } } } diff --git a/tests/FlatBuffers.Test.Swift/SwiftTest.sh b/tests/FlatBuffers.Test.Swift/SwiftTest.sh index 06b2d6f18..5e1c6cddb 100755 --- a/tests/FlatBuffers.Test.Swift/SwiftTest.sh +++ b/tests/FlatBuffers.Test.Swift/SwiftTest.sh @@ -2,6 +2,7 @@ swift_dir=`pwd` cd .. test_dir=`pwd` alias fbc='${test_dir}/../flatc' +shopt -s expand_aliases cd ${swift_dir}/Tests/FlatBuffers.Test.SwiftTests fbc --swift --gen-mutable --grpc --gen-object-api -I ${test_dir}/include_test ${test_dir}/monster_test.fbs ${test_dir}/union_vector/union_vector.fbs diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatbuffersMoreDefaults.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatbuffersMoreDefaults.swift index 5eb1f3d24..2839d2a54 100644 --- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatbuffersMoreDefaults.swift +++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatbuffersMoreDefaults.swift @@ -29,8 +29,11 @@ class FlatBuffersMoreDefaults: XCTestCase { XCTAssertEqual(defaults.someString, "some") XCTAssertEqual(defaults.ints, []) XCTAssertEqual(defaults.floats, []) + XCTAssertEqual(defaults.bools, []) XCTAssertEqual(defaults.intsCount, 0) XCTAssertEqual(defaults.floatsCount, 0) + XCTAssertEqual(defaults.abcsCount, 0) + XCTAssertEqual(defaults.boolsCount, 0) } func testFlatbuffersObjectAPI() { @@ -40,6 +43,8 @@ class FlatBuffersMoreDefaults: XCTestCase { XCTAssertEqual(defaults.someString, "some") XCTAssertEqual(defaults.ints, []) XCTAssertEqual(defaults.floats, []) + XCTAssertEqual(defaults.abcs, []) + XCTAssertEqual(defaults.bools, []) let buffer = defaults.serialize(builder: &fbb, type: MoreDefaults.self) let fDefaults = MoreDefaults.getRootAsMoreDefaults(bb: buffer) @@ -49,5 +54,7 @@ class FlatBuffersMoreDefaults: XCTestCase { XCTAssertEqual(fDefaults.floats, []) XCTAssertEqual(fDefaults.intsCount, 0) XCTAssertEqual(fDefaults.floatsCount, 0) + XCTAssertEqual(fDefaults.abcsCount, 0) + XCTAssertEqual(fDefaults.boolsCount, 0) } } diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift index 0eb129f4d..03de61c2d 100644 --- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift +++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift @@ -5,7 +5,7 @@ import FlatBuffers /// Composite components of Monster color. -public enum MyGame_Example_Color: UInt8, Enum { +public enum MyGame_Example_Color: UInt8, Enum { public typealias T = UInt8 public static var byteSize: Int { return MemoryLayout.size } public var value: UInt8 { return self.rawValue } @@ -21,7 +21,7 @@ public enum MyGame_Example_Color: UInt8, Enum { public static var min: MyGame_Example_Color { return .red } } -public enum MyGame_Example_Race: Int8, Enum { +public enum MyGame_Example_Race: Int8, Enum { public typealias T = Int8 public static var byteSize: Int { return MemoryLayout.size } public var value: Int8 { return self.rawValue } @@ -35,7 +35,7 @@ public enum MyGame_Example_Race: Int8, Enum { public static var min: MyGame_Example_Race { return .none_ } } -public enum MyGame_Example_Any_: UInt8, Enum { +public enum MyGame_Example_Any_: UInt8, Enum { public typealias T = UInt8 public static var byteSize: Int { return MemoryLayout.size } public var value: UInt8 { return self.rawValue } @@ -71,7 +71,7 @@ public struct MyGame_Example_Any_Union { } } } -public enum MyGame_Example_AnyUniqueAliases: UInt8, Enum { +public enum MyGame_Example_AnyUniqueAliases: UInt8, Enum { public typealias T = UInt8 public static var byteSize: Int { return MemoryLayout.size } public var value: UInt8 { return self.rawValue } @@ -107,7 +107,7 @@ public struct MyGame_Example_AnyUniqueAliasesUnion { } } } -public enum MyGame_Example_AnyAmbiguousAliases: UInt8, Enum { +public enum MyGame_Example_AnyAmbiguousAliases: UInt8, Enum { public typealias T = UInt8 public static var byteSize: Int { return MemoryLayout.size } public var value: UInt8 { return self.rawValue } diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/more_defaults_generated.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/more_defaults_generated.swift index 12b67f12f..6ac5d14ba 100644 --- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/more_defaults_generated.swift +++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/more_defaults_generated.swift @@ -4,6 +4,19 @@ import FlatBuffers +public enum ABC: Int32, Enum { + public typealias T = Int32 + public static var byteSize: Int { return MemoryLayout.size } + public var value: Int32 { return self.rawValue } + case a = 0 + case b = 1 + case c = 2 + + + public static var max: ABC { return .c } + public static var min: ABC { return .a } +} + public struct MoreDefaults: FlatBufferObject, ObjectAPIPacker { static func validateVersion() { FlatBuffersVersion_1_12_0() } @@ -20,6 +33,8 @@ public struct MoreDefaults: FlatBufferObject, ObjectAPIPacker { case floats = 6 case emptyString = 8 case someString = 10 + case abcs = 12 + case bools = 14 var v: Int32 { Int32(self.rawValue) } var p: VOffset { self.rawValue } } @@ -34,24 +49,35 @@ public struct MoreDefaults: FlatBufferObject, ObjectAPIPacker { public var emptyStringSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.emptyString.v) } public var someString: String? { let o = _accessor.offset(VTOFFSET.someString.v); return o == 0 ? "some" : _accessor.string(at: o) } public var someStringSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.someString.v) } - public static func startMoreDefaults(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 4) } + public var abcsCount: Int32 { let o = _accessor.offset(VTOFFSET.abcs.v); return o == 0 ? 0 : _accessor.vector(count: o) } + public func abcs(at index: Int32) -> ABC? { let o = _accessor.offset(VTOFFSET.abcs.v); return o == 0 ? ABC.a : ABC(rawValue: _accessor.directRead(of: Int32.self, offset: _accessor.vector(at: o) + index * 4)) } + public var boolsCount: Int32 { let o = _accessor.offset(VTOFFSET.bools.v); return o == 0 ? 0 : _accessor.vector(count: o) } + public func bools(at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.bools.v); return o == 0 ? true : _accessor.directRead(of: Bool.self, offset: _accessor.vector(at: o) + index * 1) } + public var bools: [Bool] { return _accessor.getVector(at: VTOFFSET.bools.v) ?? [] } + public static func startMoreDefaults(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 6) } public static func addVectorOf(ints: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: ints, at: VTOFFSET.ints.p) } public static func addVectorOf(floats: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: floats, at: VTOFFSET.floats.p) } public static func add(emptyString: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: emptyString, at: VTOFFSET.emptyString.p) } public static func add(someString: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: someString, at: VTOFFSET.someString.p) } + public static func addVectorOf(abcs: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: abcs, at: VTOFFSET.abcs.p) } + public static func addVectorOf(bools: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: bools, at: VTOFFSET.bools.p) } public static func endMoreDefaults(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end } public static func createMoreDefaults( _ fbb: inout FlatBufferBuilder, intsVectorOffset ints: Offset = Offset(), floatsVectorOffset floats: Offset = Offset(), emptyStringOffset emptyString: Offset = Offset(), - someStringOffset someString: Offset = Offset() + someStringOffset someString: Offset = Offset(), + abcsVectorOffset abcs: Offset = Offset(), + boolsVectorOffset bools: Offset = Offset() ) -> Offset { let __start = MoreDefaults.startMoreDefaults(&fbb) MoreDefaults.addVectorOf(ints: ints, &fbb) MoreDefaults.addVectorOf(floats: floats, &fbb) MoreDefaults.add(emptyString: emptyString, &fbb) MoreDefaults.add(someString: someString, &fbb) + MoreDefaults.addVectorOf(abcs: abcs, &fbb) + MoreDefaults.addVectorOf(bools: bools, &fbb) return MoreDefaults.endMoreDefaults(&fbb, start: __start) } @@ -81,11 +107,15 @@ public struct MoreDefaults: FlatBufferObject, ObjectAPIPacker { __someString = Offset() } + let __abcs = builder.createVector(obj.abcs) + let __bools = builder.createVector(obj.bools) let __root = MoreDefaults.startMoreDefaults(&builder) MoreDefaults.addVectorOf(ints: __ints, &builder) MoreDefaults.addVectorOf(floats: __floats, &builder) MoreDefaults.add(emptyString: __emptyString, &builder) MoreDefaults.add(someString: __someString, &builder) + MoreDefaults.addVectorOf(abcs: __abcs, &builder) + MoreDefaults.addVectorOf(bools: __bools, &builder) return MoreDefaults.endMoreDefaults(&builder, start: __root) } } @@ -96,6 +126,8 @@ public class MoreDefaultsT: NativeObject { public var floats: [Float32] public var emptyString: String? public var someString: String? + public var abcs: [ABC] + public var bools: [Bool] public init(_ _t: inout MoreDefaults) { ints = [] @@ -108,6 +140,14 @@ public class MoreDefaultsT: NativeObject { } emptyString = _t.emptyString someString = _t.someString + abcs = [] + for index in 0..<_t.abcsCount { + abcs.append(_t.abcs(at: index)!) + } + bools = [] + for index in 0..<_t.boolsCount { + bools.append(_t.bools(at: index)) + } } public init() { @@ -115,6 +155,8 @@ public class MoreDefaultsT: NativeObject { floats = [] emptyString = "" someString = "some" + abcs = [] + bools = [] } public func serialize() -> ByteBuffer { return serialize(type: MoreDefaults.self) } diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/optional_scalars_generated.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/optional_scalars_generated.swift index 697eddefe..cda8e2bdc 100644 --- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/optional_scalars_generated.swift +++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/optional_scalars_generated.swift @@ -4,7 +4,7 @@ import FlatBuffers -public enum optional_scalars_OptionalByte: Int8, Enum { +public enum optional_scalars_OptionalByte: Int8, Enum { public typealias T = Int8 public static var byteSize: Int { return MemoryLayout.size } public var value: Int8 { return self.rawValue } diff --git a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/union_vector_generated.swift b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/union_vector_generated.swift index b1c937676..69d1746f1 100644 --- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/union_vector_generated.swift +++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/union_vector_generated.swift @@ -4,7 +4,7 @@ import FlatBuffers -public enum Character: UInt8, Enum { +public enum Character: UInt8, Enum { public typealias T = UInt8 public static var byteSize: Int { return MemoryLayout.size } public var value: UInt8 { return self.rawValue } diff --git a/tests/more_defaults.fbs b/tests/more_defaults.fbs index 913f2bda1..da4976a4f 100644 --- a/tests/more_defaults.fbs +++ b/tests/more_defaults.fbs @@ -1,7 +1,12 @@ +enum ABC: int { A, B, C } + + table MoreDefaults { ints: [int] = []; floats: [float] = [ ]; empty_string: string = ""; some_string: string = "some"; + abcs: [ABC] = []; + bools: [bool] = []; } diff --git a/tests/more_defaults_generated.rs b/tests/more_defaults_generated.rs index 800677e4a..afb74bd42 100644 --- a/tests/more_defaults_generated.rs +++ b/tests/more_defaults_generated.rs @@ -8,6 +8,94 @@ use std::cmp::Ordering; extern crate flatbuffers; use self::flatbuffers::EndianScalar; +#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] +pub const ENUM_MIN_ABC: i32 = 0; +#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] +pub const ENUM_MAX_ABC: i32 = 2; +#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] +#[allow(non_camel_case_types)] +pub const ENUM_VALUES_ABC: [ABC; 3] = [ + ABC::A, + ABC::B, + ABC::C, +]; + +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +pub struct ABC(pub i32); +#[allow(non_upper_case_globals)] +impl ABC { + pub const A: Self = Self(0); + pub const B: Self = Self(1); + pub const C: Self = Self(2); + + pub const ENUM_MIN: i32 = 0; + pub const ENUM_MAX: i32 = 2; + pub const ENUM_VALUES: &'static [Self] = &[ + Self::A, + Self::B, + Self::C, + ]; + /// Returns the variant's name or "" if unknown. + pub fn variant_name(self) -> Option<&'static str> { + match self { + Self::A => Some("A"), + Self::B => Some("B"), + Self::C => Some("C"), + _ => None, + } + } +} +impl std::fmt::Debug for ABC { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + if let Some(name) = self.variant_name() { + f.write_str(name) + } else { + f.write_fmt(format_args!("", self.0)) + } + } +} +impl<'a> flatbuffers::Follow<'a> for ABC { + type Inner = Self; + #[inline] + fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + let b = flatbuffers::read_scalar_at::(buf, loc); + Self(b) + } +} + +impl flatbuffers::Push for ABC { + type Output = ABC; + #[inline] + fn push(&self, dst: &mut [u8], _rest: &[u8]) { + flatbuffers::emplace_scalar::(dst, self.0); + } +} + +impl flatbuffers::EndianScalar for ABC { + #[inline] + fn to_little_endian(self) -> Self { + let b = i32::to_le(self.0); + Self(b) + } + #[inline] + fn from_little_endian(self) -> Self { + let b = i32::from_le(self.0); + Self(b) + } +} + +impl<'a> flatbuffers::Verifiable for ABC { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + i32::run_verifier(v, pos) + } +} + +impl flatbuffers::SimpleToVerifyInSlice for ABC {} pub enum MoreDefaultsOffset {} #[derive(Copy, Clone, PartialEq)] @@ -33,6 +121,8 @@ impl<'a> MoreDefaults<'a> { _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, args: &'args MoreDefaultsArgs<'args>) -> flatbuffers::WIPOffset> { let mut builder = MoreDefaultsBuilder::new(_fbb); + 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.some_string { builder.add_some_string(x); } if let Some(x) = args.empty_string { builder.add_empty_string(x); } if let Some(x) = args.floats { builder.add_floats(x); } @@ -57,17 +147,29 @@ impl<'a> MoreDefaults<'a> { let x = self.some_string(); x.to_string() }; + let abcs = { + let x = self.abcs(); + x.into_iter().collect() + }; + let bools = { + let x = self.bools(); + x.to_vec() + }; MoreDefaultsT { ints, floats, empty_string, some_string, + abcs, + 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] pub fn ints(&self) -> flatbuffers::Vector<'a, i32> { @@ -85,6 +187,14 @@ impl<'a> MoreDefaults<'a> { pub fn some_string(&self) -> &'a str { self._tab.get::>(MoreDefaults::VT_SOME_STRING, Some(&"some")).unwrap() } + #[inline] + pub fn abcs(&self) -> flatbuffers::Vector<'a, ABC> { + self._tab.get::>>(MoreDefaults::VT_ABCS, Some(Default::default())).unwrap() + } + #[inline] + pub fn bools(&self) -> &'a [bool] { + self._tab.get::>>(MoreDefaults::VT_BOOLS, Some(Default::default())).map(|v| v.safe_slice()).unwrap() + } } impl flatbuffers::Verifiable for MoreDefaults<'_> { @@ -98,6 +208,8 @@ impl flatbuffers::Verifiable for MoreDefaults<'_> { .visit_field::>>(&"floats", Self::VT_FLOATS, false)? .visit_field::>(&"empty_string", Self::VT_EMPTY_STRING, false)? .visit_field::>(&"some_string", Self::VT_SOME_STRING, false)? + .visit_field::>>(&"abcs", Self::VT_ABCS, false)? + .visit_field::>>(&"bools", Self::VT_BOOLS, false)? .finish(); Ok(()) } @@ -107,6 +219,8 @@ pub struct MoreDefaultsArgs<'a> { pub floats: Option>>, pub empty_string: Option>, pub some_string: Option>, + pub abcs: Option>>, + pub bools: Option>>, } impl<'a> Default for MoreDefaultsArgs<'a> { #[inline] @@ -116,6 +230,8 @@ impl<'a> Default for MoreDefaultsArgs<'a> { floats: None, empty_string: None, some_string: None, + abcs: None, + bools: None, } } } @@ -141,6 +257,14 @@ impl<'a: 'b, 'b> MoreDefaultsBuilder<'a, 'b> { self.fbb_.push_slot_always::>(MoreDefaults::VT_SOME_STRING, some_string); } #[inline] + pub fn add_abcs(&mut self, abcs: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(MoreDefaults::VT_ABCS, abcs); + } + #[inline] + pub fn add_bools(&mut self, bools: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>(MoreDefaults::VT_BOOLS, bools); + } + #[inline] pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MoreDefaultsBuilder<'a, 'b> { let start = _fbb.start_table(); MoreDefaultsBuilder { @@ -162,6 +286,8 @@ impl std::fmt::Debug for MoreDefaults<'_> { ds.field("floats", &self.floats()); ds.field("empty_string", &self.empty_string()); ds.field("some_string", &self.some_string()); + ds.field("abcs", &self.abcs()); + ds.field("bools", &self.bools()); ds.finish() } } @@ -172,6 +298,8 @@ pub struct MoreDefaultsT { pub floats: Vec, pub empty_string: String, pub some_string: String, + pub abcs: Vec, + pub bools: Vec, } impl Default for MoreDefaultsT { fn default() -> Self { @@ -180,6 +308,8 @@ impl Default for MoreDefaultsT { floats: Default::default(), empty_string: "".to_string(), some_string: "some".to_string(), + abcs: Default::default(), + bools: Default::default(), } } } @@ -204,11 +334,21 @@ impl MoreDefaultsT { let x = &self.some_string; _fbb.create_string(x) }); + let abcs = Some({ + let x = &self.abcs; + _fbb.create_vector(x) + }); + let bools = Some({ + let x = &self.bools; + _fbb.create_vector(x) + }); MoreDefaults::create(_fbb, &MoreDefaultsArgs{ ints, floats, empty_string, some_string, + abcs, + bools, }) } } diff --git a/tests/rust_usage_test/tests/more_defaults_test.rs b/tests/rust_usage_test/tests/more_defaults_test.rs index 5127bb964..c1ed81f6f 100644 --- a/tests/rust_usage_test/tests/more_defaults_test.rs +++ b/tests/rust_usage_test/tests/more_defaults_test.rs @@ -12,6 +12,8 @@ fn object_defaults() { floats: Vec::new(), empty_string: "".to_string(), some_string: "some".to_string(), + abcs: Vec::new(), + bools: Vec::new(), }, ) } @@ -21,6 +23,8 @@ fn nonpresent_values() { let m = flatbuffers::root::(&[0; 4]).unwrap(); assert_eq!(m.ints().len(), 0); assert_eq!(m.floats().len(), 0); + assert_eq!(m.abcs().len(), 0); + assert_eq!(m.bools().len(), 0); assert_eq!(m.empty_string(), ""); assert_eq!(m.some_string(), "some"); } diff --git a/tests/test.cpp b/tests/test.cpp index 33bc504da..c649faf59 100644 --- a/tests/test.cpp +++ b/tests/test.cpp @@ -3672,6 +3672,7 @@ void StringVectorDefaultsTest() { schemas.push_back("table Monster { mana: [int] = []; }"); schemas.push_back("table Monster { mana: [uint] = [ ]; }"); schemas.push_back("table Monster { mana: [byte] = [\t\t\n]; }"); + schemas.push_back("enum E:int{}table Monster{mana:[E]=[];}"); for (auto s = schemas.begin(); s < schemas.end(); s++) { flatbuffers::Parser parser; TEST_ASSERT(parser.Parse(s->c_str()));