2 * Copyright 2014 Google Inc. All rights reserved.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 // independent from idl_parser, since this code is not needed for most clients
20 #include <unordered_set>
22 #include "flatbuffers/code_generators.h"
23 #include "flatbuffers/flatbuffers.h"
24 #include "flatbuffers/idl.h"
25 #include "flatbuffers/util.h"
26 #if defined(FLATBUFFERS_CPP98_STL)
28 #endif // defined(FLATBUFFERS_CPP98_STL)
30 namespace flatbuffers {
34 typedef std::map<std::string, std::pair<std::string, std::string> > FbbParamMap;
35 static TypedFloatConstantGenerator KotlinFloatGen("Double.", "Float.", "NaN",
39 static const CommentConfig comment_config = { "/**", " *", " */" };
40 static const std::string ident_pad = " ";
41 static const char *keywords[] = {
42 "package", "as", "typealias", "class", "this", "super",
43 "val", "var", "fun", "for", "null", "true",
44 "false", "is", "in", "throw", "return", "break",
45 "continue", "object", "if", "try", "else", "while",
46 "do", "when", "interface", "typeof", "Any", "Character"
50 static std::string Esc(const std::string &name) {
51 for (size_t i = 0; i < sizeof(keywords) / sizeof(keywords[0]); i++) {
52 if (name == keywords[i]) { return MakeCamel(name + "_", false); }
55 return MakeCamel(name, false);
58 class KotlinGenerator : public BaseGenerator {
60 KotlinGenerator(const Parser &parser, const std::string &path,
61 const std::string &file_name)
62 : BaseGenerator(parser, path, file_name, "", "."),
63 cur_name_space_(nullptr) {}
65 KotlinGenerator &operator=(const KotlinGenerator &);
66 bool generate() FLATBUFFERS_OVERRIDE {
67 std::string one_file_code;
69 cur_name_space_ = parser_.current_namespace_;
70 for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
72 CodeWriter enumWriter(ident_pad);
73 auto &enum_def = **it;
74 if (!parser_.opts.one_file) cur_name_space_ = enum_def.defined_namespace;
75 GenEnum(enum_def, enumWriter);
76 if (parser_.opts.one_file) {
77 one_file_code += enumWriter.ToString();
79 if (!SaveType(enum_def.name, *enum_def.defined_namespace,
80 enumWriter.ToString(), false))
85 for (auto it = parser_.structs_.vec.begin();
86 it != parser_.structs_.vec.end(); ++it) {
87 CodeWriter structWriter(ident_pad);
88 auto &struct_def = **it;
89 if (!parser_.opts.one_file)
90 cur_name_space_ = struct_def.defined_namespace;
91 GenStruct(struct_def, structWriter);
92 if (parser_.opts.one_file) {
93 one_file_code += structWriter.ToString();
95 if (!SaveType(struct_def.name, *struct_def.defined_namespace,
96 structWriter.ToString(), true))
101 if (parser_.opts.one_file) {
102 return SaveType(file_name_, *parser_.current_namespace_, one_file_code,
108 // Save out the generated code for a single class while adding
109 // declaration boilerplate.
110 bool SaveType(const std::string &defname, const Namespace &ns,
111 const std::string &classcode, bool needs_includes) const {
112 if (!classcode.length()) return true;
115 "// " + std::string(FlatBuffersGeneratedWarning()) + "\n\n";
117 std::string namespace_name = FullNamespace(".", ns);
118 if (!namespace_name.empty()) {
119 code += "package " + namespace_name;
122 if (needs_includes) {
123 code += "import java.nio.*\n";
124 code += "import kotlin.math.sign\n";
125 code += "import com.google.flatbuffers.*\n\n";
128 auto filename = NamespaceDir(ns) + defname + ".kt";
129 return SaveFile(filename.c_str(), code, false);
132 const Namespace *CurrentNameSpace() const FLATBUFFERS_OVERRIDE {
133 return cur_name_space_;
136 static bool IsEnum(const Type &type) {
137 return type.enum_def != nullptr && IsInteger(type.base_type);
140 static std::string GenTypeBasic(const BaseType &type) {
142 static const char * const kotlin_typename[] = {
143 #define FLATBUFFERS_TD(ENUM, IDLTYPE, \
144 CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
146 FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
147 #undef FLATBUFFERS_TD
150 return kotlin_typename[type];
153 std::string GenTypePointer(const Type &type) const {
154 switch (type.base_type) {
155 case BASE_TYPE_STRING: return "String";
156 case BASE_TYPE_VECTOR: return GenTypeGet(type.VectorType());
157 case BASE_TYPE_STRUCT: return WrapInNameSpace(*type.struct_def);
158 default: return "Table";
162 std::string GenTypeGet(const Type &type) const {
163 return IsScalar(type.base_type) ? GenTypeBasic(type.base_type)
164 : GenTypePointer(type);
167 std::string GenEnumDefaultValue(const FieldDef &field) const {
168 auto &value = field.value;
169 FLATBUFFERS_ASSERT(value.type.enum_def);
170 auto &enum_def = *value.type.enum_def;
171 auto enum_val = enum_def.FindByValue(value.constant);
172 return enum_val ? (WrapInNameSpace(enum_def) + "." + enum_val->name)
176 // Generate default values to compare against a default value when
177 // `force_defaults` is `false`.
178 // Main differences are:
179 // - Floats are upcasted to doubles
180 // - Unsigned are casted to signed
181 std::string GenFBBDefaultValue(const FieldDef &field) const {
182 auto out = GenDefaultValue(field, true);
183 // All FlatBufferBuilder default floating point values are doubles
184 if (field.value.type.base_type == BASE_TYPE_FLOAT) {
185 if (out.find("Float") != std::string::npos) {
186 out.replace(0, 5, "Double");
189 // Guarantee all values are doubles
190 if (out.back() == 'f') out.pop_back();
194 // FlatBufferBuilder only store signed types, so this function
195 // returns a cast for unsigned values
196 std::string GenFBBValueCast(const FieldDef &field) const {
197 if (IsUnsigned(field.value.type.base_type)) {
198 return CastToSigned(field.value.type);
203 std::string GenDefaultValue(const FieldDef &field,
204 bool force_signed = false) const {
205 auto &value = field.value;
206 auto base_type = field.value.type.base_type;
207 if (IsFloat(base_type)) {
208 auto val = KotlinFloatGen.GenFloatConstant(field);
209 if (base_type == BASE_TYPE_DOUBLE && val.back() == 'f') {
215 if (base_type == BASE_TYPE_BOOL) {
216 return value.constant == "0" ? "false" : "true";
219 std::string suffix = "";
221 if (base_type == BASE_TYPE_LONG || !force_signed) {
222 suffix = LiteralSuffix(base_type);
224 return value.constant + suffix;
227 void GenEnum(EnumDef &enum_def, CodeWriter &writer) const {
228 if (enum_def.generated) return;
230 GenerateComment(enum_def.doc_comment, writer, &comment_config);
232 writer += "@Suppress(\"unused\")";
233 writer += "@ExperimentalUnsignedTypes";
234 writer += "class " + Esc(enum_def.name) + " private constructor() {";
235 writer.IncrementIdentLevel();
237 GenerateCompanionObject(writer, [&]() {
238 // Write all properties
239 auto vals = enum_def.Vals();
240 for (auto it = vals.begin(); it != vals.end(); ++it) {
242 auto field_type = GenTypeBasic(enum_def.underlying_type.base_type);
243 auto val = enum_def.ToString(ev);
244 auto suffix = LiteralSuffix(enum_def.underlying_type.base_type);
245 writer.SetValue("name", Esc(ev.name));
246 writer.SetValue("type", field_type);
247 writer.SetValue("val", val + suffix);
248 GenerateComment(ev.doc_comment, writer, &comment_config);
249 writer += "const val {{name}}: {{type}} = {{val}}";
252 // Generate a generate string table for enum values.
253 // Problem is, if values are very sparse that could generate really
254 // big tables. Ideally in that case we generate a map lookup
255 // instead, but for the moment we simply don't output a table at all.
256 auto range = enum_def.Distance();
257 // Average distance between values above which we consider a table
258 // "too sparse". Change at will.
259 static const uint64_t kMaxSparseness = 5;
260 if (range / static_cast<uint64_t>(enum_def.size()) < kMaxSparseness) {
261 GeneratePropertyOneLine(writer, "names", "Array<String>", [&]() {
262 writer += "arrayOf(\\";
263 auto val = enum_def.Vals().front();
264 for (auto it = vals.begin(); it != vals.end(); ++it) {
266 for (auto k = enum_def.Distance(val, ev); k > 1; --k)
267 writer += "\"\", \\";
269 writer += "\"" + (*it)->name + "\"\\";
270 if (it + 1 != vals.end()) { writer += ", \\"; }
274 GenerateFunOneLine(writer, "name", "e: Int", "String", [&]() {
275 writer += "names[e\\";
276 if (enum_def.MinValue()->IsNonZero())
277 writer += " - " + enum_def.MinValue()->name + ".toInt()\\";
282 writer.DecrementIdentLevel();
286 // Returns the function name that is able to read a value of the given type.
287 std::string ByteBufferGetter(const Type &type,
288 std::string bb_var_name) const {
289 switch (type.base_type) {
290 case BASE_TYPE_STRING: return "__string";
291 case BASE_TYPE_STRUCT: return "__struct";
292 case BASE_TYPE_UNION: return "__union";
293 case BASE_TYPE_VECTOR:
294 return ByteBufferGetter(type.VectorType(), bb_var_name);
296 case BASE_TYPE_UINT: return bb_var_name + ".getInt";
297 case BASE_TYPE_SHORT:
298 case BASE_TYPE_USHORT: return bb_var_name + ".getShort";
299 case BASE_TYPE_ULONG:
300 case BASE_TYPE_LONG: return bb_var_name + ".getLong";
301 case BASE_TYPE_FLOAT: return bb_var_name + ".getFloat";
302 case BASE_TYPE_DOUBLE: return bb_var_name + ".getDouble";
304 case BASE_TYPE_UCHAR:
306 case BASE_TYPE_UTYPE: return bb_var_name + ".get";
307 case BASE_TYPE_BOOL: return "0.toByte() != " + bb_var_name + ".get";
309 return bb_var_name + ".get" + MakeCamel(GenTypeBasic(type.base_type));
313 std::string ByteBufferSetter(const Type &type) const {
314 if (IsScalar(type.base_type)) {
315 switch (type.base_type) {
317 case BASE_TYPE_UINT: return "bb.putInt";
318 case BASE_TYPE_SHORT:
319 case BASE_TYPE_USHORT: return "bb.putShort";
320 case BASE_TYPE_ULONG:
321 case BASE_TYPE_LONG: return "bb.putLong";
322 case BASE_TYPE_FLOAT: return "bb.putFloat";
323 case BASE_TYPE_DOUBLE: return "bb.putDouble";
325 case BASE_TYPE_UCHAR:
328 case BASE_TYPE_UTYPE: return "bb.put";
329 default: return "bb.put" + MakeCamel(GenTypeBasic(type.base_type));
335 // Returns the function name that is able to read a value of the given type.
336 std::string GenLookupByKey(flatbuffers::FieldDef *key_field,
337 const std::string &bb_var_name,
338 const char *num = nullptr) const {
339 auto type = key_field->value.type;
340 return ByteBufferGetter(type, bb_var_name) + "(" +
341 GenOffsetGetter(key_field, num) + ")";
344 // Returns the method name for use with add/put calls.
345 static std::string GenMethod(const Type &type) {
346 return IsScalar(type.base_type) ? ToSignedType(type)
347 : (IsStruct(type) ? "Struct" : "Offset");
350 // Recursively generate arguments for a constructor, to deal with nested
352 static void GenStructArgs(const StructDef &struct_def, CodeWriter &writer,
353 const char *nameprefix) {
354 for (auto it = struct_def.fields.vec.begin();
355 it != struct_def.fields.vec.end(); ++it) {
357 if (IsStruct(field.value.type)) {
358 // Generate arguments for a struct inside a struct. To ensure
359 // names don't clash, and to make it obvious these arguments are
360 // constructing a nested struct, prefix the name with the field
362 GenStructArgs(*field.value.type.struct_def, writer,
363 (nameprefix + (field.name + "_")).c_str());
365 writer += std::string(", ") + nameprefix + "\\";
366 writer += MakeCamel(field.name) + ": \\";
367 writer += GenTypeBasic(field.value.type.base_type) + "\\";
372 // Recusively generate struct construction statements of the form:
373 // builder.putType(name);
374 // and insert manual padding.
375 static void GenStructBody(const StructDef &struct_def, CodeWriter &writer,
376 const char *nameprefix) {
377 writer.SetValue("align", NumToString(struct_def.minalign));
378 writer.SetValue("size", NumToString(struct_def.bytesize));
379 writer += "builder.prep({{align}}, {{size}})";
380 auto fields_vec = struct_def.fields.vec;
381 for (auto it = fields_vec.rbegin(); it != fields_vec.rend(); ++it) {
385 writer.SetValue("pad", NumToString(field.padding));
386 writer += "builder.pad({{pad}})";
388 if (IsStruct(field.value.type)) {
389 GenStructBody(*field.value.type.struct_def, writer,
390 (nameprefix + (field.name + "_")).c_str());
392 writer.SetValue("type", GenMethod(field.value.type));
393 writer.SetValue("argname", nameprefix + MakeCamel(field.name, false));
394 writer.SetValue("cast", CastToSigned(field.value.type));
395 writer += "builder.put{{type}}({{argname}}{{cast}})";
400 std::string GenByteBufferLength(const char *bb_name) const {
401 std::string bb_len = bb_name;
402 bb_len += ".capacity()";
406 std::string GenOffsetGetter(flatbuffers::FieldDef *key_field,
407 const char *num = nullptr) const {
408 std::string key_offset =
409 "__offset(" + NumToString(key_field->value.offset) + ", ";
412 key_offset += ", _bb)";
414 key_offset += GenByteBufferLength("bb");
415 key_offset += " - tableOffset, bb)";
420 void GenStruct(StructDef &struct_def, CodeWriter &writer) const {
421 if (struct_def.generated) return;
423 GenerateComment(struct_def.doc_comment, writer, &comment_config);
424 auto fixed = struct_def.fixed;
426 writer.SetValue("struct_name", Esc(struct_def.name));
427 writer.SetValue("superclass", fixed ? "Struct" : "Table");
429 writer += "@Suppress(\"unused\")";
430 writer += "@ExperimentalUnsignedTypes";
431 writer += "class {{struct_name}} : {{superclass}}() {\n";
433 writer.IncrementIdentLevel();
436 // Generate the __init() method that sets the field in a pre-existing
437 // accessor object. This is to allow object reuse.
438 GenerateFun(writer, "__init", "_i: Int, _bb: ByteBuffer", "",
439 [&]() { writer += "__reset(_i, _bb)"; });
441 // Generate assign method
442 GenerateFun(writer, "__assign", "_i: Int, _bb: ByteBuffer",
443 Esc(struct_def.name), [&]() {
444 writer += "__init(_i, _bb)";
445 writer += "return this";
448 // Generate all getters
449 GenerateStructGetters(struct_def, writer);
451 // Generate Static Fields
452 GenerateCompanionObject(writer, [&]() {
453 if (!struct_def.fixed) {
454 FieldDef *key_field = nullptr;
456 // Generate verson check method.
457 // Force compile time error if not using the same version
459 GenerateFunOneLine(writer, "validateVersion", "", "", [&]() {
460 writer += "Constants.FLATBUFFERS_1_11_1()";
463 GenerateGetRootAsAccessors(Esc(struct_def.name), writer);
464 GenerateBufferHasIdentifier(struct_def, writer);
465 GenerateTableCreator(struct_def, writer);
467 GenerateStartStructMethod(struct_def, writer);
469 // Static Add for fields
470 auto fields = struct_def.fields.vec;
472 for (auto it = fields.begin(); it != fields.end(); ++it) {
475 if (field.deprecated) continue;
476 if (field.key) key_field = &field;
477 GenerateAddField(NumToString(field_pos), field, writer);
479 if (field.value.type.base_type == BASE_TYPE_VECTOR) {
480 auto vector_type = field.value.type.VectorType();
481 if (!IsStruct(vector_type)) {
482 GenerateCreateVectorField(field, writer);
484 GenerateStartVectorField(field, writer);
488 GenerateEndStructMethod(struct_def, writer);
489 auto file_identifier = parser_.file_identifier_;
490 if (parser_.root_struct_def_ == &struct_def) {
491 GenerateFinishStructBuffer(struct_def, file_identifier, writer);
492 GenerateFinishSizePrefixed(struct_def, file_identifier, writer);
495 if (struct_def.has_key) {
496 GenerateLookupByKey(key_field, struct_def, writer);
499 GenerateStaticConstructor(struct_def, writer);
505 writer.DecrementIdentLevel();
509 // TODO: move key_field to reference instead of pointer
510 void GenerateLookupByKey(FieldDef *key_field, StructDef &struct_def,
511 CodeWriter &writer) const {
512 std::stringstream params;
513 params << "obj: " << Esc(struct_def.name) << "?"
515 params << "vectorLocation: Int, ";
516 params << "key: " << GenTypeGet(key_field->value.type) << ", ";
517 params << "bb: ByteBuffer";
519 auto statements = [&]() {
520 auto base_type = key_field->value.type.base_type;
521 writer.SetValue("struct_name", Esc(struct_def.name));
522 if (base_type == BASE_TYPE_STRING) {
525 "toByteArray(Table.UTF8_CHARSET.get()!!)";
527 writer += "var span = bb.getInt(vectorLocation - 4)";
528 writer += "var start = 0";
529 writer += "while (span != 0) {";
530 writer.IncrementIdentLevel();
531 writer += "var middle = span / 2";
533 "val tableOffset = __indirect(vector"
534 "Location + 4 * (start + middle), bb)";
535 if (key_field->value.type.base_type == BASE_TYPE_STRING) {
536 writer += "val comp = compareStrings(\\";
537 writer += GenOffsetGetter(key_field) + "\\";
538 writer += ", byteKey, bb)";
540 auto cast = CastToUsigned(key_field->value.type);
541 auto get_val = GenLookupByKey(key_field, "bb");
542 writer += "val value = " + get_val + cast;
543 writer += "val comp = value.compareTo(key)";
546 writer.IncrementIdentLevel();
547 writer += "comp > 0 -> span = middle";
548 writer += "comp < 0 -> {";
549 writer.IncrementIdentLevel();
550 writer += "middle++";
551 writer += "start += middle";
552 writer += "span -= middle";
553 writer.DecrementIdentLevel();
554 writer += "}"; // end comp < 0
555 writer += "else -> {";
556 writer.IncrementIdentLevel();
557 writer += "return (obj ?: {{struct_name}}()).__assign(tableOffset, bb)";
558 writer.DecrementIdentLevel();
559 writer += "}"; // end else
560 writer.DecrementIdentLevel();
561 writer += "}"; // end when
562 writer.DecrementIdentLevel();
563 writer += "}"; // end while
564 writer += "return null";
566 GenerateFun(writer, "__lookup_by_key", params.str(),
567 Esc(struct_def.name) + "?", statements);
570 void GenerateFinishSizePrefixed(StructDef &struct_def,
571 const std::string &identifier,
572 CodeWriter &writer) const {
573 auto id = identifier.length() > 0 ? ", \"" + identifier + "\"" : "";
574 auto params = "builder: FlatBufferBuilder, offset: Int";
575 auto method_name = "finishSizePrefixed" + Esc(struct_def.name) + "Buffer";
576 GenerateFunOneLine(writer, method_name, params, "", [&]() {
577 writer += "builder.finishSizePrefixed(offset" + id + ")";
580 void GenerateFinishStructBuffer(StructDef &struct_def,
581 const std::string &identifier,
582 CodeWriter &writer) const {
583 auto id = identifier.length() > 0 ? ", \"" + identifier + "\"" : "";
584 auto params = "builder: FlatBufferBuilder, offset: Int";
585 auto method_name = "finish" + Esc(struct_def.name) + "Buffer";
586 GenerateFunOneLine(writer, method_name, params, "",
587 [&]() { writer += "builder.finish(offset" + id + ")"; });
590 void GenerateEndStructMethod(StructDef &struct_def,
591 CodeWriter &writer) const {
592 // Generate end{{TableName}}(builder: FlatBufferBuilder) method
593 auto name = "end" + Esc(struct_def.name);
594 auto params = "builder: FlatBufferBuilder";
595 auto returns = "Int";
596 auto field_vec = struct_def.fields.vec;
598 GenerateFun(writer, name, params, returns, [&]() {
599 writer += "val o = builder.endTable()";
600 writer.IncrementIdentLevel();
601 for (auto it = field_vec.begin(); it != field_vec.end(); ++it) {
603 if (field.deprecated || !field.required) { continue; }
604 writer.SetValue("offset", NumToString(field.value.offset));
605 writer += "builder.required(o, {{offset}})";
607 writer.DecrementIdentLevel();
608 writer += "return o";
612 // Generate a method to create a vector from a Kotlin array.
613 void GenerateCreateVectorField(FieldDef &field, CodeWriter &writer) const {
614 auto vector_type = field.value.type.VectorType();
615 auto method_name = "create" + MakeCamel(Esc(field.name)) + "Vector";
616 auto params = "builder: FlatBufferBuilder, data: " +
617 GenTypeBasic(vector_type.base_type) + "Array";
618 writer.SetValue("size", NumToString(InlineSize(vector_type)));
619 writer.SetValue("align", NumToString(InlineAlignment(vector_type)));
620 writer.SetValue("root", GenMethod(vector_type));
621 writer.SetValue("cast", CastToSigned(vector_type));
623 GenerateFun(writer, method_name, params, "Int", [&]() {
624 writer += "builder.startVector({{size}}, data.size, {{align}})";
625 writer += "for (i in data.size - 1 downTo 0) {";
626 writer.IncrementIdentLevel();
627 writer += "builder.add{{root}}(data[i]{{cast}})";
628 writer.DecrementIdentLevel();
630 writer += "return builder.endVector()";
634 void GenerateStartVectorField(FieldDef &field, CodeWriter &writer) const {
635 // Generate a method to start a vector, data to be added manually
637 auto vector_type = field.value.type.VectorType();
638 auto params = "builder: FlatBufferBuilder, numElems: Int";
639 writer.SetValue("size", NumToString(InlineSize(vector_type)));
640 writer.SetValue("align", NumToString(InlineAlignment(vector_type)));
643 writer, "start" + MakeCamel(Esc(field.name) + "Vector", true), params,
645 writer += "builder.startVector({{size}}, numElems, {{align}})";
649 void GenerateAddField(std::string field_pos, FieldDef &field,
650 CodeWriter &writer) const {
651 auto field_type = GenTypeBasic(field.value.type.base_type);
652 auto secondArg = MakeCamel(Esc(field.name), false) + ": " + field_type;
653 GenerateFunOneLine(writer, "add" + MakeCamel(Esc(field.name), true),
654 "builder: FlatBufferBuilder, " + secondArg, "", [&]() {
655 auto method = GenMethod(field.value.type);
656 writer.SetValue("field_name",
657 MakeCamel(Esc(field.name), false));
658 writer.SetValue("method_name", method);
659 writer.SetValue("pos", field_pos);
660 writer.SetValue("default", GenFBBDefaultValue(field));
661 writer.SetValue("cast", GenFBBValueCast(field));
663 writer += "builder.add{{method_name}}({{pos}}, \\";
664 writer += "{{field_name}}{{cast}}, {{default}})";
668 static std::string ToSignedType(const Type &type) {
669 switch (type.base_type) {
670 case BASE_TYPE_UINT: return GenTypeBasic(BASE_TYPE_INT);
671 case BASE_TYPE_ULONG: return GenTypeBasic(BASE_TYPE_LONG);
672 case BASE_TYPE_UCHAR:
674 case BASE_TYPE_UTYPE: return GenTypeBasic(BASE_TYPE_CHAR);
675 case BASE_TYPE_USHORT: return GenTypeBasic(BASE_TYPE_SHORT);
676 case BASE_TYPE_VECTOR: return ToSignedType(type.VectorType());
677 default: return GenTypeBasic(type.base_type);
681 static std::string FlexBufferBuilderCast(const std::string &method,
682 FieldDef &field, bool isFirst) {
683 auto field_type = GenTypeBasic(field.value.type.base_type);
685 if (method == "Boolean")
687 else if (method == "Long")
689 else if (method == "Int" || method == "Offset" || method == "Struct")
691 else if (method == "Byte" || method.empty())
692 to_type = isFirst ? "Byte" : "Int";
693 else if (method == "Short")
694 to_type = isFirst ? "Short" : "Int";
695 else if (method == "Double")
697 else if (method == "Float")
698 to_type = isFirst ? "Float" : "Double";
699 else if (method == "UByte")
701 if (field_type != to_type) return ".to" + to_type + "()";
705 // fun startMonster(builder: FlatBufferBuilder) = builder.startTable(11)
706 void GenerateStartStructMethod(StructDef &struct_def,
707 CodeWriter &code) const {
708 GenerateFunOneLine(code, "start" + Esc(struct_def.name),
709 "builder: FlatBufferBuilder", "", [&]() {
710 code += "builder.startTable(" +
711 NumToString(struct_def.fields.vec.size()) +
716 void GenerateTableCreator(StructDef &struct_def, CodeWriter &writer) const {
717 // Generate a method that creates a table in one go. This is only possible
718 // when the table has no struct fields, since those have to be created
719 // inline, and there's no way to do so in Java.
720 bool has_no_struct_fields = true;
722 auto fields_vec = struct_def.fields.vec;
724 for (auto it = fields_vec.begin(); it != fields_vec.end(); ++it) {
726 if (field.deprecated) continue;
727 if (IsStruct(field.value.type)) {
728 has_no_struct_fields = false;
733 // JVM specifications restrict default constructor params to be < 255.
734 // Longs and doubles take up 2 units, so we set the limit to be < 127.
735 if (has_no_struct_fields && num_fields && num_fields < 127) {
736 // Generate a table constructor of the form:
737 // public static int createName(FlatBufferBuilder builder, args...)
739 auto name = "create" + Esc(struct_def.name);
740 std::stringstream params;
741 params << "builder: FlatBufferBuilder";
742 for (auto it = fields_vec.begin(); it != fields_vec.end(); ++it) {
744 if (field.deprecated) continue;
745 params << ", " << MakeCamel(Esc(field.name), false);
746 if (!IsScalar(field.value.type.base_type)) {
747 params << "Offset: ";
751 params << GenTypeBasic(field.value.type.base_type);
754 GenerateFun(writer, name, params.str(), "Int", [&]() {
755 writer.SetValue("vec_size", NumToString(fields_vec.size()));
757 writer += "builder.startTable({{vec_size}})";
759 auto sortbysize = struct_def.sortbysize;
760 auto largest = sortbysize ? sizeof(largest_scalar_t) : 1;
761 for (size_t size = largest; size; size /= 2) {
762 for (auto it = fields_vec.rbegin(); it != fields_vec.rend(); ++it) {
764 auto base_type_size = SizeOf(field.value.type.base_type);
765 if (!field.deprecated && (!sortbysize || size == base_type_size)) {
766 writer.SetValue("camel_field_name",
767 MakeCamel(Esc(field.name), true));
768 writer.SetValue("field_name", MakeCamel(Esc(field.name), false));
770 writer += "add{{camel_field_name}}(builder, {{field_name}}\\";
771 if (!IsScalar(field.value.type.base_type)) {
772 writer += "Offset\\";
778 writer += "return end{{struct_name}}(builder)";
782 void GenerateBufferHasIdentifier(StructDef &struct_def,
783 CodeWriter &writer) const {
784 auto file_identifier = parser_.file_identifier_;
785 // Check if a buffer has the identifier.
786 if (parser_.root_struct_def_ != &struct_def || !file_identifier.length())
788 auto name = MakeCamel(Esc(struct_def.name), false);
789 GenerateFunOneLine(writer, name + "BufferHasIdentifier", "_bb: ByteBuffer",
791 writer += "__has_identifier(_bb, \"" +
792 file_identifier + "\")";
796 void GenerateStructGetters(StructDef &struct_def, CodeWriter &writer) const {
797 auto fields_vec = struct_def.fields.vec;
798 FieldDef *key_field = nullptr;
799 for (auto it = fields_vec.begin(); it != fields_vec.end(); ++it) {
801 if (field.deprecated) continue;
802 if (field.key) key_field = &field;
804 GenerateComment(field.doc_comment, writer, &comment_config);
806 auto field_name = MakeCamel(Esc(field.name), false);
807 auto field_type = GenTypeGet(field.value.type);
808 auto field_default_value = GenDefaultValue(field);
809 auto return_type = GenTypeGet(field.value.type);
810 auto bbgetter = ByteBufferGetter(field.value.type, "bb");
811 auto ucast = CastToUsigned(field);
812 auto offset_val = NumToString(field.value.offset);
814 "val o = __offset(" + offset_val + "); return o != 0 ? ";
815 auto value_base_type = field.value.type.base_type;
816 // Most field accessors need to retrieve and test the field offset
817 // first, this is the offset value for that:
818 writer.SetValue("offset", NumToString(field.value.offset));
819 writer.SetValue("return_type", return_type);
820 writer.SetValue("field_type", field_type);
821 writer.SetValue("field_name", field_name);
822 writer.SetValue("field_default", field_default_value);
823 writer.SetValue("bbgetter", bbgetter);
824 writer.SetValue("ucast", ucast);
826 auto opt_ret_type = return_type + "?";
827 // Generate the accessors that don't do object reuse.
828 if (value_base_type == BASE_TYPE_STRUCT) {
829 // Calls the accessor that takes an accessor object with a
832 // get() = pos(Vec3())
833 GenerateGetterOneLine(writer, field_name, opt_ret_type, [&]() {
834 writer += "{{field_name}}({{field_type}}())";
836 } else if (value_base_type == BASE_TYPE_VECTOR &&
837 field.value.type.element == BASE_TYPE_STRUCT) {
838 // Accessors for vectors of structs also take accessor objects,
839 // this generates a variant without that argument.
840 // ex: fun weapons(j: Int) = weapons(Weapon(), j)
841 GenerateFunOneLine(writer, field_name, "j: Int", opt_ret_type, [&]() {
842 writer += "{{field_name}}({{return_type}}(), j)";
846 if (IsScalar(value_base_type)) {
847 if (struct_def.fixed) {
848 GenerateGetterOneLine(writer, field_name, return_type, [&]() {
849 writer += "{{bbgetter}}(bb_pos + {{offset}}){{ucast}}";
852 GenerateGetter(writer, field_name, return_type, [&]() {
853 writer += "val o = __offset({{offset}})";
855 "return if(o != 0) {{bbgetter}}"
856 "(o + bb_pos){{ucast}} else "
861 switch (value_base_type) {
862 case BASE_TYPE_STRUCT:
863 if (struct_def.fixed) {
864 // create getter with object reuse
866 // fun pos(obj: Vec3) : Vec3? = obj.__assign(bb_pos + 4, bb)
867 // ? adds nullability annotation
869 writer, field_name, "obj: " + field_type, return_type + "?",
870 [&]() { writer += "obj.__assign(bb_pos + {{offset}}, bb)"; });
872 // create getter with object reuse
874 // fun pos(obj: Vec3) : Vec3? {
875 // val o = __offset(4)
876 // return if(o != 0) {
877 // obj.__assign(o + bb_pos, bb)
882 // ? adds nullability annotation
884 writer, field_name, "obj: " + field_type, return_type + "?",
886 auto fixed = field.value.type.struct_def->fixed;
888 writer.SetValue("seek", Indirect("o + bb_pos", fixed));
891 [&]() { writer += "obj.__assign({{seek}}, bb)"; },
892 [&]() { writer += "null"; });
896 case BASE_TYPE_STRING:
897 // create string getter
899 // val Name : String?
901 // val o = __offset(10)
902 // return if (o != 0) __string(o + bb_pos) else null
904 // ? adds nullability annotation
905 GenerateGetter(writer, field_name, return_type + "?", [&]() {
906 writer += "val o = __offset({{offset}})";
907 writer += "return if (o != 0) __string(o + bb_pos) else null";
910 case BASE_TYPE_VECTOR: {
912 // fun inventory(j: Int) : UByte {
913 // val o = __offset(14)
914 // return if (o != 0) {
915 // bb.get(__vector(o) + j * 1).toUByte()
921 auto vectortype = field.value.type.VectorType();
922 std::string params = "j: Int";
923 std::string nullable = IsScalar(vectortype.base_type) ? "" : "?";
925 if (vectortype.base_type == BASE_TYPE_STRUCT ||
926 vectortype.base_type == BASE_TYPE_UNION) {
927 params = "obj: " + field_type + ", j: Int";
930 auto ret_type = return_type + nullable;
931 GenerateFun(writer, field_name, params, ret_type, [&]() {
932 auto inline_size = NumToString(InlineSize(vectortype));
933 auto index = "__vector(o) + j * " + inline_size;
934 auto not_found = NotFoundReturn(field.value.type.element);
936 writer.SetValue("index", index);
937 switch (vectortype.base_type) {
938 case BASE_TYPE_STRUCT: {
939 bool fixed = vectortype.struct_def->fixed;
940 writer.SetValue("index", Indirect(index, fixed));
941 found = "obj.__assign({{index}}, bb)";
944 case BASE_TYPE_UNION:
945 found = "{{bbgetter}}(obj, {{index}} - bb_pos){{ucast}}";
947 default: found = "{{bbgetter}}({{index}}){{ucast}}";
950 writer, offset_val, [&]() { writer += found; },
951 [&]() { writer += not_found; });
955 case BASE_TYPE_UNION:
956 GenerateFun(writer, field_name, "obj: " + field_type,
957 return_type + "?", [&]() {
958 writer += OffsetWrapperOneLine(
959 offset_val, bbgetter + "(obj, o + bb_pos)",
963 default: FLATBUFFERS_ASSERT(0);
967 if (value_base_type == BASE_TYPE_VECTOR) {
968 // Generate Lenght functions for vectors
969 GenerateGetter(writer, field_name + "Length", "Int", [&]() {
970 writer += OffsetWrapperOneLine(offset_val, "__vector_len(o)", "0");
973 // See if we should generate a by-key accessor.
974 if (field.value.type.element == BASE_TYPE_STRUCT &&
975 !field.value.type.struct_def->fixed) {
976 auto &sd = *field.value.type.struct_def;
977 auto &fields = sd.fields.vec;
978 for (auto kit = fields.begin(); kit != fields.end(); ++kit) {
979 auto &kfield = **kit;
981 auto qualified_name = WrapInNameSpace(sd);
982 auto name = MakeCamel(Esc(field.name), false) + "ByKey";
983 auto params = "key: " + GenTypeGet(kfield.value.type);
984 auto rtype = qualified_name + "?";
985 GenerateFun(writer, name, params, rtype, [&]() {
989 writer += qualified_name +
990 ".__lookup_by_key(null, __vector(o), key, bb)";
992 [&]() { writer += "null"; });
995 auto param2 = "obj: " + qualified_name +
996 ", key: " + GenTypeGet(kfield.value.type);
997 GenerateFun(writer, name, param2, rtype, [&]() {
1001 writer += qualified_name +
1002 ".__lookup_by_key(obj, __vector(o), key, bb)";
1004 [&]() { writer += "null"; });
1013 if ((value_base_type == BASE_TYPE_VECTOR &&
1014 IsScalar(field.value.type.VectorType().base_type)) ||
1015 value_base_type == BASE_TYPE_STRING) {
1017 NumToString(value_base_type == BASE_TYPE_STRING
1019 : InlineSize(field.value.type.VectorType()));
1020 // Generate a ByteBuffer accessor for strings & vectors of scalars.
1022 // val inventoryByteBuffer: ByteBuffer
1023 // get = __vector_as_bytebuffer(14, 1)
1025 GenerateGetterOneLine(
1026 writer, field_name + "AsByteBuffer", "ByteBuffer", [&]() {
1027 writer.SetValue("end", end_idx);
1028 writer += "__vector_as_bytebuffer({{offset}}, {{end}})";
1031 // Generate a ByteBuffer accessor for strings & vectors of scalars.
1033 // fun inventoryInByteBuffer(_bb: Bytebuffer):
1034 // ByteBuffer = __vector_as_bytebuffer(_bb, 14, 1)
1036 writer, field_name + "InByteBuffer", "_bb: ByteBuffer",
1037 "ByteBuffer", [&]() {
1038 writer.SetValue("end", end_idx);
1039 writer += "__vector_in_bytebuffer(_bb, {{offset}}, {{end}})";
1043 // generate object accessors if is nested_flatbuffer
1044 // fun testnestedflatbufferAsMonster() : Monster?
1045 //{ return testnestedflatbufferAsMonster(new Monster()); }
1047 if (field.nested_flatbuffer) {
1048 auto nested_type_name = WrapInNameSpace(*field.nested_flatbuffer);
1049 auto nested_method_name =
1050 field_name + "As" + field.nested_flatbuffer->name;
1052 GenerateGetterOneLine(
1053 writer, nested_method_name, nested_type_name + "?", [&]() {
1054 writer += nested_method_name + "(" + nested_type_name + "())";
1057 GenerateFun(writer, nested_method_name, "obj: " + nested_type_name,
1058 nested_type_name + "?", [&]() {
1063 "obj.__assign(__indirect(__vector(o)), bb)";
1065 [&]() { writer += "null"; });
1069 // Generate mutators for scalar fields or vectors of scalars.
1070 if (parser_.opts.mutable_buffer) {
1071 auto value_type = field.value.type;
1072 auto underlying_type = value_base_type == BASE_TYPE_VECTOR
1073 ? value_type.VectorType()
1075 auto name = "mutate" + MakeCamel(Esc(field.name), true);
1076 auto size = NumToString(InlineSize(underlying_type));
1077 auto params = Esc(field.name) + ": " + GenTypeGet(underlying_type);
1078 // A vector mutator also needs the index of the vector element it should
1080 if (value_base_type == BASE_TYPE_VECTOR) params.insert(0, "j: Int, ");
1082 // Boolean parameters have to be explicitly converted to byte
1084 auto setter_parameter =
1085 underlying_type.base_type == BASE_TYPE_BOOL
1086 ? "(if(" + Esc(field.name) + ") 1 else 0).toByte()"
1090 value_base_type == BASE_TYPE_VECTOR
1091 ? "__vector(o) + j * " + size
1092 : (struct_def.fixed ? "bb_pos + " + offset_val : "o + bb_pos");
1093 if (IsScalar(value_base_type) ||
1094 (value_base_type == BASE_TYPE_VECTOR &&
1095 IsScalar(value_type.VectorType().base_type))) {
1096 auto statements = [&]() {
1097 writer.SetValue("bbsetter", ByteBufferSetter(underlying_type));
1098 writer.SetValue("index", setter_index);
1099 writer.SetValue("params", setter_parameter);
1100 writer.SetValue("cast", CastToSigned(field));
1101 if (struct_def.fixed) {
1102 writer += "{{bbsetter}}({{index}}, {{params}}{{cast}})";
1107 writer += "{{bbsetter}}({{index}}, {{params}}{{cast}})";
1110 [&]() { writer += "false"; });
1114 if (struct_def.fixed) {
1115 GenerateFunOneLine(writer, name, params, "ByteBuffer", statements);
1117 GenerateFun(writer, name, params, "Boolean", statements);
1122 if (struct_def.has_key && !struct_def.fixed) {
1123 // Key Comparison method
1124 GenerateOverrideFun(
1125 writer, "keysCompare", "o1: Int, o2: Int, _bb: ByteBuffer", "Int",
1127 if (key_field->value.type.base_type == BASE_TYPE_STRING) {
1128 writer.SetValue("offset", NumToString(key_field->value.offset));
1130 " return compareStrings(__offset({{offset}}, o1, "
1131 "_bb), __offset({{offset}}, o2, _bb), _bb)";
1134 auto getter1 = GenLookupByKey(key_field, "_bb", "o1");
1135 auto getter2 = GenLookupByKey(key_field, "_bb", "o2");
1136 writer += "val val_1 = " + getter1;
1137 writer += "val val_2 = " + getter2;
1138 writer += "return (val_1 - val_2).sign";
1144 static std::string CastToUsigned(const FieldDef &field) {
1145 return CastToUsigned(field.value.type);
1148 static std::string CastToUsigned(const Type type) {
1149 switch (type.base_type) {
1150 case BASE_TYPE_UINT: return ".toUInt()";
1151 case BASE_TYPE_UCHAR:
1152 case BASE_TYPE_UTYPE: return ".toUByte()";
1153 case BASE_TYPE_USHORT: return ".toUShort()";
1154 case BASE_TYPE_ULONG: return ".toULong()";
1155 case BASE_TYPE_VECTOR: return CastToUsigned(type.VectorType());
1160 static std::string CastToSigned(const FieldDef &field) {
1161 return CastToSigned(field.value.type);
1164 static std::string CastToSigned(const Type type) {
1165 switch (type.base_type) {
1166 case BASE_TYPE_UINT: return ".toInt()";
1167 case BASE_TYPE_UCHAR:
1168 case BASE_TYPE_UTYPE: return ".toByte()";
1169 case BASE_TYPE_USHORT: return ".toShort()";
1170 case BASE_TYPE_ULONG: return ".toLong()";
1171 case BASE_TYPE_VECTOR: return CastToSigned(type.VectorType());
1176 static std::string LiteralSuffix(const BaseType type) {
1178 case BASE_TYPE_UINT:
1179 case BASE_TYPE_UCHAR:
1180 case BASE_TYPE_UTYPE:
1181 case BASE_TYPE_USHORT: return "u";
1182 case BASE_TYPE_ULONG: return "UL";
1183 case BASE_TYPE_LONG: return "L";
1188 void GenerateCompanionObject(CodeWriter &code,
1189 const std::function<void()> &callback) const {
1190 code += "companion object {";
1191 code.IncrementIdentLevel();
1193 code.DecrementIdentLevel();
1197 // Generate a documentation comment, if available.
1198 void GenerateComment(const std::vector<std::string> &dc, CodeWriter &writer,
1199 const CommentConfig *config) const {
1200 if (dc.begin() == dc.end()) {
1201 // Don't output empty comment blocks with 0 lines of comment content.
1205 if (config != nullptr && config->first_line != nullptr) {
1206 writer += std::string(config->first_line);
1208 std::string line_prefix =
1209 ((config != nullptr && config->content_line_prefix != nullptr)
1210 ? config->content_line_prefix
1212 for (auto it = dc.begin(); it != dc.end(); ++it) {
1213 writer += line_prefix + *it;
1215 if (config != nullptr && config->last_line != nullptr) {
1216 writer += std::string(config->last_line);
1220 static void GenerateGetRootAsAccessors(const std::string &struct_name,
1221 CodeWriter &writer) {
1222 // Generate a special accessor for the table that when used as the root
1223 // ex: fun getRootAsMonster(_bb: ByteBuffer): Monster {...}
1224 writer.SetValue("gr_name", struct_name);
1225 writer.SetValue("gr_method", "getRootAs" + struct_name);
1227 // create convenience method that doesn't require an existing object
1228 writer += "fun {{gr_method}}(_bb: ByteBuffer): {{gr_name}} = \\";
1229 writer += "{{gr_method}}(_bb, {{gr_name}}())";
1231 // create method that allows object reuse
1232 // ex: fun Monster getRootAsMonster(_bb: ByteBuffer, obj: Monster) {...}
1235 "(_bb: ByteBuffer, obj: {{gr_name}}): {{gr_name}} {";
1236 writer.IncrementIdentLevel();
1237 writer += "_bb.order(ByteOrder.LITTLE_ENDIAN)";
1239 "return (obj.__assign(_bb.getInt(_bb.position())"
1240 " + _bb.position(), _bb))";
1241 writer.DecrementIdentLevel();
1245 static void GenerateStaticConstructor(const StructDef &struct_def,
1247 // create a struct constructor function
1248 auto params = StructConstructorParams(struct_def);
1249 GenerateFun(code, "create" + Esc(struct_def.name), params, "Int", [&]() {
1250 GenStructBody(struct_def, code, "");
1251 code += "return builder.offset()";
1255 static std::string StructConstructorParams(const StructDef &struct_def,
1256 const std::string &prefix = "") {
1257 // builder: FlatBufferBuilder
1258 std::stringstream out;
1259 auto field_vec = struct_def.fields.vec;
1260 if (prefix.empty()) { out << "builder: FlatBufferBuilder"; }
1261 for (auto it = field_vec.begin(); it != field_vec.end(); ++it) {
1263 if (IsStruct(field.value.type)) {
1264 // Generate arguments for a struct inside a struct. To ensure
1265 // names don't clash, and to make it obvious these arguments are
1266 // constructing a nested struct, prefix the name with the field
1268 out << StructConstructorParams(*field.value.type.struct_def,
1269 prefix + (Esc(field.name) + "_"));
1271 out << ", " << prefix << MakeCamel(Esc(field.name), false) << ": "
1272 << GenTypeBasic(field.value.type.base_type);
1278 static void GeneratePropertyOneLine(CodeWriter &writer,
1279 const std::string &name,
1280 const std::string &type,
1281 const std::function<void()> &body) {
1282 // Generates Kotlin getter for properties
1284 // val prop: Mytype = x
1285 writer.SetValue("_name", name);
1286 writer.SetValue("_type", type);
1287 writer += "val {{_name}} : {{_type}} = \\";
1290 static void GenerateGetterOneLine(CodeWriter &writer, const std::string &name,
1291 const std::string &type,
1292 const std::function<void()> &body) {
1293 // Generates Kotlin getter for properties
1295 // val prop: Mytype get() = x
1296 writer.SetValue("_name", name);
1297 writer.SetValue("_type", type);
1298 writer += "val {{_name}} : {{_type}} get() = \\";
1302 static void GenerateGetter(CodeWriter &writer, const std::string &name,
1303 const std::string &type,
1304 const std::function<void()> &body) {
1305 // Generates Kotlin getter for properties
1311 writer.SetValue("name", name);
1312 writer.SetValue("type", type);
1313 writer += "val {{name}} : {{type}}";
1314 writer.IncrementIdentLevel();
1315 writer += "get() {";
1316 writer.IncrementIdentLevel();
1318 writer.DecrementIdentLevel();
1320 writer.DecrementIdentLevel();
1323 static void GenerateFun(CodeWriter &writer, const std::string &name,
1324 const std::string ¶ms,
1325 const std::string &returnType,
1326 const std::function<void()> &body) {
1327 // Generates Kotlin function
1329 // fun path(j: Int): Vec3 {
1330 // return path(Vec3(), j)
1332 auto noreturn = returnType.empty();
1333 writer.SetValue("name", name);
1334 writer.SetValue("params", params);
1335 writer.SetValue("return_type", noreturn ? "" : ": " + returnType);
1336 writer += "fun {{name}}({{params}}) {{return_type}} {";
1337 writer.IncrementIdentLevel();
1339 writer.DecrementIdentLevel();
1343 static void GenerateFunOneLine(CodeWriter &writer, const std::string &name,
1344 const std::string ¶ms,
1345 const std::string &returnType,
1346 const std::function<void()> &body) {
1347 // Generates Kotlin function
1349 // fun path(j: Int): Vec3 = return path(Vec3(), j)
1350 writer.SetValue("name", name);
1351 writer.SetValue("params", params);
1352 writer.SetValue("return_type_p",
1353 returnType.empty() ? "" : " : " + returnType);
1354 writer += "fun {{name}}({{params}}){{return_type_p}} = \\";
1358 static void GenerateOverrideFun(CodeWriter &writer, const std::string &name,
1359 const std::string ¶ms,
1360 const std::string &returnType,
1361 const std::function<void()> &body) {
1362 // Generates Kotlin function
1364 // override fun path(j: Int): Vec3 = return path(Vec3(), j)
1365 writer += "override \\";
1366 GenerateFun(writer, name, params, returnType, body);
1369 static void GenerateOverrideFunOneLine(CodeWriter &writer,
1370 const std::string &name,
1371 const std::string ¶ms,
1372 const std::string &returnType,
1373 const std::string &statement) {
1374 // Generates Kotlin function
1376 // override fun path(j: Int): Vec3 = return path(Vec3(), j)
1377 writer.SetValue("name", name);
1378 writer.SetValue("params", params);
1379 writer.SetValue("return_type",
1380 returnType.empty() ? "" : " : " + returnType);
1381 writer += "override fun {{name}}({{params}}){{return_type}} = \\";
1382 writer += statement;
1385 static std::string OffsetWrapperOneLine(const std::string &offset,
1386 const std::string &found,
1387 const std::string ¬_found) {
1388 return "val o = __offset(" + offset + "); return if (o != 0) " + found +
1389 " else " + not_found;
1392 static void OffsetWrapper(CodeWriter &code, const std::string &offset,
1393 const std::function<void()> &found,
1394 const std::function<void()> ¬_found) {
1395 code += "val o = __offset(" + offset + ")";
1396 code += "return if (o != 0) {";
1397 code.IncrementIdentLevel();
1399 code.DecrementIdentLevel();
1401 code.IncrementIdentLevel();
1403 code.DecrementIdentLevel();
1407 static std::string Indirect(const std::string &index, bool fixed) {
1408 // We apply __indirect() and struct is not fixed.
1409 if (!fixed) return "__indirect(" + index + ")";
1413 static std::string NotFoundReturn(BaseType el) {
1415 case BASE_TYPE_FLOAT: return "0.0f";
1416 case BASE_TYPE_DOUBLE: return "0.0";
1417 case BASE_TYPE_BOOL: return "false";
1418 case BASE_TYPE_LONG:
1420 case BASE_TYPE_CHAR:
1421 case BASE_TYPE_SHORT: return "0";
1422 case BASE_TYPE_UINT:
1423 case BASE_TYPE_UCHAR:
1424 case BASE_TYPE_USHORT:
1425 case BASE_TYPE_UTYPE: return "0u";
1426 case BASE_TYPE_ULONG: return "0uL";
1427 default: return "null";
1431 // This tracks the current namespace used to determine if a type need to be
1432 // prefixed by its namespace
1433 const Namespace *cur_name_space_;
1435 } // namespace kotlin
1437 bool GenerateKotlin(const Parser &parser, const std::string &path,
1438 const std::string &file_name) {
1439 kotlin::KotlinGenerator generator(parser, path, file_name);
1440 return generator.generate();
1442 } // namespace flatbuffers