diff --git a/src/idl_gen_dart.cpp b/src/idl_gen_dart.cpp index ab9425f87..b072d2937 100644 --- a/src/idl_gen_dart.cpp +++ b/src/idl_gen_dart.cpp @@ -449,13 +449,22 @@ class DartGenerator : public BaseGenerator { code += " final " + _kFb + ".BufferContext _bc;\n"; code += " final int _bcOffset;\n\n"; - GenImplementationGetters(struct_def, &code); + std::vector> non_deprecated_fields; + for (auto it = struct_def.fields.vec.begin(); + it != struct_def.fields.vec.end(); ++it) { + auto &field = **it; + if (field.deprecated) continue; + auto offset = it - struct_def.fields.vec.begin(); + non_deprecated_fields.push_back(std::make_pair(offset, &field)); + } + + GenImplementationGetters(struct_def, non_deprecated_fields, &code); code += "}\n\n"; GenReader(struct_def, &reader_name, &reader_code); - GenBuilder(struct_def, &builder_name, &builder_code); - GenObjectBuilder(struct_def, &object_builder_name, &builder_code); + GenBuilder(struct_def, non_deprecated_fields, &builder_name, &builder_code); + GenObjectBuilder(struct_def, non_deprecated_fields, &object_builder_name, &builder_code); code += reader_code; code += builder_code; @@ -492,13 +501,14 @@ class DartGenerator : public BaseGenerator { } void GenImplementationGetters(const StructDef &struct_def, + std::vector> non_deprecated_fields, std::string *code_ptr) { auto &code = *code_ptr; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - auto &field = **it; - if (field.deprecated) continue; + for (auto it = non_deprecated_fields.begin(); + it != non_deprecated_fields.end(); ++it) { + auto pair = *it; + auto &field = *pair.second; std::string field_name = MakeCamel(field.name, false); std::string type_name = GenDartTypeName( @@ -544,6 +554,12 @@ class DartGenerator : public BaseGenerator { if (!field.value.constant.empty() && field.value.constant != "0") { if (IsBool(field.value.type.base_type)) { code += "true"; + } else if (field.value.constant == "nan" || field.value.constant == "+nan" || field.value.constant == "-nan") { + code += "double.nan"; + } else if (field.value.constant == "inf" || field.value.constant == "+inf") { + code += "double.infinity"; + } else if (field.value.constant == "-inf") { + code += "double.negativeInfinity"; } else { code += field.value.constant; } @@ -571,13 +587,13 @@ class DartGenerator : public BaseGenerator { code += " @override\n"; code += " String toString() {\n"; code += " return '" + struct_def.name + "{"; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - auto &field = **it; - if (field.deprecated) continue; + for (auto it = non_deprecated_fields.begin(); + it != non_deprecated_fields.end(); ++it) { + auto pair = *it; + auto &field = *pair.second; code += MakeCamel(field.name, false) + ": $" + MakeCamel(field.name, false); - if (it != struct_def.fields.vec.end() - 1) { code += ", "; } + if (it != non_deprecated_fields.end() - 1) { code += ", "; } } code += "}';\n"; code += " }\n"; @@ -609,9 +625,11 @@ class DartGenerator : public BaseGenerator { code += "}\n\n"; } - void GenBuilder(const StructDef &struct_def, std::string *builder_name_ptr, + void GenBuilder(const StructDef &struct_def, + std::vector> non_deprecated_fields, + std::string *builder_name_ptr, std::string *code_ptr) { - if (struct_def.fields.vec.size() == 0) { return; } + if (non_deprecated_fields.size() == 0) { return; } auto &code = *code_ptr; auto &builder_name = *builder_name_ptr; @@ -622,22 +640,24 @@ class DartGenerator : public BaseGenerator { code += " final " + _kFb + ".Builder fbBuilder;\n\n"; if (struct_def.fixed) { - StructBuilderBody(struct_def, code_ptr); + StructBuilderBody(struct_def, non_deprecated_fields, code_ptr); } else { - TableBuilderBody(struct_def, code_ptr); + TableBuilderBody(struct_def, non_deprecated_fields, code_ptr); } code += "}\n\n"; } - void StructBuilderBody(const StructDef &struct_def, std::string *code_ptr) { + void StructBuilderBody(const StructDef &struct_def, + std::vector> non_deprecated_fields, + std::string *code_ptr) { auto &code = *code_ptr; code += " int finish("; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - auto &field = **it; - if (field.deprecated) continue; + for (auto it = non_deprecated_fields.begin(); + it != non_deprecated_fields.end(); ++it) { + auto pair = *it; + auto &field = *pair.second; if (IsStruct(field.value.type)) { code += "fb.StructBuilder"; @@ -646,15 +666,14 @@ class DartGenerator : public BaseGenerator { field); } code += " " + field.name; - if (it != struct_def.fields.vec.end() - 1) { code += ", "; } + if (it != non_deprecated_fields.end() - 1) { code += ", "; } } code += ") {\n"; - for (auto it = struct_def.fields.vec.rbegin(); - it != struct_def.fields.vec.rend(); ++it) { - auto &field = **it; - - if (field.deprecated) continue; + for (auto it = non_deprecated_fields.rbegin(); + it != non_deprecated_fields.rend(); ++it) { + auto pair = *it; + auto &field = *pair.second; if (field.padding) { code += " fbBuilder.pad(" + NumToString(field.padding) + ");\n"; @@ -673,19 +692,20 @@ class DartGenerator : public BaseGenerator { code += " }\n\n"; } - void TableBuilderBody(const StructDef &struct_def, std::string *code_ptr) { + void TableBuilderBody(const StructDef &struct_def, + std::vector> non_deprecated_fields, + std::string *code_ptr) { auto &code = *code_ptr; code += " void begin() {\n"; code += " fbBuilder.startTable();\n"; code += " }\n\n"; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - auto &field = **it; - if (field.deprecated) continue; - - auto offset = it - struct_def.fields.vec.begin(); + for (auto it = non_deprecated_fields.begin(); + it != non_deprecated_fields.end(); ++it) { + auto pair = *it; + auto &field = *pair.second; + auto offset = pair.first; if (IsScalar(field.value.type.base_type)) { code += " int add" + MakeCamel(field.name) + "("; @@ -717,15 +737,18 @@ class DartGenerator : public BaseGenerator { } void GenObjectBuilder(const StructDef &struct_def, - std::string *builder_name_ptr, std::string *code_ptr) { + std::vector> non_deprecated_fields, + std::string *builder_name_ptr, + std::string *code_ptr) { auto &code = *code_ptr; auto &builder_name = *builder_name_ptr; code += "class " + builder_name + " extends " + _kFb + ".ObjectBuilder {\n"; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - auto &field = **it; - if (field.deprecated) continue; + for (auto it = non_deprecated_fields.begin(); + it != non_deprecated_fields.end(); ++it) { + auto pair = *it; + auto &field = *pair.second; + code += " final " + GenDartTypeName(field.value.type, struct_def.defined_namespace, field, true) + @@ -733,14 +756,14 @@ class DartGenerator : public BaseGenerator { } code += "\n"; code += " " + builder_name + "("; - if (struct_def.fields.vec.size() != 0) { - code += - "{\n"; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - auto &field = **it; - if (field.deprecated) continue; + if (non_deprecated_fields.size() != 0) { + code += "{\n"; + for (auto it = non_deprecated_fields.begin(); + it != non_deprecated_fields.end(); ++it) { + auto pair = *it; + auto &field = *pair.second; + code += " " + GenDartTypeName(field.value.type, struct_def.defined_namespace, field, true) + @@ -748,13 +771,14 @@ class DartGenerator : public BaseGenerator { } code += " })\n"; code += " : "; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - auto &field = **it; - if (field.deprecated) continue; + for (auto it = non_deprecated_fields.begin(); + it != non_deprecated_fields.end(); ++it) { + auto pair = *it; + auto &field = *pair.second; + code += "_" + MakeCamel(field.name, false) + " = " + MakeCamel(field.name, false); - if (it == struct_def.fields.vec.end() - 1) { + if (it == non_deprecated_fields.end() - 1) { code += ";\n\n"; } else { code += ",\n "; @@ -770,10 +794,11 @@ class DartGenerator : public BaseGenerator { code += " " + _kFb + ".Builder fbBuilder) {\n"; code += " assert(fbBuilder != null);\n"; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - auto &field = **it; - if (field.deprecated) continue; + for (auto it = non_deprecated_fields.begin(); + it != non_deprecated_fields.end(); ++it) { + auto pair = *it; + auto &field = *pair.second; + if (IsScalar(field.value.type.base_type) || IsStruct(field.value.type)) continue; @@ -813,9 +838,9 @@ class DartGenerator : public BaseGenerator { code += "\n"; if (struct_def.fixed) { - StructObjectBuilderBody(struct_def, code_ptr); + StructObjectBuilderBody(non_deprecated_fields, code_ptr); } else { - TableObjectBuilderBody(struct_def, code_ptr); + TableObjectBuilderBody(non_deprecated_fields, code_ptr); } code += " }\n\n"; @@ -830,16 +855,15 @@ class DartGenerator : public BaseGenerator { code += "}\n"; } - void StructObjectBuilderBody(const StructDef &struct_def, + void StructObjectBuilderBody(std::vector> non_deprecated_fields, std::string *code_ptr, bool prependUnderscore = true) { auto &code = *code_ptr; - for (auto it = struct_def.fields.vec.rbegin(); - it != struct_def.fields.vec.rend(); ++it) { - auto &field = **it; - - if (field.deprecated) continue; + for (auto it = non_deprecated_fields.rbegin(); + it != non_deprecated_fields.rend(); ++it) { + auto pair = *it; + auto &field = *pair.second; if (field.padding) { code += " fbBuilder.pad(" + NumToString(field.padding) + ");\n"; @@ -861,19 +885,18 @@ class DartGenerator : public BaseGenerator { code += " return fbBuilder.offset;\n"; } - void TableObjectBuilderBody(const StructDef &struct_def, + void TableObjectBuilderBody(std::vector> non_deprecated_fields, std::string *code_ptr, bool prependUnderscore = true) { std::string &code = *code_ptr; code += " fbBuilder.startTable();\n"; - for (auto it = struct_def.fields.vec.begin(); - it != struct_def.fields.vec.end(); ++it) { - auto &field = **it; + for (auto it = non_deprecated_fields.begin(); + it != non_deprecated_fields.end(); ++it) { + auto pair = *it; + auto &field = *pair.second; + auto offset = pair.first; - if (field.deprecated) continue; - - auto offset = it - struct_def.fields.vec.begin(); if (IsScalar(field.value.type.base_type)) { code += " fbBuilder.add" + GenType(field.value.type) + "(" + NumToString(offset) + ", "; diff --git a/tests/MyGame/MonsterExtra.cs b/tests/MyGame/MonsterExtra.cs index d4916197f..fa145b501 100644 --- a/tests/MyGame/MonsterExtra.cs +++ b/tests/MyGame/MonsterExtra.cs @@ -65,7 +65,7 @@ public struct MonsterExtra : IFlatbufferObject float f3 = Single.NegativeInfinity, VectorOffset dvecOffset = default(VectorOffset), VectorOffset fvecOffset = default(VectorOffset)) { - builder.StartTable(10); + builder.StartTable(11); MonsterExtra.AddD3(builder, d3); MonsterExtra.AddD2(builder, d2); MonsterExtra.AddD1(builder, d1); @@ -79,7 +79,7 @@ public struct MonsterExtra : IFlatbufferObject return MonsterExtra.EndMonsterExtra(builder); } - public static void StartMonsterExtra(FlatBufferBuilder builder) { builder.StartTable(10); } + public static void StartMonsterExtra(FlatBufferBuilder builder) { builder.StartTable(11); } public static void AddD0(FlatBufferBuilder builder, double d0) { builder.AddDouble(0, d0, Double.NaN); } public static void AddD1(FlatBufferBuilder builder, double d1) { builder.AddDouble(1, d1, Double.NaN); } public static void AddD2(FlatBufferBuilder builder, double d2) { builder.AddDouble(2, d2, Double.PositiveInfinity); } diff --git a/tests/MyGame/MonsterExtra.java b/tests/MyGame/MonsterExtra.java index 82c75b46e..11e16a875 100644 --- a/tests/MyGame/MonsterExtra.java +++ b/tests/MyGame/MonsterExtra.java @@ -58,7 +58,7 @@ public final class MonsterExtra extends Table { float f3, int dvecOffset, int fvecOffset) { - builder.startTable(10); + builder.startTable(11); MonsterExtra.addD3(builder, d3); MonsterExtra.addD2(builder, d2); MonsterExtra.addD1(builder, d1); @@ -72,7 +72,7 @@ public final class MonsterExtra extends Table { return MonsterExtra.endMonsterExtra(builder); } - public static void startMonsterExtra(FlatBufferBuilder builder) { builder.startTable(10); } + public static void startMonsterExtra(FlatBufferBuilder builder) { builder.startTable(11); } public static void addD0(FlatBufferBuilder builder, double d0) { builder.addDouble(0, d0, Double.NaN); } public static void addD1(FlatBufferBuilder builder, double d1) { builder.addDouble(1, d1, Double.NaN); } public static void addD2(FlatBufferBuilder builder, double d2) { builder.addDouble(2, d2, Double.POSITIVE_INFINITY); } diff --git a/tests/MyGame/MonsterExtra.kt b/tests/MyGame/MonsterExtra.kt index 96ea73118..b6771650d 100644 --- a/tests/MyGame/MonsterExtra.kt +++ b/tests/MyGame/MonsterExtra.kt @@ -184,7 +184,7 @@ class MonsterExtra : Table() { } fun MonsterExtraBufferHasIdentifier(_bb: ByteBuffer) : Boolean = __has_identifier(_bb, "MONE") fun createMonsterExtra(builder: FlatBufferBuilder, d0: Double, d1: Double, d2: Double, d3: Double, f0: Float, f1: Float, f2: Float, f3: Float, dvecOffset: Int, fvecOffset: Int) : Int { - builder.startTable(10) + builder.startTable(11) addD3(builder, d3) addD2(builder, d2) addD1(builder, d1) @@ -197,7 +197,7 @@ class MonsterExtra : Table() { addF0(builder, f0) return endMonsterExtra(builder) } - fun startMonsterExtra(builder: FlatBufferBuilder) = builder.startTable(10) + fun startMonsterExtra(builder: FlatBufferBuilder) = builder.startTable(11) fun addD0(builder: FlatBufferBuilder, d0: Double) = builder.addDouble(0, d0, Double.NaN) fun addD1(builder: FlatBufferBuilder, d1: Double) = builder.addDouble(1, d1, Double.NaN) fun addD2(builder: FlatBufferBuilder, d2: Double) = builder.addDouble(2, d2, Double.POSITIVE_INFINITY) diff --git a/tests/MyGame/MonsterExtra.py b/tests/MyGame/MonsterExtra.py index 65d8d1eb5..eafea7cf0 100644 --- a/tests/MyGame/MonsterExtra.py +++ b/tests/MyGame/MonsterExtra.py @@ -134,7 +134,7 @@ class MonsterExtra(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) return o == 0 -def MonsterExtraStart(builder): builder.StartObject(10) +def MonsterExtraStart(builder): builder.StartObject(11) def MonsterExtraAddD0(builder, d0): builder.PrependFloat64Slot(0, d0, float('nan')) def MonsterExtraAddD1(builder, d1): builder.PrependFloat64Slot(1, d1, float('nan')) def MonsterExtraAddD2(builder, d2): builder.PrependFloat64Slot(2, d2, float('inf')) diff --git a/tests/generate_code.sh b/tests/generate_code.sh index a86ae2fed..aa6e602dd 100755 --- a/tests/generate_code.sh +++ b/tests/generate_code.sh @@ -45,6 +45,7 @@ $TEST_NOINCL_FLAGS $TEST_CPP_FLAGS -o namespace_test namespace_test/namespace_te ../flatc --cpp --java --kotlin --csharp --python $TEST_NOINCL_FLAGS $TEST_CPP_FLAGS monster_extra.fbs monsterdata_extra.json ../flatc --cpp --java --csharp --jsonschema $TEST_NOINCL_FLAGS $TEST_CPP_FLAGS --scoped-enums arrays_test.fbs ../flatc --python $TEST_BASE_FLAGS arrays_test.fbs +../flatc --dart monster_extra.fbs # Flag c++17 requires Clang6, GCC7, MSVC2017 (_MSC_VER >= 1914) or higher. TEST_CPP17_FLAGS="--cpp --cpp-std c++17 -o ./cpp17/generated_cpp17 $TEST_NOINCL_FLAGS" diff --git a/tests/monster_extra.fbs b/tests/monster_extra.fbs index d0fc7feb4..7cadf457a 100644 --- a/tests/monster_extra.fbs +++ b/tests/monster_extra.fbs @@ -13,6 +13,7 @@ table MonsterExtra { f3:float = -inf; dvec : [double]; fvec : [float]; + deprec:int (deprecated); } root_type MonsterExtra; diff --git a/tests/monster_extra_generated.h b/tests/monster_extra_generated.h index 386fb5633..1db81da90 100644 --- a/tests/monster_extra_generated.h +++ b/tests/monster_extra_generated.h @@ -325,7 +325,8 @@ inline const flatbuffers::TypeTable *MonsterExtraTypeTable() { { flatbuffers::ET_FLOAT, 0, -1 }, { flatbuffers::ET_FLOAT, 0, -1 }, { flatbuffers::ET_DOUBLE, 1, -1 }, - { flatbuffers::ET_FLOAT, 1, -1 } + { flatbuffers::ET_FLOAT, 1, -1 }, + { flatbuffers::ET_INT, 0, -1 } }; static const char * const names[] = { "d0", @@ -337,10 +338,11 @@ inline const flatbuffers::TypeTable *MonsterExtraTypeTable() { "f2", "f3", "dvec", - "fvec" + "fvec", + "deprec" }; static const flatbuffers::TypeTable tt = { - flatbuffers::ST_TABLE, 10, type_codes, nullptr, nullptr, names + flatbuffers::ST_TABLE, 11, type_codes, nullptr, nullptr, names }; return &tt; } diff --git a/tests/monster_extra_my_game_generated.dart b/tests/monster_extra_my_game_generated.dart new file mode 100644 index 000000000..676641de6 --- /dev/null +++ b/tests/monster_extra_my_game_generated.dart @@ -0,0 +1,176 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// ignore_for_file: unused_import, unused_field, unused_local_variable + +library my_game; + +import 'dart:typed_data' show Uint8List; +import 'package:flat_buffers/flat_buffers.dart' as fb; + + +class MonsterExtra { + MonsterExtra._(this._bc, this._bcOffset); + factory MonsterExtra(List bytes) { + fb.BufferContext rootRef = new fb.BufferContext.fromBytes(bytes); + return reader.read(rootRef, 0); + } + + static const fb.Reader reader = const _MonsterExtraReader(); + + final fb.BufferContext _bc; + final int _bcOffset; + + double get d0 => const fb.Float64Reader().vTableGet(_bc, _bcOffset, 4, double.nan); + double get d1 => const fb.Float64Reader().vTableGet(_bc, _bcOffset, 6, double.nan); + double get d2 => const fb.Float64Reader().vTableGet(_bc, _bcOffset, 8, double.infinity); + double get d3 => const fb.Float64Reader().vTableGet(_bc, _bcOffset, 10, double.negativeInfinity); + double get f0 => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 12, double.nan); + double get f1 => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 14, double.nan); + double get f2 => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 16, double.infinity); + double get f3 => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 18, double.negativeInfinity); + List get dvec => const fb.ListReader(const fb.Float64Reader()).vTableGet(_bc, _bcOffset, 20, null); + List get fvec => const fb.ListReader(const fb.Float32Reader()).vTableGet(_bc, _bcOffset, 22, null); + + @override + String toString() { + return 'MonsterExtra{d0: $d0, d1: $d1, d2: $d2, d3: $d3, f0: $f0, f1: $f1, f2: $f2, f3: $f3, dvec: $dvec, fvec: $fvec}'; + } +} + +class _MonsterExtraReader extends fb.TableReader { + const _MonsterExtraReader(); + + @override + MonsterExtra createObject(fb.BufferContext bc, int offset) => + new MonsterExtra._(bc, offset); +} + +class MonsterExtraBuilder { + MonsterExtraBuilder(this.fbBuilder) { + assert(fbBuilder != null); + } + + final fb.Builder fbBuilder; + + void begin() { + fbBuilder.startTable(); + } + + int addD0(double d0) { + fbBuilder.addFloat64(0, d0); + return fbBuilder.offset; + } + int addD1(double d1) { + fbBuilder.addFloat64(1, d1); + return fbBuilder.offset; + } + int addD2(double d2) { + fbBuilder.addFloat64(2, d2); + return fbBuilder.offset; + } + int addD3(double d3) { + fbBuilder.addFloat64(3, d3); + return fbBuilder.offset; + } + int addF0(double f0) { + fbBuilder.addFloat32(4, f0); + return fbBuilder.offset; + } + int addF1(double f1) { + fbBuilder.addFloat32(5, f1); + return fbBuilder.offset; + } + int addF2(double f2) { + fbBuilder.addFloat32(6, f2); + return fbBuilder.offset; + } + int addF3(double f3) { + fbBuilder.addFloat32(7, f3); + return fbBuilder.offset; + } + int addDvecOffset(int offset) { + fbBuilder.addOffset(8, offset); + return fbBuilder.offset; + } + int addFvecOffset(int offset) { + fbBuilder.addOffset(9, offset); + return fbBuilder.offset; + } + + int finish() { + return fbBuilder.endTable(); + } +} + +class MonsterExtraObjectBuilder extends fb.ObjectBuilder { + final double _d0; + final double _d1; + final double _d2; + final double _d3; + final double _f0; + final double _f1; + final double _f2; + final double _f3; + final List _dvec; + final List _fvec; + + MonsterExtraObjectBuilder({ + double d0, + double d1, + double d2, + double d3, + double f0, + double f1, + double f2, + double f3, + List dvec, + List fvec, + }) + : _d0 = d0, + _d1 = d1, + _d2 = d2, + _d3 = d3, + _f0 = f0, + _f1 = f1, + _f2 = f2, + _f3 = f3, + _dvec = dvec, + _fvec = fvec; + + /// Finish building, and store into the [fbBuilder]. + @override + int finish( + fb.Builder fbBuilder) { + assert(fbBuilder != null); + final int dvecOffset = _dvec?.isNotEmpty == true + ? fbBuilder.writeListFloat64(_dvec) + : null; + final int fvecOffset = _fvec?.isNotEmpty == true + ? fbBuilder.writeListFloat32(_fvec) + : null; + + fbBuilder.startTable(); + fbBuilder.addFloat64(0, _d0); + fbBuilder.addFloat64(1, _d1); + fbBuilder.addFloat64(2, _d2); + fbBuilder.addFloat64(3, _d3); + fbBuilder.addFloat32(4, _f0); + fbBuilder.addFloat32(5, _f1); + fbBuilder.addFloat32(6, _f2); + fbBuilder.addFloat32(7, _f3); + if (dvecOffset != null) { + fbBuilder.addOffset(8, dvecOffset); + } + if (fvecOffset != null) { + fbBuilder.addOffset(9, fvecOffset); + } + return fbBuilder.endTable(); + } + + /// Convenience method to serialize to byte list. + @override + Uint8List toBytes([String fileIdentifier]) { + fb.Builder fbBuilder = new fb.Builder(); + int offset = finish(fbBuilder); + return fbBuilder.finish(offset, fileIdentifier); + } +}