Dart object API (#6682)

* dart test scripts - generate with `--gen-object-api`

* Dart object API, pack and unpack methods (WIP)

* Dart flatc - extract Builder code to separate functions to reuse it in Pack()

* Dart flatc - use builder field-building implementation in pack()

* Dart flatc - add pack() as an intance method of the "T" class

* Dart object API - make inner fields unpacked as well

* Dart object API - use pack() when collecting field offsets

* Dart object API - use packOnce() for fields that are structs or vectors of structs

* Dart object API - remove obsolete union support TODO

* Dart object API - minor review changes, test and fixes

* Dart object API - revert packOnce() - not supported by other object API implementations

* Dart object API - update docs

* update dart generated code in tests/ to fix CI failure on ./scripts/check-generated-code.sh

* Dart flatc - fix compilation for old MSVC and c++0x

tests/namespace_test/namespace_test1_namespace_a.namespace_b_generated.dart

@@ -104,6 +104,34 @@ class TableInNestedNS {
   String toString() {
     return 'TableInNestedNS{foo: $foo}';
   }
+
+  TableInNestedNST unpack() => TableInNestedNST(
+      foo: foo);
+
+  static int pack(fb.Builder fbBuilder, TableInNestedNST object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class TableInNestedNST {
+  int foo;
+
+  TableInNestedNST({
+      this.foo});
+
+  int pack(fb.Builder fbBuilder) {
+    assert(fbBuilder != null);
+
+    fbBuilder.startTable();
+    fbBuilder.addInt32(0, foo);
+    return fbBuilder.endTable();
+  }
+
+  @override
+  String toString() {
+    return 'TableInNestedNST{foo: $foo}';
+  }
 }
 
 class _TableInNestedNSReader extends fb.TableReader<TableInNestedNS> {
@@ -177,6 +205,37 @@ class StructInNestedNS {
   String toString() {
     return 'StructInNestedNS{a: $a, b: $b}';
   }
+
+  StructInNestedNST unpack() => StructInNestedNST(
+      a: a,
+      b: b);
+
+  static int pack(fb.Builder fbBuilder, StructInNestedNST object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class StructInNestedNST {
+  int a;
+  int b;
+
+  StructInNestedNST({
+      this.a,
+      this.b});
+
+  int pack(fb.Builder fbBuilder) {
+    assert(fbBuilder != null);
+
+    fbBuilder.putInt32(b);
+    fbBuilder.putInt32(a);
+    return fbBuilder.offset;
+  }
+
+  @override
+  String toString() {
+    return 'StructInNestedNST{a: $a, b: $b}';
+  }
 }
 
 class _StructInNestedNSReader extends fb.StructReader<StructInNestedNS> {

tests/namespace_test/namespace_test2_namespace_a_generated.dart

@@ -35,6 +35,58 @@ class TableInFirstNS {
   String toString() {
     return 'TableInFirstNS{fooTable: $fooTable, fooEnum: $fooEnum, fooUnionType: $fooUnionType, fooUnion: $fooUnion, fooStruct: $fooStruct}';
   }
+
+  TableInFirstNST unpack() => TableInFirstNST(
+      fooTable: fooTable?.unpack(),
+      fooEnum: fooEnum,
+      fooUnionType: fooUnionType,
+      fooUnion: fooUnion,
+      fooStruct: fooStruct?.unpack());
+
+  static int pack(fb.Builder fbBuilder, TableInFirstNST object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class TableInFirstNST {
+  namespace_a_namespace_b.TableInNestedNST fooTable;
+  EnumInNestedNS fooEnum;
+  UnionInNestedNSTypeId fooUnionType;
+  dynamic fooUnion;
+  namespace_a_namespace_b.StructInNestedNST fooStruct;
+
+  TableInFirstNST({
+      this.fooTable,
+      this.fooEnum,
+      this.fooUnionType,
+      this.fooUnion,
+      this.fooStruct});
+
+  int pack(fb.Builder fbBuilder) {
+    assert(fbBuilder != null);
+    final int fooTableOffset = fooTable?.pack(fbBuilder);
+    final int fooUnionOffset = fooUnion?.pack(fbBuilder);
+
+    fbBuilder.startTable();
+    if (fooTableOffset != null) {
+      fbBuilder.addOffset(0, fooTableOffset);
+    }
+    fbBuilder.addInt8(1, fooEnum?.value);
+    fbBuilder.addUint8(2, fooUnionType?.value);
+    if (fooUnionOffset != null) {
+      fbBuilder.addOffset(3, fooUnionOffset);
+    }
+    if (fooStruct != null) {
+      fbBuilder.addStruct(4, fooStruct.pack(fbBuilder));
+    }
+    return fbBuilder.endTable();
+  }
+
+  @override
+  String toString() {
+    return 'TableInFirstNST{fooTable: $fooTable, fooEnum: $fooEnum, fooUnionType: $fooUnionType, fooUnion: $fooUnion, fooStruct: $fooStruct}';
+  }
 }
 
 class _TableInFirstNSReader extends fb.TableReader<TableInFirstNS> {
@@ -151,6 +203,37 @@ class SecondTableInA {
   String toString() {
     return 'SecondTableInA{referToC: $referToC}';
   }
+
+  SecondTableInAT unpack() => SecondTableInAT(
+      referToC: referToC?.unpack());
+
+  static int pack(fb.Builder fbBuilder, SecondTableInAT object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class SecondTableInAT {
+  namespace_c.TableInCT referToC;
+
+  SecondTableInAT({
+      this.referToC});
+
+  int pack(fb.Builder fbBuilder) {
+    assert(fbBuilder != null);
+    final int referToCOffset = referToC?.pack(fbBuilder);
+
+    fbBuilder.startTable();
+    if (referToCOffset != null) {
+      fbBuilder.addOffset(0, referToCOffset);
+    }
+    return fbBuilder.endTable();
+  }
+
+  @override
+  String toString() {
+    return 'SecondTableInAT{referToC: $referToC}';
+  }
 }
 
 class _SecondTableInAReader extends fb.TableReader<SecondTableInA> {

tests/namespace_test/namespace_test2_namespace_c_generated.dart

@@ -27,6 +27,44 @@ class TableInC {
   String toString() {
     return 'TableInC{referToA1: $referToA1, referToA2: $referToA2}';
   }
+
+  TableInCT unpack() => TableInCT(
+      referToA1: referToA1?.unpack(),
+      referToA2: referToA2?.unpack());
+
+  static int pack(fb.Builder fbBuilder, TableInCT object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class TableInCT {
+  namespace_a.TableInFirstNST referToA1;
+  namespace_a.SecondTableInAT referToA2;
+
+  TableInCT({
+      this.referToA1,
+      this.referToA2});
+
+  int pack(fb.Builder fbBuilder) {
+    assert(fbBuilder != null);
+    final int referToA1Offset = referToA1?.pack(fbBuilder);
+    final int referToA2Offset = referToA2?.pack(fbBuilder);
+
+    fbBuilder.startTable();
+    if (referToA1Offset != null) {
+      fbBuilder.addOffset(0, referToA1Offset);
+    }
+    if (referToA2Offset != null) {
+      fbBuilder.addOffset(1, referToA2Offset);
+    }
+    return fbBuilder.endTable();
+  }
+
+  @override
+  String toString() {
+    return 'TableInCT{referToA1: $referToA1, referToA2: $referToA2}';
+  }
 }
 
 class _TableInCReader extends fb.TableReader<TableInC> {