src/idl_gen_dart.cpp

   1 /*
   2  * Copyright 2018 Dan Field
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 // independent from idl_parser, since this code is not needed for most clients
  18 #include <cassert>
  19
  20 #include "flatbuffers/code_generators.h"
  21 #include "flatbuffers/flatbuffers.h"
  22 #include "flatbuffers/idl.h"
  23 #include "flatbuffers/util.h"
  24
  25 namespace flatbuffers {
  26
  27 static std::string GeneratedFileName(const std::string &path,
  28                                      const std::string &file_name) {
  29   return path + file_name + "_generated.dart";
  30 }
  31
  32 namespace dart {
  33
  34 const std::string _kFb = "fb";
  35 // see https://www.dartlang.org/guides/language/language-tour#keywords
  36 // yeild*, async*, and sync* shouldn't be problems anyway but keeping them in
  37 static const char *keywords[] = {
  38   "abstract",   "deferred", "if",       "super",   "as",       "do",
  39   "implements", "switch",   "assert",   "dynamic", "import",   "sync*",
  40   "async",      "else",     "in",       "this",    "async*",   "enum",
  41   "is",         "throw",    "await",    "export",  "library",  "true",
  42   "break",      "external", "new",      "try",     "case",     "extends",
  43   "null",       "typedef",  "catch",    "factory", "operator", "var",
  44   "class",      "false",    "part",     "void",    "const",    "final",
  45   "rethrow",    "while",    "continue", "finally", "return",   "with",
  46   "covariant",  "for",      "set",      "yield",   "default",  "get",
  47   "static",     "yield*"
  48 };
  49
  50 // Iterate through all definitions we haven't generate code for (enums, structs,
  51 // and tables) and output them to a single file.
  52 class DartGenerator : public BaseGenerator {
  53  public:
  54   typedef std::map<std::string, std::string> namespace_code_map;
  55
  56   DartGenerator(const Parser &parser, const std::string &path,
  57                 const std::string &file_name)
  58       : BaseGenerator(parser, path, file_name, "", ".") {}
  59   // Iterate through all definitions we haven't generate code for (enums,
  60   // structs, and tables) and output them to a single file.
  61   bool generate() {
  62     std::string code;
  63     namespace_code_map namespace_code;
  64     GenerateEnums(&namespace_code);
  65     GenerateStructs(&namespace_code);
  66
  67     for (auto kv = namespace_code.begin(); kv != namespace_code.end(); ++kv) {
  68       code.clear();
  69       code = code + "// " + FlatBuffersGeneratedWarning() + "\n";
  70       code = code +
  71              "// ignore_for_file: unused_import, unused_field, "
  72              "unused_local_variable\n\n";
  73
  74       if (!kv->first.empty()) { code += "library " + kv->first + ";\n\n"; }
  75
  76       code += "import 'dart:typed_data' show Uint8List;\n";
  77       code += "import 'package:flat_buffers/flat_buffers.dart' as " + _kFb +
  78               ";\n\n";
  79
  80       if (parser_.opts.include_dependence_headers) {
  81         GenIncludeDependencies(&code, kv->first);
  82       }
  83
  84       for (auto kv2 = namespace_code.begin(); kv2 != namespace_code.end();
  85            ++kv2) {
  86         if (kv2->first != kv->first) {
  87           code += "import '" +
  88                   GeneratedFileName(
  89                       "./", file_name_ +
  90                                 (!kv2->first.empty() ? "_" + kv2->first : "")) +
  91                   "' as " + ImportAliasName(kv2->first) + ";\n";
  92         }
  93       }
  94       code += "\n";
  95       code += kv->second;
  96
  97       if (!SaveFile(GeneratedFileName(
  98                         path_, file_name_ +
  99                                    (!kv->first.empty() ? "_" + kv->first : ""))
 100                         .c_str(),
 101                     code, false)) {
 102         return false;
 103       }
 104     }
 105     return true;
 106   }
 107
 108  private:
 109   static std::string ImportAliasName(const std::string &ns) {
 110     std::string ret;
 111     ret.assign(ns);
 112     size_t pos = ret.find('.');
 113     while (pos != std::string::npos) {
 114       ret.replace(pos, 1, "_");
 115       pos = ret.find('.', pos + 1);
 116     }
 117
 118     return ret;
 119   }
 120
 121   static std::string BuildNamespaceName(const Namespace &ns) {
 122     if (ns.components.empty()) { return ""; }
 123     std::stringstream sstream;
 124     std::copy(ns.components.begin(), ns.components.end() - 1,
 125               std::ostream_iterator<std::string>(sstream, "."));
 126
 127     auto ret = sstream.str() + ns.components.back();
 128     for (size_t i = 0; i < ret.size(); i++) {
 129       auto lower = tolower(ret[i]);
 130       if (lower != ret[i]) {
 131         ret[i] = static_cast<char>(lower);
 132         if (i != 0 && ret[i - 1] != '.') {
 133           ret.insert(i, "_");
 134           i++;
 135         }
 136       }
 137     }
 138     // std::transform(ret.begin(), ret.end(), ret.begin(), ::tolower);
 139     return ret;
 140   }
 141
 142   void GenIncludeDependencies(std::string *code,
 143                               const std::string &the_namespace) {
 144     for (auto it = parser_.included_files_.begin();
 145          it != parser_.included_files_.end(); ++it) {
 146       if (it->second.empty()) continue;
 147
 148       auto noext = flatbuffers::StripExtension(it->second);
 149       auto basename = flatbuffers::StripPath(noext);
 150
 151       *code +=
 152           "import '" +
 153           GeneratedFileName(
 154               "", basename + (the_namespace == "" ? "" : "_" + the_namespace)) +
 155           "';\n";
 156     }
 157   }
 158
 159   static std::string EscapeKeyword(const std::string &name) {
 160     for (size_t i = 0; i < sizeof(keywords) / sizeof(keywords[0]); i++) {
 161       if (name == keywords[i]) { return MakeCamel(name + "_", false); }
 162     }
 163
 164     return MakeCamel(name, false);
 165   }
 166
 167   void GenerateEnums(namespace_code_map *namespace_code) {
 168     for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
 169          ++it) {
 170       auto &enum_def = **it;
 171       GenEnum(enum_def, namespace_code);  // enum_code_ptr);
 172     }
 173   }
 174
 175   void GenerateStructs(namespace_code_map *namespace_code) {
 176     for (auto it = parser_.structs_.vec.begin();
 177          it != parser_.structs_.vec.end(); ++it) {
 178       auto &struct_def = **it;
 179       GenStruct(struct_def, namespace_code);
 180     }
 181   }
 182
 183   // Generate a documentation comment, if available.
 184   static void GenDocComment(const std::vector<std::string> &dc,
 185                             std::string *code_ptr,
 186                             const std::string &extra_lines,
 187                             const char *indent = nullptr) {
 188     if (dc.empty() && extra_lines.empty()) {
 189       // Don't output empty comment blocks with 0 lines of comment content.
 190       return;
 191     }
 192
 193     auto &code = *code_ptr;
 194
 195     for (auto it = dc.begin(); it != dc.end(); ++it) {
 196       if (indent) code += indent;
 197       code += "/// " + *it + "\n";
 198     }
 199     if (!extra_lines.empty()) {
 200       if (!dc.empty()) {
 201         if (indent) code += indent;
 202         code += "///\n";
 203       }
 204       if (indent) code += indent;
 205       std::string::size_type start = 0;
 206       for (;;) {
 207         auto end = extra_lines.find('\n', start);
 208         if (end != std::string::npos) {
 209           code += "/// " + extra_lines.substr(start, end - start) + "\n";
 210           start = end + 1;
 211         } else {
 212           code += "/// " + extra_lines.substr(start) + "\n";
 213           break;
 214         }
 215       }
 216     }
 217   }
 218
 219   static void GenDocComment(std::string *code_ptr,
 220                             const std::string &extra_lines) {
 221     GenDocComment(std::vector<std::string>(), code_ptr, extra_lines);
 222   }
 223
 224   // Generate an enum declaration and an enum string lookup table.
 225   void GenEnum(EnumDef &enum_def, namespace_code_map *namespace_code) {
 226     if (enum_def.generated) return;
 227     auto ns = BuildNamespaceName(*enum_def.defined_namespace);
 228     std::string code;
 229     GenDocComment(enum_def.doc_comment, &code, "");
 230
 231     auto name = enum_def.is_union ? enum_def.name + "TypeId" : enum_def.name;
 232     auto is_bit_flags = enum_def.attributes.Lookup("bit_flags");
 233
 234     code += "class " + name + " {\n";
 235     code += "  final int value;\n";
 236     code += "  const " + name + "._(this.value);\n\n";
 237     code += "  factory " + name + ".fromValue(int value) {\n";
 238     code += "    if (value == null) value = 0;\n";
 239
 240     code += "    if (!values.containsKey(value)) {\n";
 241     code +=
 242         "      throw new StateError('Invalid value $value for bit flag enum ";
 243     code += name + "');\n";
 244     code += "    }\n";
 245
 246     code += "    return values[value];\n";
 247     code += "  }\n\n";
 248
 249     // this is meaningless for bit_flags
 250     // however, note that unlike "regular" dart enums this enum can still have
 251     // holes.
 252     if (!is_bit_flags) {
 253       code += "  static const int minValue = " +
 254               enum_def.ToString(*enum_def.MinValue()) + ";\n";
 255       code += "  static const int maxValue = " +
 256               enum_def.ToString(*enum_def.MaxValue()) + ";\n";
 257     }
 258
 259     code +=
 260         "  static bool containsValue(int value) =>"
 261         " values.containsKey(value);\n\n";
 262
 263     for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
 264       auto &ev = **it;
 265
 266       if (!ev.doc_comment.empty()) {
 267         if (it != enum_def.Vals().begin()) { code += '\n'; }
 268         GenDocComment(ev.doc_comment, &code, "", "  ");
 269       }
 270       code += "  static const " + name + " " + ev.name + " = ";
 271       code += "const " + name + "._(" + enum_def.ToString(ev) + ");\n";
 272     }
 273
 274     code += "  static get values => {";
 275     for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
 276       auto &ev = **it;
 277       code += enum_def.ToString(ev) + ": " + ev.name + ",";
 278     }
 279     code += "};\n\n";
 280
 281     code += "  static const " + _kFb + ".Reader<" + name +
 282             "> reader = const _" + name + "Reader();\n\n";
 283     code += "  @override\n";
 284     code += "  String toString() {\n";
 285     code += "    return '" + name + "{value: $value}';\n";
 286     code += "  }\n";
 287     code += "}\n\n";
 288
 289     GenEnumReader(enum_def, name, &code);
 290     (*namespace_code)[ns] += code;
 291   }
 292
 293   void GenEnumReader(EnumDef &enum_def, const std::string &name,
 294                      std::string *code_ptr) {
 295     auto &code = *code_ptr;
 296
 297     code += "class _" + name + "Reader extends " + _kFb + ".Reader<" + name +
 298             "> {\n";
 299     code += "  const _" + name + "Reader();\n\n";
 300     code += "  @override\n";
 301     code += "  int get size => 1;\n\n";
 302     code += "  @override\n";
 303     code +=
 304         "  " + name + " read(" + _kFb + ".BufferContext bc, int offset) =>\n";
 305     code += "      new " + name + ".fromValue(const " + _kFb + "." +
 306             GenType(enum_def.underlying_type) + "Reader().read(bc, offset));\n";
 307     code += "}\n\n";
 308   }
 309
 310   static std::string GenType(const Type &type) {
 311     switch (type.base_type) {
 312       case BASE_TYPE_BOOL: return "Bool";
 313       case BASE_TYPE_CHAR: return "Int8";
 314       case BASE_TYPE_UTYPE:
 315       case BASE_TYPE_UCHAR: return "Uint8";
 316       case BASE_TYPE_SHORT: return "Int16";
 317       case BASE_TYPE_USHORT: return "Uint16";
 318       case BASE_TYPE_INT: return "Int32";
 319       case BASE_TYPE_UINT: return "Uint32";
 320       case BASE_TYPE_LONG: return "Int64";
 321       case BASE_TYPE_ULONG: return "Uint64";
 322       case BASE_TYPE_FLOAT: return "Float32";
 323       case BASE_TYPE_DOUBLE: return "Float64";
 324       case BASE_TYPE_STRING: return "String";
 325       case BASE_TYPE_VECTOR: return GenType(type.VectorType());
 326       case BASE_TYPE_STRUCT: return type.struct_def->name;
 327       case BASE_TYPE_UNION: return type.enum_def->name + "TypeId";
 328       default: return "Table";
 329     }
 330   }
 331
 332   std::string GenReaderTypeName(const Type &type, Namespace *current_namespace,
 333                                 const FieldDef &def,
 334                                 bool parent_is_vector = false) {
 335     if (type.base_type == BASE_TYPE_BOOL) {
 336       return "const " + _kFb + ".BoolReader()";
 337     } else if (type.base_type == BASE_TYPE_VECTOR) {
 338       return "const " + _kFb + ".ListReader<" +
 339              GenDartTypeName(type.VectorType(), current_namespace, def) + ">(" +
 340              GenReaderTypeName(type.VectorType(), current_namespace, def,
 341                                true) +
 342              ")";
 343     } else if (type.base_type == BASE_TYPE_STRING) {
 344       return "const " + _kFb + ".StringReader()";
 345     }
 346     if (IsScalar(type.base_type)) {
 347       if (type.enum_def && parent_is_vector) {
 348         return GenDartTypeName(type, current_namespace, def) + ".reader";
 349       }
 350       return "const " + _kFb + "." + GenType(type) + "Reader()";
 351     } else {
 352       return GenDartTypeName(type, current_namespace, def) + ".reader";
 353     }
 354   }
 355
 356   std::string GenDartTypeName(const Type &type, Namespace *current_namespace,
 357                               const FieldDef &def, bool addBuilder = false) {
 358     if (type.enum_def) {
 359       if (type.enum_def->is_union && type.base_type != BASE_TYPE_UNION) {
 360         return type.enum_def->name + "TypeId";
 361       } else if (type.enum_def->is_union) {
 362         return "dynamic";
 363       } else if (type.base_type != BASE_TYPE_VECTOR) {
 364         return type.enum_def->name;
 365       }
 366     }
 367
 368     switch (type.base_type) {
 369       case BASE_TYPE_BOOL: return "bool";
 370       case BASE_TYPE_LONG:
 371       case BASE_TYPE_ULONG:
 372       case BASE_TYPE_INT:
 373       case BASE_TYPE_UINT:
 374       case BASE_TYPE_SHORT:
 375       case BASE_TYPE_USHORT:
 376       case BASE_TYPE_CHAR:
 377       case BASE_TYPE_UCHAR: return "int";
 378       case BASE_TYPE_FLOAT:
 379       case BASE_TYPE_DOUBLE: return "double";
 380       case BASE_TYPE_STRING: return "String";
 381       case BASE_TYPE_STRUCT:
 382         return MaybeWrapNamespace(
 383             type.struct_def->name + (addBuilder ? "ObjectBuilder" : ""),
 384             current_namespace, def);
 385       case BASE_TYPE_VECTOR:
 386         return "List<" +
 387                GenDartTypeName(type.VectorType(), current_namespace, def,
 388                                addBuilder) +
 389                ">";
 390       default: assert(0); return "dynamic";
 391     }
 392   }
 393
 394   static const std::string MaybeWrapNamespace(const std::string &type_name,
 395                                               Namespace *current_ns,
 396                                               const FieldDef &field) {
 397     auto curr_ns_str = BuildNamespaceName(*current_ns);
 398     std::string field_ns_str = "";
 399     if (field.value.type.struct_def) {
 400       field_ns_str +=
 401           BuildNamespaceName(*field.value.type.struct_def->defined_namespace);
 402     } else if (field.value.type.enum_def) {
 403       field_ns_str +=
 404           BuildNamespaceName(*field.value.type.enum_def->defined_namespace);
 405     }
 406
 407     if (field_ns_str != "" && field_ns_str != curr_ns_str) {
 408       return ImportAliasName(field_ns_str) + "." + type_name;
 409     } else {
 410       return type_name;
 411     }
 412   }
 413
 414   // Generate an accessor struct with constructor for a flatbuffers struct.
 415   void GenStruct(const StructDef &struct_def,
 416                  namespace_code_map *namespace_code) {
 417     if (struct_def.generated) return;
 418
 419     auto object_namespace = BuildNamespaceName(*struct_def.defined_namespace);
 420     std::string code;
 421
 422     const auto &object_name = struct_def.name;
 423
 424     // Emit constructor
 425
 426     GenDocComment(struct_def.doc_comment, &code, "");
 427
 428     auto reader_name = "_" + object_name + "Reader";
 429     auto builder_name = object_name + "Builder";
 430     auto object_builder_name = object_name + "ObjectBuilder";
 431
 432     std::string reader_code, builder_code;
 433
 434     code += "class " + object_name + " {\n";
 435
 436     code += "  " + object_name + "._(this._bc, this._bcOffset);\n";
 437     if (!struct_def.fixed) {
 438       code += "  factory " + object_name + "(List<int> bytes) {\n";
 439       code += "    " + _kFb + ".BufferContext rootRef = new " + _kFb +
 440               ".BufferContext.fromBytes(bytes);\n";
 441       code += "    return reader.read(rootRef, 0);\n";
 442       code += "  }\n";
 443     }
 444
 445     code += "\n";
 446     code += "  static const " + _kFb + ".Reader<" + object_name +
 447             "> reader = const " + reader_name + "();\n\n";
 448
 449     code += "  final " + _kFb + ".BufferContext _bc;\n";
 450     code += "  final int _bcOffset;\n\n";
 451
 452     GenImplementationGetters(struct_def, &code);
 453
 454     code += "}\n\n";
 455
 456     GenReader(struct_def, &reader_name, &reader_code);
 457     GenBuilder(struct_def, &builder_name, &builder_code);
 458     GenObjectBuilder(struct_def, &object_builder_name, &builder_code);
 459
 460     code += reader_code;
 461     code += builder_code;
 462
 463     (*namespace_code)[object_namespace] += code;
 464   }
 465
 466   std::string NamespaceAliasFromUnionType(const std::string &in) {
 467     if (in.find('_') == std::string::npos) { return in; }
 468
 469     std::stringstream ss(in);
 470     std::string item;
 471     std::vector<std::string> parts;
 472     std::string ns;
 473
 474     while (std::getline(ss, item, '_')) { parts.push_back(item); }
 475
 476     for (auto it = parts.begin(); it != parts.end() - 1; ++it) {
 477       auto &part = *it;
 478
 479       for (size_t i = 0; i < part.length(); i++) {
 480         if (i && !isdigit(part[i]) &&
 481             part[i] == static_cast<char>(toupper(part[i]))) {
 482           ns += "_";
 483           ns += static_cast<char>(tolower(part[i]));
 484         } else {
 485           ns += static_cast<char>(tolower(part[i]));
 486         }
 487       }
 488       if (it != parts.end() - 2) { ns += "_"; }
 489     }
 490
 491     return ns + "." + parts.back();
 492   }
 493
 494   void GenImplementationGetters(const StructDef &struct_def,
 495                                 std::string *code_ptr) {
 496     auto &code = *code_ptr;
 497
 498     for (auto it = struct_def.fields.vec.begin();
 499          it != struct_def.fields.vec.end(); ++it) {
 500       auto &field = **it;
 501       if (field.deprecated) continue;
 502
 503       std::string field_name = MakeCamel(field.name, false);
 504       std::string type_name = GenDartTypeName(
 505           field.value.type, struct_def.defined_namespace, field, false);
 506
 507       GenDocComment(field.doc_comment, &code, "", "  ");
 508
 509       code += "  " + type_name + " get " + field_name;
 510       if (field.value.type.base_type == BASE_TYPE_UNION) {
 511         code += " {\n";
 512         code += "    switch (" + field_name + "Type?.value) {\n";
 513         auto &enum_def = *field.value.type.enum_def;
 514         for (auto en_it = enum_def.Vals().begin() + 1;
 515              en_it != enum_def.Vals().end(); ++en_it) {
 516           auto &ev = **en_it;
 517
 518           auto enum_name = NamespaceAliasFromUnionType(ev.name);
 519           code += "      case " + enum_def.ToString(ev) + ": return " +
 520                   enum_name + ".reader.vTableGet(_bc, _bcOffset, " +
 521                   NumToString(field.value.offset) + ", null);\n";
 522         }
 523         code += "      default: return null;\n";
 524         code += "    }\n";
 525         code += "  }\n";
 526       } else {
 527         code += " => ";
 528         if (field.value.type.enum_def &&
 529             field.value.type.base_type != BASE_TYPE_VECTOR) {
 530           code += "new " +
 531                   GenDartTypeName(field.value.type,
 532                                   struct_def.defined_namespace, field) +
 533                   ".fromValue(";
 534         }
 535
 536         code += GenReaderTypeName(field.value.type,
 537                                   struct_def.defined_namespace, field);
 538         if (struct_def.fixed) {
 539           code +=
 540               ".read(_bc, _bcOffset + " + NumToString(field.value.offset) + ")";
 541         } else {
 542           code += ".vTableGet(_bc, _bcOffset, " +
 543                   NumToString(field.value.offset) + ", ";
 544           if (!field.value.constant.empty() && field.value.constant != "0") {
 545             if (IsBool(field.value.type.base_type)) {
 546               code += "true";
 547             } else {
 548               code += field.value.constant;
 549             }
 550           } else {
 551             if (IsBool(field.value.type.base_type)) {
 552               code += "false";
 553             } else if (IsScalar(field.value.type.base_type)) {
 554               code += "0";
 555             } else {
 556               code += "null";
 557             }
 558           }
 559           code += ")";
 560         }
 561         if (field.value.type.enum_def &&
 562             field.value.type.base_type != BASE_TYPE_VECTOR) {
 563           code += ")";
 564         }
 565         code += ";\n";
 566       }
 567     }
 568
 569     code += "\n";
 570
 571     code += "  @override\n";
 572     code += "  String toString() {\n";
 573     code += "    return '" + struct_def.name + "{";
 574     for (auto it = struct_def.fields.vec.begin();
 575          it != struct_def.fields.vec.end(); ++it) {
 576       auto &field = **it;
 577       if (field.deprecated) continue;
 578       code +=
 579           MakeCamel(field.name, false) + ": $" + MakeCamel(field.name, false);
 580       if (it != struct_def.fields.vec.end() - 1) { code += ", "; }
 581     }
 582     code += "}';\n";
 583     code += "  }\n";
 584   }
 585
 586   void GenReader(const StructDef &struct_def, std::string *reader_name_ptr,
 587                  std::string *code_ptr) {
 588     auto &code = *code_ptr;
 589     auto &reader_name = *reader_name_ptr;
 590     auto &impl_name = struct_def.name;
 591
 592     code += "class " + reader_name + " extends " + _kFb;
 593     if (struct_def.fixed) {
 594       code += ".StructReader<";
 595     } else {
 596       code += ".TableReader<";
 597     }
 598     code += impl_name + "> {\n";
 599     code += "  const " + reader_name + "();\n\n";
 600
 601     if (struct_def.fixed) {
 602       code += "  @override\n";
 603       code += "  int get size => " + NumToString(struct_def.bytesize) + ";\n\n";
 604     }
 605     code += "  @override\n";
 606     code += "  " + impl_name +
 607             " createObject(fb.BufferContext bc, int offset) => \n    new " +
 608             impl_name + "._(bc, offset);\n";
 609     code += "}\n\n";
 610   }
 611
 612   void GenBuilder(const StructDef &struct_def, std::string *builder_name_ptr,
 613                   std::string *code_ptr) {
 614     if (struct_def.fields.vec.size() == 0) { return; }
 615     auto &code = *code_ptr;
 616     auto &builder_name = *builder_name_ptr;
 617
 618     code += "class " + builder_name + " {\n";
 619     code += "  " + builder_name + "(this.fbBuilder) {\n";
 620     code += "    assert(fbBuilder != null);\n";
 621     code += "  }\n\n";
 622     code += "  final " + _kFb + ".Builder fbBuilder;\n\n";
 623
 624     if (struct_def.fixed) {
 625       StructBuilderBody(struct_def, code_ptr);
 626     } else {
 627       TableBuilderBody(struct_def, code_ptr);
 628     }
 629
 630     code += "}\n\n";
 631   }
 632
 633   void StructBuilderBody(const StructDef &struct_def, std::string *code_ptr) {
 634     auto &code = *code_ptr;
 635
 636     code += "  int finish(";
 637     for (auto it = struct_def.fields.vec.begin();
 638          it != struct_def.fields.vec.end(); ++it) {
 639       auto &field = **it;
 640       if (field.deprecated) continue;
 641
 642       if (IsStruct(field.value.type)) {
 643         code += "fb.StructBuilder";
 644       } else {
 645         code += GenDartTypeName(field.value.type, struct_def.defined_namespace,
 646                                 field);
 647       }
 648       code += " " + field.name;
 649       if (it != struct_def.fields.vec.end() - 1) { code += ", "; }
 650     }
 651     code += ") {\n";
 652
 653     for (auto it = struct_def.fields.vec.rbegin();
 654          it != struct_def.fields.vec.rend(); ++it) {
 655       auto &field = **it;
 656
 657       if (field.deprecated) continue;
 658
 659       if (field.padding) {
 660         code += "    fbBuilder.pad(" + NumToString(field.padding) + ");\n";
 661       }
 662
 663       if (IsStruct(field.value.type)) {
 664         code += "    " + field.name + "();\n";
 665       } else {
 666         code += "    fbBuilder.put" + GenType(field.value.type) + "(";
 667         code += field.name;
 668         if (field.value.type.enum_def) { code += "?.value"; }
 669         code += ");\n";
 670       }
 671     }
 672     code += "    return fbBuilder.offset;\n";
 673     code += "  }\n\n";
 674   }
 675
 676   void TableBuilderBody(const StructDef &struct_def, std::string *code_ptr) {
 677     auto &code = *code_ptr;
 678
 679     code += "  void begin() {\n";
 680     code += "    fbBuilder.startTable();\n";
 681     code += "  }\n\n";
 682
 683     for (auto it = struct_def.fields.vec.begin();
 684          it != struct_def.fields.vec.end(); ++it) {
 685       auto &field = **it;
 686       if (field.deprecated) continue;
 687
 688       auto offset = it - struct_def.fields.vec.begin();
 689
 690       if (IsScalar(field.value.type.base_type)) {
 691         code += "  int add" + MakeCamel(field.name) + "(";
 692         code += GenDartTypeName(field.value.type, struct_def.defined_namespace,
 693                                 field);
 694         code += " " + MakeCamel(field.name, false) + ") {\n";
 695         code += "    fbBuilder.add" + GenType(field.value.type) + "(" +
 696                 NumToString(offset) + ", ";
 697         code += MakeCamel(field.name, false);
 698         if (field.value.type.enum_def) { code += "?.value"; }
 699         code += ");\n";
 700       } else if (IsStruct(field.value.type)) {
 701         code += "  int add" + MakeCamel(field.name) + "(int offset) {\n";
 702         code +=
 703             "    fbBuilder.addStruct(" + NumToString(offset) + ", offset);\n";
 704       } else {
 705         code += "  int add" + MakeCamel(field.name) + "Offset(int offset) {\n";
 706         code +=
 707             "    fbBuilder.addOffset(" + NumToString(offset) + ", offset);\n";
 708       }
 709       code += "    return fbBuilder.offset;\n";
 710       code += "  }\n";
 711     }
 712
 713     code += "\n";
 714     code += "  int finish() {\n";
 715     code += "    return fbBuilder.endTable();\n";
 716     code += "  }\n";
 717   }
 718
 719   void GenObjectBuilder(const StructDef &struct_def,
 720                         std::string *builder_name_ptr, std::string *code_ptr) {
 721     auto &code = *code_ptr;
 722     auto &builder_name = *builder_name_ptr;
 723
 724     code += "class " + builder_name + " extends " + _kFb + ".ObjectBuilder {\n";
 725     for (auto it = struct_def.fields.vec.begin();
 726          it != struct_def.fields.vec.end(); ++it) {
 727       auto &field = **it;
 728       if (field.deprecated) continue;
 729       code += "  final " +
 730               GenDartTypeName(field.value.type, struct_def.defined_namespace,
 731                               field, true) +
 732               " _" + MakeCamel(field.name, false) + ";\n";
 733     }
 734     code += "\n";
 735     code += "  " + builder_name + "(";
 736     if (struct_def.fields.vec.size() != 0) {
 737       code +=
 738
 739           "{\n";
 740       for (auto it = struct_def.fields.vec.begin();
 741            it != struct_def.fields.vec.end(); ++it) {
 742         auto &field = **it;
 743         if (field.deprecated) continue;
 744         code += "    " +
 745                 GenDartTypeName(field.value.type, struct_def.defined_namespace,
 746                                 field, true) +
 747                 " " + MakeCamel(field.name, false) + ",\n";
 748       }
 749       code += "  })\n";
 750       code += "      : ";
 751       for (auto it = struct_def.fields.vec.begin();
 752            it != struct_def.fields.vec.end(); ++it) {
 753         auto &field = **it;
 754         if (field.deprecated) continue;
 755         code += "_" + MakeCamel(field.name, false) + " = " +
 756                 MakeCamel(field.name, false);
 757         if (it == struct_def.fields.vec.end() - 1) {
 758           code += ";\n\n";
 759         } else {
 760           code += ",\n        ";
 761         }
 762       }
 763     } else {
 764       code += ");\n\n";
 765     }
 766
 767     code += "  /// Finish building, and store into the [fbBuilder].\n";
 768     code += "  @override\n";
 769     code += "  int finish(\n";
 770     code += "    " + _kFb + ".Builder fbBuilder) {\n";
 771     code += "    assert(fbBuilder != null);\n";
 772
 773     for (auto it = struct_def.fields.vec.begin();
 774          it != struct_def.fields.vec.end(); ++it) {
 775       auto &field = **it;
 776       if (field.deprecated) continue;
 777       if (IsScalar(field.value.type.base_type) || IsStruct(field.value.type))
 778         continue;
 779
 780       code += "    final int " + MakeCamel(field.name, false) + "Offset";
 781       if (field.value.type.base_type == BASE_TYPE_VECTOR) {
 782         code +=
 783             " = _" + MakeCamel(field.name, false) + "?.isNotEmpty == true\n";
 784         code += "        ? fbBuilder.writeList";
 785         switch (field.value.type.VectorType().base_type) {
 786           case BASE_TYPE_STRING:
 787             code += "(_" + MakeCamel(field.name, false) +
 788                     ".map((b) => fbBuilder.writeString(b)).toList())";
 789             break;
 790           case BASE_TYPE_STRUCT:
 791             if (field.value.type.struct_def->fixed) {
 792               code += "OfStructs(_" + MakeCamel(field.name, false) + ")";
 793             } else {
 794               code += "(_" + MakeCamel(field.name, false) +
 795                       ".map((b) => b.getOrCreateOffset(fbBuilder)).toList())";
 796             }
 797             break;
 798           default:
 799             code += GenType(field.value.type.VectorType()) + "(_" +
 800                     MakeCamel(field.name, false);
 801             if (field.value.type.enum_def) { code += ".map((f) => f.value)"; }
 802             code += ")";
 803         }
 804         code += "\n        : null;\n";
 805       } else if (field.value.type.base_type == BASE_TYPE_STRING) {
 806         code += " = fbBuilder.writeString(_" + MakeCamel(field.name, false) +
 807                 ");\n";
 808       } else {
 809         code += " = _" + MakeCamel(field.name, false) +
 810                 "?.getOrCreateOffset(fbBuilder);\n";
 811       }
 812     }
 813
 814     code += "\n";
 815     if (struct_def.fixed) {
 816       StructObjectBuilderBody(struct_def, code_ptr);
 817     } else {
 818       TableObjectBuilderBody(struct_def, code_ptr);
 819     }
 820     code += "  }\n\n";
 821
 822     code += "  /// Convenience method to serialize to byte list.\n";
 823     code += "  @override\n";
 824     code += "  Uint8List toBytes([String fileIdentifier]) {\n";
 825     code += "    " + _kFb + ".Builder fbBuilder = new ";
 826     code += _kFb + ".Builder();\n";
 827     code += "    int offset = finish(fbBuilder);\n";
 828     code += "    return fbBuilder.finish(offset, fileIdentifier);\n";
 829     code += "  }\n";
 830     code += "}\n";
 831   }
 832
 833   void StructObjectBuilderBody(const StructDef &struct_def,
 834                                std::string *code_ptr,
 835                                bool prependUnderscore = true) {
 836     auto &code = *code_ptr;
 837
 838     for (auto it = struct_def.fields.vec.rbegin();
 839          it != struct_def.fields.vec.rend(); ++it) {
 840       auto &field = **it;
 841
 842       if (field.deprecated) continue;
 843
 844       if (field.padding) {
 845         code += "    fbBuilder.pad(" + NumToString(field.padding) + ");\n";
 846       }
 847
 848       if (IsStruct(field.value.type)) {
 849         code += "    ";
 850         if (prependUnderscore) { code += "_"; }
 851         code += field.name + ".finish(fbBuilder);\n";
 852       } else {
 853         code += "    fbBuilder.put" + GenType(field.value.type) + "(";
 854         if (prependUnderscore) { code += "_"; }
 855         code += field.name;
 856         if (field.value.type.enum_def) { code += "?.value"; }
 857         code += ");\n";
 858       }
 859     }
 860
 861     code += "    return fbBuilder.offset;\n";
 862   }
 863
 864   void TableObjectBuilderBody(const StructDef &struct_def,
 865                               std::string *code_ptr,
 866                               bool prependUnderscore = true) {
 867     std::string &code = *code_ptr;
 868     code += "    fbBuilder.startTable();\n";
 869
 870     for (auto it = struct_def.fields.vec.begin();
 871          it != struct_def.fields.vec.end(); ++it) {
 872       auto &field = **it;
 873
 874       if (field.deprecated) continue;
 875
 876       auto offset = it - struct_def.fields.vec.begin();
 877       if (IsScalar(field.value.type.base_type)) {
 878         code += "    fbBuilder.add" + GenType(field.value.type) + "(" +
 879                 NumToString(offset) + ", ";
 880         if (prependUnderscore) { code += "_"; }
 881         code += MakeCamel(field.name, false);
 882         if (field.value.type.enum_def) { code += "?.value"; }
 883         code += ");\n";
 884       } else if (IsStruct(field.value.type)) {
 885         code += "    if (";
 886         if (prependUnderscore) { code += "_"; }
 887         code += MakeCamel(field.name, false) + " != null) {\n";
 888         code += "      fbBuilder.addStruct(" + NumToString(offset) + ", ";
 889         code += "_" + MakeCamel(field.name, false) + ".finish(fbBuilder));\n";
 890         code += "    }\n";
 891       } else {
 892         code +=
 893             "    if (" + MakeCamel(field.name, false) + "Offset != null) {\n";
 894         code += "      fbBuilder.addOffset(" + NumToString(offset) + ", " +
 895                 MakeCamel(field.name, false) + "Offset);\n";
 896         code += "    }\n";
 897       }
 898     }
 899     code += "    return fbBuilder.endTable();\n";
 900   }
 901 };
 902 }  // namespace dart
 903
 904 bool GenerateDart(const Parser &parser, const std::string &path,
 905                   const std::string &file_name) {
 906   dart::DartGenerator generator(parser, path, file_name);
 907   return generator.generate();
 908 }
 909
 910 std::string DartMakeRule(const Parser &parser, const std::string &path,
 911                          const std::string &file_name) {
 912   assert(parser.opts.lang <= IDLOptions::kMAX);
 913
 914   auto filebase =
 915       flatbuffers::StripPath(flatbuffers::StripExtension(file_name));
 916   auto make_rule = GeneratedFileName(path, filebase) + ": ";
 917
 918   auto included_files = parser.GetIncludedFilesRecursive(file_name);
 919   for (auto it = included_files.begin(); it != included_files.end(); ++it) {
 920     make_rule += " " + *it;
 921   }
 922   return make_rule;
 923 }
 924
 925 }  // namespace flatbuffers