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
25namespace flatbuffers {
26
27namespace dart {
28
29const std::string _kFb = "fb";
30// see https://www.dartlang.org/guides/language/language-tour#keywords
31// yeild*, async*, and sync* shouldn't be problems anyway but keeping them in
32static const char *keywords[] = {
33 "abstract", "deferred", "if", "super", "as", "do",
34 "implements", "switch", "assert", "dynamic", "import", "sync*",
35 "async", "else", "in", "this", "async*", "enum",
36 "is", "throw", "await", "export", "library", "true",
37 "break", "external", "new", "try", "case", "extends",
38 "null", "typedef", "catch", "factory", "operator", "var",
39 "class", "false", "part", "void", "const", "final",
40 "rethrow", "while", "continue", "finally", "return", "with",
41 "covariant", "for", "set", "yield", "default", "get",
42 "static", "yield*"
43};
44
45// Iterate through all definitions we haven't generate code for (enums, structs,
46// and tables) and output them to a single file.
47class DartGenerator : public BaseGenerator {
48 public:
49 typedef std::map<std::string, std::string> namespace_code_map;
50
51 DartGenerator(const Parser &parser, const std::string &path,
52 const std::string &file_name)
53 : BaseGenerator(parser, path, file_name, "", ".", "dart") {}
54 // Iterate through all definitions we haven't generate code for (enums,
55 // structs, and tables) and output them to a single file.
56 bool generate() {
57 std::string code;
58 namespace_code_map namespace_code;
59 GenerateEnums(&namespace_code);
60 GenerateStructs(&namespace_code);
61
62 for (auto kv = namespace_code.begin(); kv != namespace_code.end(); ++kv) {
63 code.clear();
64 code = code + "// " + FlatBuffersGeneratedWarning() + "\n";
65 code = code +
66 "// ignore_for_file: unused_import, unused_field, unused_element, "
67 "unused_local_variable\n\n";
68
69 if (!kv->first.empty()) { code += "library " + kv->first + ";\n\n"; }
70
71 code += "import 'dart:typed_data' show Uint8List;\n";
72 code += "import 'package:flat_buffers/flat_buffers.dart' as " + _kFb +
73 ";\n\n";
74
75 for (auto kv2 = namespace_code.begin(); kv2 != namespace_code.end();
76 ++kv2) {
77 if (kv2->first != kv->first) {
78 code +=
79 "import '" +
80 GeneratedFileName(
81 "./",
82 file_name_ + (!kv2->first.empty() ? "_" + kv2->first : ""),
83 parser_.opts) +
84 "' as " + ImportAliasName(kv2->first) + ";\n";
85 }
86 }
87 code += "\n";
88 code += kv->second;
89
90 if (!SaveFile(
91 GeneratedFileName(
92 path_,
93 file_name_ + (!kv->first.empty() ? "_" + kv->first : ""),
94 parser_.opts)
95 .c_str(),
96 code, false)) {
97 return false;
98 }
99 }
100 return true;
101 }
102
103 private:
104 static std::string ImportAliasName(const std::string &ns) {
105 std::string ret;
106 ret.assign(ns);
107 size_t pos = ret.find('.');
108 while (pos != std::string::npos) {
109 ret.replace(pos, 1, "_");
110 pos = ret.find('.', pos + 1);
111 }
112
113 return ret;
114 }
115
116 static std::string BuildNamespaceName(const Namespace &ns) {
117 if (ns.components.empty()) { return ""; }
118 std::stringstream sstream;
119 std::copy(ns.components.begin(), ns.components.end() - 1,
120 std::ostream_iterator<std::string>(sstream, "."));
121
122 auto ret = sstream.str() + ns.components.back();
123 for (size_t i = 0; i < ret.size(); i++) {
124 auto lower = CharToLower(ret[i]);
125 if (lower != ret[i]) {
126 ret[i] = lower;
127 if (i != 0 && ret[i - 1] != '.') {
128 ret.insert(i, "_");
129 i++;
130 }
131 }
132 }
133 // std::transform(ret.begin(), ret.end(), ret.begin(), CharToLower);
134 return ret;
135 }
136
137 void GenIncludeDependencies(std::string *code,
138 const std::string &the_namespace) {
139 for (auto it = parser_.included_files_.begin();
140 it != parser_.included_files_.end(); ++it) {
141 if (it->second.empty()) continue;
142
143 auto noext = flatbuffers::StripExtension(it->second);
144 auto basename = flatbuffers::StripPath(noext);
145
146 *code +=
147 "import '" +
148 GeneratedFileName(
149 "", basename + (the_namespace == "" ? "" : "_" + the_namespace),
150 parser_.opts) +
151 "';\n";
152 }
153 }
154
155 static std::string EscapeKeyword(const std::string &name) {
156 for (size_t i = 0; i < sizeof(keywords) / sizeof(keywords[0]); i++) {
157 if (name == keywords[i]) { return MakeCamel(name + "_", false); }
158 }
159
160 return MakeCamel(name, false);
161 }
162
163 void GenerateEnums(namespace_code_map *namespace_code) {
164 for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
165 ++it) {
166 auto &enum_def = **it;
167 GenEnum(enum_def, namespace_code); // enum_code_ptr);
168 }
169 }
170
171 void GenerateStructs(namespace_code_map *namespace_code) {
172 for (auto it = parser_.structs_.vec.begin();
173 it != parser_.structs_.vec.end(); ++it) {
174 auto &struct_def = **it;
175 GenStruct(struct_def, namespace_code);
176 }
177 }
178
179 // Generate a documentation comment, if available.
180 static void GenDocComment(const std::vector<std::string> &dc,
181 std::string *code_ptr,
182 const std::string &extra_lines,
183 const char *indent = nullptr) {
184 if (dc.empty() && extra_lines.empty()) {
185 // Don't output empty comment blocks with 0 lines of comment content.
186 return;
187 }
188
189 auto &code = *code_ptr;
190
191 for (auto it = dc.begin(); it != dc.end(); ++it) {
192 if (indent) code += indent;
193 code += "/// " + *it + "\n";
194 }
195 if (!extra_lines.empty()) {
196 if (!dc.empty()) {
197 if (indent) code += indent;
198 code += "///\n";
199 }
200 if (indent) code += indent;
201 std::string::size_type start = 0;
202 for (;;) {
203 auto end = extra_lines.find('\n', start);
204 if (end != std::string::npos) {
205 code += "/// " + extra_lines.substr(start, end - start) + "\n";
206 start = end + 1;
207 } else {
208 code += "/// " + extra_lines.substr(start) + "\n";
209 break;
210 }
211 }
212 }
213 }
214
215 static void GenDocComment(std::string *code_ptr,
216 const std::string &extra_lines) {
217 GenDocComment(std::vector<std::string>(), code_ptr, extra_lines);
218 }
219
220 // Generate an enum declaration and an enum string lookup table.
221 void GenEnum(EnumDef &enum_def, namespace_code_map *namespace_code) {
222 if (enum_def.generated) return;
223 auto ns = BuildNamespaceName(*enum_def.defined_namespace);
224 std::string code;
225 GenDocComment(enum_def.doc_comment, &code, "");
226
227 auto name = enum_def.is_union ? enum_def.name + "TypeId" : enum_def.name;
228 auto is_bit_flags = enum_def.attributes.Lookup("bit_flags");
229
230 code += "class " + name + " {\n";
231 code += " final int value;\n";
232 code += " const " + name + "._(this.value);\n\n";
233 code += " factory " + name + ".fromValue(int value) {\n";
234 code += " final result = values[value];\n";
235 code += " if (result == null) {\n";
236 code += " throw StateError('Invalid value $value for bit flag enum ";
237 code += name + "');\n";
238 code += " }\n";
239
240 code += " return result;\n";
241 code += " }\n\n";
242
243 code += " static " + name + "? _createOrNull(int? value) => \n";
244 code += " value == null ? null : " + name + ".fromValue(value);\n\n";
245
246 // this is meaningless for bit_flags
247 // however, note that unlike "regular" dart enums this enum can still have
248 // holes.
249 if (!is_bit_flags) {
250 code += " static const int minValue = " +
251 enum_def.ToString(*enum_def.MinValue()) + ";\n";
252 code += " static const int maxValue = " +
253 enum_def.ToString(*enum_def.MaxValue()) + ";\n";
254 }
255
256 code +=
257 " static bool containsValue(int value) =>"
258 " values.containsKey(value);\n\n";
259
260 for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
261 auto &ev = **it;
262
263 if (!ev.doc_comment.empty()) {
264 if (it != enum_def.Vals().begin()) { code += '\n'; }
265 GenDocComment(ev.doc_comment, &code, "", " ");
266 }
267 code += " static const " + name + " " + ev.name + " = " + name + "._(" +
268 enum_def.ToString(ev) + ");\n";
269 }
270
271 code += " static const Map<int, " + name + "> values = {\n";
272 for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
273 auto &ev = **it;
274 if (it != enum_def.Vals().begin()) code += ",\n";
275 code += " " + enum_def.ToString(ev) + ": " + ev.name;
276 }
277 code += "};\n\n";
278
279 code += " static const " + _kFb + ".Reader<" + name + "> reader = _" +
280 name + "Reader();\n\n";
281 code += " @override\n";
282 code += " String toString() {\n";
283 code += " return '" + name + "{value: $value}';\n";
284 code += " }\n";
285 code += "}\n\n";
286
287 GenEnumReader(enum_def, name, &code);
288 (*namespace_code)[ns] += code;
289 }
290
291 void GenEnumReader(EnumDef &enum_def, const std::string &name,
292 std::string *code_ptr) {
293 auto &code = *code_ptr;
294
295 code += "class _" + name + "Reader extends " + _kFb + ".Reader<" + name +
296 "> {\n";
297 code += " const _" + name + "Reader();\n\n";
298 code += " @override\n";
299 code += " int get size => 1;\n\n";
300 code += " @override\n";
301 code +=
302 " " + name + " read(" + _kFb + ".BufferContext bc, int offset) =>\n";
303 code += " " + name + ".fromValue(const " + _kFb + "." +
304 GenType(enum_def.underlying_type) + "Reader().read(bc, offset));\n";
305 code += "}\n\n";
306 }
307
308 static std::string GenType(const Type &type) {
309 switch (type.base_type) {
310 case BASE_TYPE_BOOL: return "Bool";
311 case BASE_TYPE_CHAR: return "Int8";
312 case BASE_TYPE_UTYPE:
313 case BASE_TYPE_UCHAR: return "Uint8";
314 case BASE_TYPE_SHORT: return "Int16";
315 case BASE_TYPE_USHORT: return "Uint16";
316 case BASE_TYPE_INT: return "Int32";
317 case BASE_TYPE_UINT: return "Uint32";
318 case BASE_TYPE_LONG: return "Int64";
319 case BASE_TYPE_ULONG: return "Uint64";
320 case BASE_TYPE_FLOAT: return "Float32";
321 case BASE_TYPE_DOUBLE: return "Float64";
322 case BASE_TYPE_STRING: return "String";
323 case BASE_TYPE_VECTOR: return GenType(type.VectorType());
324 case BASE_TYPE_STRUCT: return type.struct_def->name;
325 case BASE_TYPE_UNION: return type.enum_def->name + "TypeId";
326 default: return "Table";
327 }
328 }
329
330 std::string GenReaderTypeName(const Type &type, Namespace *current_namespace,
331 const FieldDef &def,
332 bool parent_is_vector = false, bool lazy = true,
333 bool constConstruct = true) {
334 std::string prefix = (constConstruct ? "const " : "") + _kFb;
335 if (type.base_type == BASE_TYPE_BOOL) {
336 return prefix + ".BoolReader()";
337 } else if (IsVector(type)) {
338 if (!type.VectorType().enum_def) {
339 if (type.VectorType().base_type == BASE_TYPE_CHAR) {
340 return prefix + ".Int8ListReader(" + (lazy ? ")" : "lazy: false)");
341 }
342 if (type.VectorType().base_type == BASE_TYPE_UCHAR) {
343 return prefix + ".Uint8ListReader(" + (lazy ? ")" : "lazy: false)");
344 }
345 }
346 return prefix + ".ListReader<" +
347 GenDartTypeName(type.VectorType(), current_namespace, def) + ">(" +
348 GenReaderTypeName(type.VectorType(), current_namespace, def, true,
349 true, false) +
350 (lazy ? ")" : ", lazy: false)");
351 } else if (IsString(type)) {
352 return prefix + ".StringReader()";
353 }
354 if (IsScalar(type.base_type)) {
355 if (type.enum_def && parent_is_vector) {
356 return GenDartTypeName(type, current_namespace, def) + ".reader";
357 }
358 return prefix + "." + GenType(type) + "Reader()";
359 } else {
360 return GenDartTypeName(type, current_namespace, def) + ".reader";
361 }
362 }
363
364 std::string GenDartTypeName(const Type &type, Namespace *current_namespace,
365 const FieldDef &def,
366 std::string struct_type_suffix = "") {
367 if (type.enum_def) {
368 if (type.enum_def->is_union && type.base_type != BASE_TYPE_UNION) {
369 return type.enum_def->name + "TypeId";
370 } else if (type.enum_def->is_union) {
371 return "dynamic";
372 } else if (type.base_type != BASE_TYPE_VECTOR) {
373 return type.enum_def->name;
374 }
375 }
376
377 switch (type.base_type) {
378 case BASE_TYPE_BOOL: return "bool";
379 case BASE_TYPE_LONG:
380 case BASE_TYPE_ULONG:
381 case BASE_TYPE_INT:
382 case BASE_TYPE_UINT:
383 case BASE_TYPE_SHORT:
384 case BASE_TYPE_USHORT:
385 case BASE_TYPE_CHAR:
386 case BASE_TYPE_UCHAR: return "int";
387 case BASE_TYPE_FLOAT:
388 case BASE_TYPE_DOUBLE: return "double";
389 case BASE_TYPE_STRING: return "String";
390 case BASE_TYPE_STRUCT:
391 return MaybeWrapNamespace(type.struct_def->name + struct_type_suffix,
392 current_namespace, def);
393 case BASE_TYPE_VECTOR:
394 return "List<" +
395 GenDartTypeName(type.VectorType(), current_namespace, def,
396 struct_type_suffix) +
397 ">";
398 default: assert(0); return "dynamic";
399 }
400 }
401
402 std::string GenDartTypeName(const Type &type, Namespace *current_namespace,
403 const FieldDef &def, bool nullable,
404 std::string struct_type_suffix) {
405 std::string typeName =
406 GenDartTypeName(type, current_namespace, def, struct_type_suffix);
407 if (nullable && typeName != "dynamic") typeName += "?";
408 return typeName;
409 }
410
411 static const std::string MaybeWrapNamespace(const std::string &type_name,
412 Namespace *current_ns,
413 const FieldDef &field) {
414 auto curr_ns_str = BuildNamespaceName(*current_ns);
415 std::string field_ns_str = "";
416 if (field.value.type.struct_def) {
417 field_ns_str +=
418 BuildNamespaceName(*field.value.type.struct_def->defined_namespace);
419 } else if (field.value.type.enum_def) {
420 field_ns_str +=
421 BuildNamespaceName(*field.value.type.enum_def->defined_namespace);
422 }
423
424 if (field_ns_str != "" && field_ns_str != curr_ns_str) {
425 return ImportAliasName(field_ns_str) + "." + type_name;
426 } else {
427 return type_name;
428 }
429 }
430
431 // Generate an accessor struct with constructor for a flatbuffers struct.
432 void GenStruct(const StructDef &struct_def,
433 namespace_code_map *namespace_code) {
434 if (struct_def.generated) return;
435
436 auto object_namespace = BuildNamespaceName(*struct_def.defined_namespace);
437 std::string code;
438
439 const auto &object_name = struct_def.name;
440
441 // Emit constructor
442
443 GenDocComment(struct_def.doc_comment, &code, "");
444
445 auto reader_name = "_" + object_name + "Reader";
446 auto builder_name = object_name + "Builder";
447 auto object_builder_name = object_name + "ObjectBuilder";
448
449 std::string reader_code, builder_code;
450
451 code += "class " + object_name + " {\n";
452
453 code += " " + object_name + "._(this._bc, this._bcOffset);\n";
454 if (!struct_def.fixed) {
455 code += " factory " + object_name + "(List<int> bytes) {\n";
456 code +=
457 " final rootRef = " + _kFb + ".BufferContext.fromBytes(bytes);\n";
458 code += " return reader.read(rootRef, 0);\n";
459 code += " }\n";
460 }
461
462 code += "\n";
463 code += " static const " + _kFb + ".Reader<" + object_name +
464 "> reader = " + reader_name + "();\n\n";
465
466 code += " final " + _kFb + ".BufferContext _bc;\n";
467 code += " final int _bcOffset;\n\n";
468
469 std::vector<std::pair<int, FieldDef *>> non_deprecated_fields;
470 for (auto it = struct_def.fields.vec.begin();
471 it != struct_def.fields.vec.end(); ++it) {
472 auto &field = **it;
473 if (field.deprecated) continue;
474 auto offset = static_cast<int>(it - struct_def.fields.vec.begin());
475 non_deprecated_fields.push_back(std::make_pair(offset, &field));
476 }
477
478 GenImplementationGetters(struct_def, non_deprecated_fields, &code);
479
480 if (parser_.opts.generate_object_based_api) {
481 code +=
482 "\n" + GenStructObjectAPIUnpack(struct_def, non_deprecated_fields);
483
484 code += "\n static int pack(fb.Builder fbBuilder, " + struct_def.name +
485 "T? object) {\n";
486 code += " if (object == null) return 0;\n";
487 code += " return object.pack(fbBuilder);\n";
488 code += " }\n";
489 }
490
491 code += "}\n\n";
492
493 if (parser_.opts.generate_object_based_api) {
494 code += GenStructObjectAPI(struct_def, non_deprecated_fields);
495 }
496
497 GenReader(struct_def, &reader_name, &reader_code);
498 GenBuilder(struct_def, non_deprecated_fields, &builder_name, &builder_code);
499 GenObjectBuilder(struct_def, non_deprecated_fields, &object_builder_name,
500 &builder_code);
501
502 code += reader_code;
503 code += builder_code;
504
505 (*namespace_code)[object_namespace] += code;
506 }
507
508 // Generate an accessor struct with constructor for a flatbuffers struct.
509 std::string GenStructObjectAPI(
510 const StructDef &struct_def,
511 const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields) {
512 std::string code;
513 GenDocComment(struct_def.doc_comment, &code, "");
514
515 std::string class_name = struct_def.name + "T";
516 code += "class " + class_name + " implements " + _kFb + ".Packable {\n";
517
518 std::string constructor_args;
519 for (auto it = non_deprecated_fields.begin();
520 it != non_deprecated_fields.end(); ++it) {
521 const FieldDef &field = *it->second;
522
523 std::string field_name = MakeCamel(field.name, false);
524 std::string defaultValue = getDefaultValue(field.value);
525 std::string type_name =
526 GenDartTypeName(field.value.type, struct_def.defined_namespace, field,
527 defaultValue.empty() && !struct_def.fixed, "T");
528
529 GenDocComment(field.doc_comment, &code, "", " ");
530 code += " " + type_name + " " + field_name + ";\n";
531
532 if (!constructor_args.empty()) constructor_args += ",\n";
533 constructor_args += " ";
534 constructor_args += (struct_def.fixed ? "required " : "");
535 constructor_args += "this." + field_name;
536 if (!struct_def.fixed && !defaultValue.empty()) {
537 if (IsEnum(field.value.type)) {
538 auto &enum_def = *field.value.type.enum_def;
539 for (auto enumIt = enum_def.Vals().begin();
540 enumIt != enum_def.Vals().end(); ++enumIt) {
541 auto &ev = **enumIt;
542 if (enum_def.ToString(ev) == defaultValue) {
543 constructor_args += " = " + enum_def.name + "." + ev.name;
544 break;
545 }
546 }
547 } else {
548 constructor_args += " = " + defaultValue;
549 }
550 }
551 }
552
553 if (!constructor_args.empty()) {
554 code += "\n " + class_name + "({\n" + constructor_args + "});\n\n";
555 }
556
557 code += GenStructObjectAPIPack(struct_def, non_deprecated_fields);
558 code += "\n";
559 code += GenToString(class_name, non_deprecated_fields);
560
561 code += "}\n\n";
562 return code;
563 }
564
565 // Generate function `StructNameT unpack()`
566 std::string GenStructObjectAPIUnpack(
567 const StructDef &struct_def,
568 const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields) {
569 std::string constructor_args;
570 for (auto it = non_deprecated_fields.begin();
571 it != non_deprecated_fields.end(); ++it) {
572 const FieldDef &field = *it->second;
573
574 std::string field_name = MakeCamel(field.name, false);
575 if (!constructor_args.empty()) constructor_args += ",\n";
576 constructor_args += " " + field_name + ": ";
577
578 const Type &type = field.value.type;
579 std::string defaultValue = getDefaultValue(field.value);
580 bool isNullable = defaultValue.empty() && !struct_def.fixed;
581 std::string nullableValueAccessOperator = isNullable ? "?" : "";
582 if (type.base_type == BASE_TYPE_STRUCT) {
583 constructor_args +=
584 field_name + nullableValueAccessOperator + ".unpack()";
585 } else if (type.base_type == BASE_TYPE_VECTOR) {
586 if (type.VectorType().base_type == BASE_TYPE_STRUCT) {
587 constructor_args += field_name + nullableValueAccessOperator +
588 ".map((e) => e.unpack()).toList()";
589 } else {
590 constructor_args +=
591 GenReaderTypeName(field.value.type, struct_def.defined_namespace,
592 field, false, false);
593 constructor_args += ".vTableGet";
594 std::string offset = NumToString(field.value.offset);
595 constructor_args +=
596 isNullable
597 ? "Nullable(_bc, _bcOffset, " + offset + ")"
598 : "(_bc, _bcOffset, " + offset + ", " + defaultValue + ")";
599 }
600 } else {
601 constructor_args += field_name;
602 }
603 }
604
605 std::string class_name = struct_def.name + "T";
606 std::string code = " " + class_name + " unpack() => " + class_name + "(";
607 if (!constructor_args.empty()) code += "\n" + constructor_args;
608 code += ");\n";
609 return code;
610 }
611
612 // Generate function `StructNameT pack()`
613 std::string GenStructObjectAPIPack(
614 const StructDef &struct_def,
615 const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields) {
616 std::string code;
617
618 code += " @override\n";
619 code += " int pack(fb.Builder fbBuilder) {\n";
620 code += GenObjectBuilderImplementation(struct_def, non_deprecated_fields,
621 false, true);
622 code += " }\n";
623 return code;
624 }
625
626 std::string NamespaceAliasFromUnionType(Namespace *root_namespace,
627 const Type &type) {
628 const std::vector<std::string> qualified_name_parts =
629 type.struct_def->defined_namespace->components;
630 if (std::equal(root_namespace->components.begin(),
631 root_namespace->components.end(),
632 qualified_name_parts.begin())) {
633 return type.struct_def->name;
634 }
635
636 std::string ns;
637
638 for (auto it = qualified_name_parts.begin();
639 it != qualified_name_parts.end(); ++it) {
640 auto &part = *it;
641
642 for (size_t i = 0; i < part.length(); i++) {
643 if (i && !isdigit(part[i]) && part[i] == CharToUpper(part[i])) {
644 ns += "_";
645 ns += CharToLower(part[i]);
646 } else {
647 ns += CharToLower(part[i]);
648 }
649 }
650 if (it != qualified_name_parts.end() - 1) { ns += "_"; }
651 }
652
653 return ns + "." + type.struct_def->name;
654 }
655
656 void GenImplementationGetters(
657 const StructDef &struct_def,
658 std::vector<std::pair<int, FieldDef *>> non_deprecated_fields,
659 std::string *code_ptr) {
660 auto &code = *code_ptr;
661
662 for (auto it = non_deprecated_fields.begin();
663 it != non_deprecated_fields.end(); ++it) {
664 auto pair = *it;
665 auto &field = *pair.second;
666
667 std::string field_name = MakeCamel(field.name, false);
668 std::string defaultValue = getDefaultValue(field.value);
669 bool isNullable = defaultValue.empty() && !struct_def.fixed;
670 std::string type_name =
671 GenDartTypeName(field.value.type, struct_def.defined_namespace, field,
672 isNullable, "");
673
674 GenDocComment(field.doc_comment, &code, "", " ");
675
676 code += " " + type_name + " get " + field_name;
677 if (field.value.type.base_type == BASE_TYPE_UNION) {
678 code += " {\n";
679 code += " switch (" + field_name + "Type?.value) {\n";
680 auto &enum_def = *field.value.type.enum_def;
681 for (auto en_it = enum_def.Vals().begin() + 1;
682 en_it != enum_def.Vals().end(); ++en_it) {
683 auto &ev = **en_it;
684
685 auto enum_name = NamespaceAliasFromUnionType(
686 enum_def.defined_namespace, ev.union_type);
687 code += " case " + enum_def.ToString(ev) + ": return " +
688 enum_name + ".reader.vTableGetNullable(_bc, _bcOffset, " +
689 NumToString(field.value.offset) + ");\n";
690 }
691 code += " default: return null;\n";
692 code += " }\n";
693 code += " }\n";
694 } else {
695 code += " => ";
696 if (field.value.type.enum_def &&
697 field.value.type.base_type != BASE_TYPE_VECTOR) {
698 code += GenDartTypeName(field.value.type,
699 struct_def.defined_namespace, field) +
700 (isNullable ? "._createOrNull(" : ".fromValue(");
701 }
702
703 code += GenReaderTypeName(field.value.type,
704 struct_def.defined_namespace, field);
705 if (struct_def.fixed) {
706 code +=
707 ".read(_bc, _bcOffset + " + NumToString(field.value.offset) + ")";
708 } else {
709 code += ".vTableGet";
710 std::string offset = NumToString(field.value.offset);
711 if (isNullable) {
712 code += "Nullable(_bc, _bcOffset, " + offset + ")";
713 } else {
714 code += "(_bc, _bcOffset, " + offset + ", " + defaultValue + ")";
715 }
716 }
717 if (field.value.type.enum_def &&
718 field.value.type.base_type != BASE_TYPE_VECTOR) {
719 code += ")";
720 }
721 code += ";\n";
722 }
723 }
724
725 code += "\n";
726 code += GenToString(struct_def.name, non_deprecated_fields);
727 }
728
729 std::string GenToString(
730 const std::string &object_name,
731 const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields) {
732 std::string code;
733 code += " @override\n";
734 code += " String toString() {\n";
735 code += " return '" + object_name + "{";
736 for (auto it = non_deprecated_fields.begin();
737 it != non_deprecated_fields.end(); ++it) {
738 auto pair = *it;
739 auto &field = *pair.second;
740 code +=
741 MakeCamel(field.name, false) + ": $" + MakeCamel(field.name, false);
742 if (it != non_deprecated_fields.end() - 1) { code += ", "; }
743 }
744 code += "}';\n";
745 code += " }\n";
746 return code;
747 }
748
749 std::string getDefaultValue(const Value &value) const {
750 if (!value.constant.empty() && value.constant != "0") {
751 if (IsBool(value.type.base_type)) {
752 return "true";
753 } else if (value.constant == "nan" || value.constant == "+nan" ||
754 value.constant == "-nan") {
755 return "double.nan";
756 } else if (value.constant == "inf" || value.constant == "+inf") {
757 return "double.infinity";
758 } else if (value.constant == "-inf") {
759 return "double.negativeInfinity";
760 } else {
761 return value.constant;
762 }
763 } else if (IsBool(value.type.base_type)) {
764 return "false";
765 } else if (IsScalar(value.type.base_type) && !IsUnion(value.type)) {
766 return "0";
767 } else {
768 return "";
769 }
770 }
771
772 void GenReader(const StructDef &struct_def, std::string *reader_name_ptr,
773 std::string *code_ptr) {
774 auto &code = *code_ptr;
775 auto &reader_name = *reader_name_ptr;
776 auto &impl_name = struct_def.name;
777
778 code += "class " + reader_name + " extends " + _kFb;
779 if (struct_def.fixed) {
780 code += ".StructReader<";
781 } else {
782 code += ".TableReader<";
783 }
784 code += impl_name + "> {\n";
785 code += " const " + reader_name + "();\n\n";
786
787 if (struct_def.fixed) {
788 code += " @override\n";
789 code += " int get size => " + NumToString(struct_def.bytesize) + ";\n\n";
790 }
791 code += " @override\n";
792 code += " " + impl_name +
793 " createObject(fb.BufferContext bc, int offset) => \n " +
794 impl_name + "._(bc, offset);\n";
795 code += "}\n\n";
796 }
797
798 void GenBuilder(const StructDef &struct_def,
799 std::vector<std::pair<int, FieldDef *>> non_deprecated_fields,
800 std::string *builder_name_ptr, std::string *code_ptr) {
801 if (non_deprecated_fields.size() == 0) { return; }
802 auto &code = *code_ptr;
803 auto &builder_name = *builder_name_ptr;
804
805 code += "class " + builder_name + " {\n";
806 code += " " + builder_name + "(this.fbBuilder);\n\n";
807 code += " final " + _kFb + ".Builder fbBuilder;\n\n";
808
809 if (struct_def.fixed) {
810 StructBuilderBody(struct_def, non_deprecated_fields, code_ptr);
811 } else {
812 TableBuilderBody(struct_def, non_deprecated_fields, code_ptr);
813 }
814
815 code += "}\n\n";
816 }
817
818 void StructBuilderBody(
819 const StructDef &struct_def,
820 std::vector<std::pair<int, FieldDef *>> non_deprecated_fields,
821 std::string *code_ptr) {
822 auto &code = *code_ptr;
823
824 code += " int finish(";
825 for (auto it = non_deprecated_fields.begin();
826 it != non_deprecated_fields.end(); ++it) {
827 auto pair = *it;
828 auto &field = *pair.second;
829
830 if (IsStruct(field.value.type)) {
831 code += "fb.StructBuilder";
832 } else {
833 code += GenDartTypeName(field.value.type, struct_def.defined_namespace,
834 field);
835 }
836 code += " " + field.name;
837 if (it != non_deprecated_fields.end() - 1) { code += ", "; }
838 }
839 code += ") {\n";
840
841 for (auto it = non_deprecated_fields.rbegin();
842 it != non_deprecated_fields.rend(); ++it) {
843 auto pair = *it;
844 auto &field = *pair.second;
845
846 if (field.padding) {
847 code += " fbBuilder.pad(" + NumToString(field.padding) + ");\n";
848 }
849
850 if (IsStruct(field.value.type)) {
851 code += " " + field.name + "();\n";
852 } else {
853 code += " fbBuilder.put" + GenType(field.value.type) + "(";
854 code += field.name;
855 if (field.value.type.enum_def) { code += ".value"; }
856 code += ");\n";
857 }
858 }
859 code += " return fbBuilder.offset;\n";
860 code += " }\n\n";
861 }
862
863 void TableBuilderBody(
864 const StructDef &struct_def,
865 std::vector<std::pair<int, FieldDef *>> non_deprecated_fields,
866 std::string *code_ptr) {
867 auto &code = *code_ptr;
868
869 code += " void begin() {\n";
870 code += " fbBuilder.startTable(" +
871 NumToString(non_deprecated_fields.size()) + ");\n";
872 code += " }\n\n";
873
874 for (auto it = non_deprecated_fields.begin();
875 it != non_deprecated_fields.end(); ++it) {
876 auto pair = *it;
877 auto &field = *pair.second;
878 auto offset = pair.first;
879
880 if (IsScalar(field.value.type.base_type)) {
881 code += " int add" + MakeCamel(field.name) + "(";
882 code += GenDartTypeName(field.value.type, struct_def.defined_namespace,
883 field);
884 code += "? " + MakeCamel(field.name, false) + ") {\n";
885 code += " fbBuilder.add" + GenType(field.value.type) + "(" +
886 NumToString(offset) + ", ";
887 code += MakeCamel(field.name, false);
888 if (field.value.type.enum_def) { code += "?.value"; }
889 code += ");\n";
890 } else if (IsStruct(field.value.type)) {
891 code += " int add" + MakeCamel(field.name) + "(int offset) {\n";
892 code +=
893 " fbBuilder.addStruct(" + NumToString(offset) + ", offset);\n";
894 } else {
895 code += " int add" + MakeCamel(field.name) + "Offset(int? offset) {\n";
896 code +=
897 " fbBuilder.addOffset(" + NumToString(offset) + ", offset);\n";
898 }
899 code += " return fbBuilder.offset;\n";
900 code += " }\n";
901 }
902
903 code += "\n";
904 code += " int finish() {\n";
905 code += " return fbBuilder.endTable();\n";
906 code += " }\n";
907 }
908
909 void GenObjectBuilder(
910 const StructDef &struct_def,
911 std::vector<std::pair<int, FieldDef *>> non_deprecated_fields,
912 std::string *builder_name_ptr, std::string *code_ptr) {
913 auto &code = *code_ptr;
914 auto &builder_name = *builder_name_ptr;
915
916 code += "class " + builder_name + " extends " + _kFb + ".ObjectBuilder {\n";
917 for (auto it = non_deprecated_fields.begin();
918 it != non_deprecated_fields.end(); ++it) {
919 auto pair = *it;
920 auto &field = *pair.second;
921
922 code += " final " +
923 GenDartTypeName(field.value.type, struct_def.defined_namespace,
924 field, !struct_def.fixed, "ObjectBuilder") +
925 " _" + MakeCamel(field.name, false) + ";\n";
926 }
927 code += "\n";
928 code += " " + builder_name + "(";
929
930 if (non_deprecated_fields.size() != 0) {
931 code += "{\n";
932 for (auto it = non_deprecated_fields.begin();
933 it != non_deprecated_fields.end(); ++it) {
934 auto pair = *it;
935 auto &field = *pair.second;
936
937 code += " ";
938 code += (struct_def.fixed ? "required " : "") +
939 GenDartTypeName(field.value.type, struct_def.defined_namespace,
940 field, !struct_def.fixed, "ObjectBuilder") +
941 " " + MakeCamel(field.name, false) + ",\n";
942 }
943 code += " })\n";
944 code += " : ";
945 for (auto it = non_deprecated_fields.begin();
946 it != non_deprecated_fields.end(); ++it) {
947 auto pair = *it;
948 auto &field = *pair.second;
949
950 code += "_" + MakeCamel(field.name, false) + " = " +
951 MakeCamel(field.name, false);
952 if (it == non_deprecated_fields.end() - 1) {
953 code += ";\n\n";
954 } else {
955 code += ",\n ";
956 }
957 }
958 } else {
959 code += ");\n\n";
960 }
961
962 code += " /// Finish building, and store into the [fbBuilder].\n";
963 code += " @override\n";
964 code += " int finish(" + _kFb + ".Builder fbBuilder) {\n";
965 code += GenObjectBuilderImplementation(struct_def, non_deprecated_fields);
966 code += " }\n\n";
967
968 code += " /// Convenience method to serialize to byte list.\n";
969 code += " @override\n";
970 code += " Uint8List toBytes([String? fileIdentifier]) {\n";
971 code += " final fbBuilder = " + _kFb +
972 ".Builder(deduplicateTables: false);\n";
973 code += " fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n";
974 code += " return fbBuilder.buffer;\n";
975 code += " }\n";
976 code += "}\n";
977 }
978
979 std::string GenObjectBuilderImplementation(
980 const StructDef &struct_def,
981 const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields,
982 bool prependUnderscore = true, bool pack = false) {
983 std::string code;
984 for (auto it = non_deprecated_fields.begin();
985 it != non_deprecated_fields.end(); ++it) {
986 const FieldDef &field = *it->second;
987
988 if (IsScalar(field.value.type.base_type) || IsStruct(field.value.type))
989 continue;
990
991 std::string offset_name = MakeCamel(field.name, false) + "Offset";
992 std::string field_name =
993 (prependUnderscore ? "_" : "") + MakeCamel(field.name, false);
994
995 // custom handling for fixed-sized struct in pack()
996 if (pack && IsVector(field.value.type) &&
997 field.value.type.VectorType().base_type == BASE_TYPE_STRUCT &&
998 field.value.type.struct_def->fixed) {
999 code += " int? " + offset_name + ";\n";
1000 code += " if (" + field_name + " != null) {\n";
1001 code +=
1002 " for (var e in " + field_name + "!) { e.pack(fbBuilder); }\n";
1003 code += " " + MakeCamel(field.name, false) +
1004 "Offset = fbBuilder.endStructVector(" + field_name +
1005 "!.length);\n";
1006 code += " }\n";
1007 continue;
1008 }
1009
1010 code += " final int? " + offset_name;
1011 if (IsVector(field.value.type)) {
1012 code += " = " + field_name + " == null ? null\n";
1013 code += " : fbBuilder.writeList";
1014 switch (field.value.type.VectorType().base_type) {
1015 case BASE_TYPE_STRING:
1016 code +=
1017 "(" + field_name + "!.map(fbBuilder.writeString).toList());\n";
1018 break;
1019 case BASE_TYPE_STRUCT:
1020 if (field.value.type.struct_def->fixed) {
1021 code += "OfStructs(" + field_name + "!);\n";
1022 } else {
1023 code += "(" + field_name + "!.map((b) => b." +
1024 (pack ? "pack" : "getOrCreateOffset") +
1025 "(fbBuilder)).toList());\n";
1026 }
1027 break;
1028 default:
1029 code +=
1030 GenType(field.value.type.VectorType()) + "(" + field_name + "!";
1031 if (field.value.type.enum_def) {
1032 code += ".map((f) => f.value).toList()";
1033 }
1034 code += ");\n";
1035 }
1036 } else if (IsString(field.value.type)) {
1037 code += " = " + field_name + " == null ? null\n";
1038 code += " : fbBuilder.writeString(" + field_name + "!);\n";
1039 } else {
1040 code += " = " + field_name + "?." +
1041 (pack ? "pack" : "getOrCreateOffset") + "(fbBuilder);\n";
1042 }
1043 }
1044
1045 if (struct_def.fixed) {
1046 code += StructObjectBuilderBody(non_deprecated_fields, prependUnderscore,
1047 pack);
1048 } else {
1049 code += TableObjectBuilderBody(non_deprecated_fields, prependUnderscore,
1050 pack);
1051 }
1052 return code;
1053 }
1054
1055 std::string StructObjectBuilderBody(
1056 const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields,
1057 bool prependUnderscore = true, bool pack = false) {
1058 std::string code;
1059
1060 for (auto it = non_deprecated_fields.rbegin();
1061 it != non_deprecated_fields.rend(); ++it) {
1062 auto pair = *it;
1063 auto &field = *pair.second;
1064
1065 if (field.padding) {
1066 code += " fbBuilder.pad(" + NumToString(field.padding) + ");\n";
1067 }
1068
1069 if (IsStruct(field.value.type)) {
1070 code += " ";
1071 if (prependUnderscore) { code += "_"; }
1072 code += field.name + (pack ? ".pack" : ".finish") + "(fbBuilder);\n";
1073 } else {
1074 code += " fbBuilder.put" + GenType(field.value.type) + "(";
1075 if (prependUnderscore) { code += "_"; }
1076 code += field.name;
1077 if (field.value.type.enum_def) { code += ".value"; }
1078 code += ");\n";
1079 }
1080 }
1081
1082 code += " return fbBuilder.offset;\n";
1083 return code;
1084 }
1085
1086 std::string TableObjectBuilderBody(
1087 const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields,
1088 bool prependUnderscore = true, bool pack = false) {
1089 std::string code;
1090 code += " fbBuilder.startTable(" +
1091 NumToString(non_deprecated_fields.size()) + ");\n";
1092
1093 for (auto it = non_deprecated_fields.begin();
1094 it != non_deprecated_fields.end(); ++it) {
1095 auto pair = *it;
1096 auto &field = *pair.second;
1097 auto offset = pair.first;
1098
1099 std::string field_name =
1100 (prependUnderscore ? "_" : "") + MakeCamel(field.name, false);
1101
1102 if (IsScalar(field.value.type.base_type)) {
1103 code += " fbBuilder.add" + GenType(field.value.type) + "(" +
1104 NumToString(offset) + ", " + field_name;
1105 if (field.value.type.enum_def) {
1106 bool isNullable = getDefaultValue(field.value).empty();
1107 code += (isNullable || !pack) ? "?.value" : ".value";
1108 }
1109 code += ");\n";
1110 } else if (IsStruct(field.value.type)) {
1111 code += " if (" + field_name + " != null) {\n";
1112 code += " fbBuilder.addStruct(" + NumToString(offset) + ", " +
1113 field_name + (pack ? "!.pack" : "!.finish") + "(fbBuilder));\n";
1114 code += " }\n";
1115 } else {
1116 code += " fbBuilder.addOffset(" + NumToString(offset) + ", " +
1117 MakeCamel(field.name, false) + "Offset);\n";
1118 }
1119 }
1120 code += " return fbBuilder.endTable();\n";
1121 return code;
1122 }
1123};
1124} // namespace dart
1125
1126bool GenerateDart(const Parser &parser, const std::string &path,
1127 const std::string &file_name) {
1128 dart::DartGenerator generator(parser, path, file_name);
1129 return generator.generate();
1130}
1131
1132std::string DartMakeRule(const Parser &parser, const std::string &path,
1133 const std::string &file_name) {
1134 auto filebase =
1135 flatbuffers::StripPath(flatbuffers::StripExtension(file_name));
1136 dart::DartGenerator generator(parser, path, file_name);
1137 auto make_rule =
1138 generator.GeneratedFileName(path, file_name, parser.opts) + ": ";
1139
1140 auto included_files = parser.GetIncludedFilesRecursive(file_name);
1141 for (auto it = included_files.begin(); it != included_files.end(); ++it) {
1142 make_rule += " " + *it;
1143 }
1144 return make_rule;
1145}
1146
1147} // namespace flatbuffers
1148