Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity
d257782230
osrm-backend/third_party/flatbuffers/src/idl_gen_kotlin_kmp.cpp

1620 lines
62 KiB
C++
Raw Normal View History

Bump flatbuffers to v24.3.25 version (#6968)
2024-07-10 14:44:36 -04:00
/*
* Copyright 2014 Google Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// independent from idl_parser, since this code is not needed for most clients
#include <functional>
#include <unordered_set>
#include "flatbuffers/code_generators.h"
#include "flatbuffers/idl.h"
#include "flatbuffers/util.h"
#include "idl_gen_kotlin.h"
#include "idl_namer.h"
namespace flatbuffers {
namespace kotlin {
namespace {
typedef std::map<std::string, std::pair<std::string, std::string> > FbbParamMap;
static TypedFloatConstantGenerator KotlinFloatGen("Double.", "Float.", "NaN",
"POSITIVE_INFINITY",
"NEGATIVE_INFINITY");
static const CommentConfig comment_config = { "/**", " *", " */" };
static const std::string ident_pad = " ";
static std::set<std::string> KotlinKeywords() {
return { "package", "as", "typealias", "class", "this", "super",
"val", "var", "fun", "for", "null", "true",
"false", "is", "in", "throw", "return", "break",
"continue", "object", "if", "try", "else", "while",
"do", "when", "interface", "typeof", "Any", "Character" };
}
static Namer::Config KotlinDefaultConfig() {
return { /*types=*/Case::kKeep,
/*constants=*/Case::kUpperCamel,
/*methods=*/Case::kLowerCamel,
/*functions=*/Case::kKeep,
/*fields=*/Case::kLowerCamel,
/*variables=*/Case::kLowerCamel,
/*variants=*/Case::kUpperCamel,
/*enum_variant_seperator=*/"", // I.e. Concatenate.
/*escape_keywords=*/Namer::Config::Escape::AfterConvertingCase,
/*namespaces=*/Case::kLowerCamel,
/*namespace_seperator=*/".",
/*object_prefix=*/"",
/*object_suffix=*/"T",
/*keyword_prefix=*/"",
/*keyword_suffix=*/"E",
/*filenames=*/Case::kUpperCamel,
/*directories=*/Case::kLowerCamel,
/*output_path=*/"",
/*filename_suffix=*/"",
/*filename_extension=*/".kt" };
}
} // namespace
class KotlinKMPGenerator : public BaseGenerator {
public:
KotlinKMPGenerator(const Parser &parser, const std::string &path,
const std::string &file_name)
: BaseGenerator(parser, path, file_name, "", ".", "kt"),
namer_(WithFlagOptions(KotlinDefaultConfig(), parser.opts, path),
KotlinKeywords()) {}
KotlinKMPGenerator &operator=(const KotlinKMPGenerator &);
bool generate() FLATBUFFERS_OVERRIDE {
std::string one_file_code;
for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
++it) {
CodeWriter enumWriter(ident_pad);
auto &enum_def = **it;
GenEnum(enum_def, enumWriter);
enumWriter += "";
GenEnumOffsetAlias(enum_def, enumWriter);
if (parser_.opts.one_file) {
one_file_code += enumWriter.ToString();
} else {
if (!SaveType(namer_.EscapeKeyword(enum_def.name),
*enum_def.defined_namespace, enumWriter.ToString(), true))
return false;
}
}
for (auto it = parser_.structs_.vec.begin();
it != parser_.structs_.vec.end(); ++it) {
CodeWriter structWriter(ident_pad);
auto &struct_def = **it;
GenStruct(struct_def, structWriter, parser_.opts);
structWriter += "";
GenStructOffsetAlias(struct_def, structWriter);
if (parser_.opts.one_file) {
one_file_code += structWriter.ToString();
} else {
if (!SaveType(namer_.EscapeKeyword(struct_def.name),
*struct_def.defined_namespace, structWriter.ToString(),
true))
return false;
}
}
if (parser_.opts.one_file) {
return SaveType(file_name_, *parser_.current_namespace_, one_file_code,
true);
}
return true;
}
std::string TypeInNameSpace(const Namespace *ns,
const std::string &name = "") const {
auto qualified = namer_.Namespace(*ns);
return qualified.empty() ? name : qualified + qualifying_separator_ + name;
}
std::string TypeInNameSpace(const Definition &def,
const std::string &suffix = "") const {
return TypeInNameSpace(def.defined_namespace, def.name + suffix);
}
// Save out the generated code for a single class while adding
// declaration boilerplate.
bool SaveType(const std::string &defname, const Namespace &ns,
const std::string &classcode, bool needs_includes) const {
if (!classcode.length()) return true;
std::string code =
"// " + std::string(FlatBuffersGeneratedWarning()) + "\n\n";
auto qualified = ns.GetFullyQualifiedName("");
std::string namespace_name = namer_.Namespace(ns);
if (!namespace_name.empty()) {
code += "package " + namespace_name;
code += "\n\n";
}
if (needs_includes) { code += "import com.google.flatbuffers.kotlin.*\n"; }
code += "import kotlin.jvm.JvmInline\n";
code += classcode;
const std::string dirs =
namer_.Directories(ns, SkipDir::None, Case::kUnknown);
EnsureDirExists(dirs);
const std::string filename =
dirs + namer_.File(defname, /*skips=*/SkipFile::Suffix);
return SaveFile(filename.c_str(), code, false);
}
static bool IsEnum(const Type &type) {
return type.enum_def != nullptr && IsInteger(type.base_type);
}
std::string GenerateKotlinPrimiteArray(const Type &type) const {
if (IsScalar(type.base_type) && !IsEnum(type)) { return GenType(type); }
if (IsEnum(type) || type.base_type == BASE_TYPE_UTYPE) {
return TypeInNameSpace(type.enum_def->defined_namespace,
namer_.Type(*type.enum_def));
}
switch (type.base_type) {
case BASE_TYPE_STRUCT:
return "Offset<" + TypeInNameSpace(*type.struct_def) + ">";
case BASE_TYPE_UNION: return "UnionOffset";
case BASE_TYPE_STRING: return "Offset<String>";
case BASE_TYPE_UTYPE: return "Offset<UByte>";
default: return "Offset<" + GenTypeBasic(type.element) + ">";
}
}
std::string GenerateKotlinOffsetArray(const Type &type) const {
if (IsScalar(type.base_type) && !IsEnum(type)) {
return GenType(type) + "Array";
}
if (IsEnum(type) || type.base_type == BASE_TYPE_UTYPE) {
return TypeInNameSpace(type.enum_def->defined_namespace,
namer_.Type(*type.enum_def) + "Array");
}
switch (type.base_type) {
case BASE_TYPE_STRUCT:
return TypeInNameSpace(*type.struct_def) + "OffsetArray";
case BASE_TYPE_UNION: return "UnionOffsetArray";
case BASE_TYPE_STRING: return "StringOffsetArray";
case BASE_TYPE_UTYPE: return "UByteArray";
default: return GenTypeBasic(type.element) + "OffsetArray";
}
}
std::string GenTypeBasic(const BaseType &type) const {
switch (type) {
case BASE_TYPE_NONE:
case BASE_TYPE_UTYPE: return "UByte";
case BASE_TYPE_BOOL: return "Boolean";
case BASE_TYPE_CHAR: return "Byte";
case BASE_TYPE_UCHAR: return "UByte";
case BASE_TYPE_SHORT: return "Short";
case BASE_TYPE_USHORT: return "UShort";
case BASE_TYPE_INT: return "Int";
case BASE_TYPE_UINT: return "UInt";
case BASE_TYPE_LONG: return "Long";
case BASE_TYPE_ULONG: return "ULong";
case BASE_TYPE_FLOAT: return "Float";
case BASE_TYPE_DOUBLE: return "Double";
case BASE_TYPE_STRING:
case BASE_TYPE_STRUCT: return "Offset";
case BASE_TYPE_UNION: return "UnionOffset";
case BASE_TYPE_VECTOR:
case BASE_TYPE_ARRAY: return "VectorOffset";
// VECTOR64 not supported
case BASE_TYPE_VECTOR64: FLATBUFFERS_ASSERT(0);
}
return "Int";
}
std::string GenType(const Type &type) const {
auto base_type = GenTypeBasic(type.base_type);
if (IsEnum(type) || type.base_type == BASE_TYPE_UTYPE) {
return TypeInNameSpace(type.enum_def->defined_namespace,
namer_.Type(*type.enum_def));
}
switch (type.base_type) {
case BASE_TYPE_ARRAY:
case BASE_TYPE_VECTOR: {
switch (type.element) {
case BASE_TYPE_STRUCT:
return base_type + "<" + TypeInNameSpace(*type.struct_def) + ">";
case BASE_TYPE_UNION:
return base_type + "<" + GenTypeBasic(type.element) + ">";
case BASE_TYPE_STRING: return base_type + "<String>";
case BASE_TYPE_UTYPE: return base_type + "<UByte>";
default: return base_type + "<" + GenTypeBasic(type.element) + ">";
}
}
case BASE_TYPE_STRUCT:
return base_type + "<" + TypeInNameSpace(*type.struct_def) + ">";
case BASE_TYPE_STRING: return base_type + "<String>";
case BASE_TYPE_UNION: return base_type;
default: return base_type;
}
// clang-format on
}
std::string GenTypePointer(const Type &type) const {
switch (type.base_type) {
case BASE_TYPE_STRING: return "String";
case BASE_TYPE_VECTOR: return GenTypeGet(type.VectorType());
case BASE_TYPE_STRUCT: return TypeInNameSpace(*type.struct_def);
default: return "Table";
}
}
// with the addition of optional scalar types,
// we are adding the nullable '?' operator to return type of a field.
std::string GetterReturnType(const FieldDef &field) const {
auto base_type = field.value.type.base_type;
auto r_type = GenTypeGet(field.value.type);
if (field.IsScalarOptional() ||
// string, structs and unions
(base_type == BASE_TYPE_STRING || base_type == BASE_TYPE_STRUCT ||
base_type == BASE_TYPE_UNION) ||
// vector of anything not scalar
(base_type == BASE_TYPE_VECTOR &&
!IsScalar(field.value.type.VectorType().base_type))) {
r_type += "?";
}
return r_type;
}
std::string GenTypeGet(const Type &type) const {
return IsScalar(type.base_type) ? GenType(type) : GenTypePointer(type);
}
std::string GenEnumDefaultValue(const FieldDef &field) const {
auto &value = field.value;
FLATBUFFERS_ASSERT(value.type.enum_def);
auto &enum_def = *value.type.enum_def;
auto enum_val = enum_def.FindByValue(value.constant);
return enum_val ? (TypeInNameSpace(enum_def) + "." + enum_val->name)
: value.constant;
}
// differently from GenDefaultValue, the default values are meant
// to be inserted in the buffer as the object is building.
std::string GenDefaultBufferValue(const FieldDef &field) const {
auto &value = field.value;
auto base_type = value.type.base_type;
auto field_name = field.name;
std::string suffix = IsScalar(base_type) ? LiteralSuffix(value.type) : "";
if (field.IsScalarOptional()) { return "null"; }
if (IsFloat(base_type)) {
auto val = KotlinFloatGen.GenFloatConstant(field);
if (base_type == BASE_TYPE_DOUBLE && val.back() == 'f') {
val.pop_back();
}
return val;
}
if (base_type == BASE_TYPE_BOOL) {
return value.constant == "0" ? "false" : "true";
}
if (IsEnum(field.value.type)) {
return value.constant + suffix;
} else if ((IsVector(field.value.type) &&
field.value.type.element == BASE_TYPE_UTYPE) ||
(IsVector(field.value.type) &&
field.value.type.VectorType().base_type == BASE_TYPE_UNION)) {
return value.constant;
} else {
return value.constant + suffix;
}
}
std::string GenDefaultValue(const FieldDef &field) const {
auto &value = field.value;
auto base_type = value.type.base_type;
auto field_name = field.name;
std::string suffix = LiteralSuffix(value.type);
if (field.IsScalarOptional()) { return "null"; }
if (IsFloat(base_type)) {
auto val = KotlinFloatGen.GenFloatConstant(field);
if (base_type == BASE_TYPE_DOUBLE && val.back() == 'f') {
val.pop_back();
}
return val;
}
if (base_type == BASE_TYPE_BOOL) {
return value.constant == "0" ? "false" : "true";
}
if (IsEnum(field.value.type) ||
(IsVector(field.value.type) && IsEnum(field.value.type.VectorType()))) {
return WrapEnumValue(field.value.type, value.constant + suffix);
}
if (IsVector(field.value.type) &&
(field.value.type.VectorType().base_type == BASE_TYPE_UNION ||
field.value.type.VectorType().base_type == BASE_TYPE_STRUCT ||
field.value.type.VectorType().base_type == BASE_TYPE_STRING)) {
return "null";
}
if (IsVector(field.value.type)) {
switch (field.value.type.element) {
case BASE_TYPE_UTYPE:
return namer_.Type(*field.value.type.enum_def) + "(" +
value.constant + suffix + ")";
case BASE_TYPE_UNION:
case BASE_TYPE_STRUCT:
case BASE_TYPE_STRING: return "null";
case BASE_TYPE_BOOL: return value.constant == "0" ? "false" : "true";
case BASE_TYPE_FLOAT: return value.constant + "f";
case BASE_TYPE_DOUBLE: {
return value.constant + ".toDouble()";
}
default: return value.constant + suffix;
}
}
return value.constant + suffix;
}
void GenEnum(EnumDef &enum_def, CodeWriter &writer) const {
if (enum_def.generated) return;
GenerateComment(enum_def.doc_comment, writer, &comment_config);
auto enum_type = namer_.Type(enum_def);
auto field_type = GenTypeBasic(enum_def.underlying_type.base_type);
writer += "@Suppress(\"unused\")";
writer += "@JvmInline";
writer += "value class " + enum_type + " (val value: " + field_type + ") {";
writer.IncrementIdentLevel();
GenerateCompanionObject(writer, [&]() {
// Write all properties
auto vals = enum_def.Vals();
for (auto it = vals.begin(); it != vals.end(); ++it) {
auto &ev = **it;
auto val = enum_def.ToString(ev);
auto suffix = LiteralSuffix(enum_def.underlying_type);
writer.SetValue("name", namer_.Variant(ev));
writer.SetValue("type", enum_type);
writer.SetValue("val", val + suffix);
GenerateComment(ev.doc_comment, writer, &comment_config);
writer += "val {{name}} = {{type}}({{val}})";
}
// Generate a generate string table for enum values.
// Problem is, if values are very sparse that could generate really
// big tables. Ideally in that case we generate a map lookup
// instead, but for the moment we simply don't output a table at all.
auto range = enum_def.Distance();
// Average distance between values above which we consider a table
// "too sparse". Change at will.
static const uint64_t kMaxSparseness = 5;
if (range / static_cast<uint64_t>(enum_def.size()) < kMaxSparseness) {
GeneratePropertyOneLine(writer, "names", "Array<String>", [&]() {
writer += "arrayOf(\\";
auto val = enum_def.Vals().front();
for (auto it = vals.begin(); it != vals.end(); ++it) {
auto ev = *it;
for (auto k = enum_def.Distance(val, ev); k > 1; --k)
writer += "\"\", \\";
val = ev;
writer += "\"" + (*it)->name + "\"\\";
if (it + 1 != vals.end()) { writer += ", \\"; }
}
writer += ")";
});
std::string e_param = "e: " + enum_type;
GenerateFunOneLine(
writer, "name", e_param, "String",
[&]() {
writer += "names[e.value.toInt()\\";
if (enum_def.MinValue()->IsNonZero())
writer += " - " + namer_.Variant(*enum_def.MinValue()) +
".value.toInt()\\";
writer += "]";
},
parser_.opts.gen_jvmstatic);
}
});
writer.DecrementIdentLevel();
writer += "}";
}
// Returns the function name that is able to read a value of the given type.
std::string ByteBufferGetter(const Type &type,
std::string bb_var_name) const {
switch (type.base_type) {
case BASE_TYPE_STRING: return "string";
case BASE_TYPE_STRUCT: return "__struct";
case BASE_TYPE_UNION: return "union";
case BASE_TYPE_VECTOR:
return ByteBufferGetter(type.VectorType(), bb_var_name);
case BASE_TYPE_INT: return bb_var_name + ".getInt";
case BASE_TYPE_UINT: return bb_var_name + ".getUInt";
case BASE_TYPE_SHORT: return bb_var_name + ".getShort";
case BASE_TYPE_USHORT: return bb_var_name + ".getUShort";
case BASE_TYPE_ULONG: return bb_var_name + ".getULong";
case BASE_TYPE_LONG: return bb_var_name + ".getLong";
case BASE_TYPE_FLOAT: return bb_var_name + ".getFloat";
case BASE_TYPE_DOUBLE: return bb_var_name + ".getDouble";
case BASE_TYPE_UTYPE:
case BASE_TYPE_UCHAR: return bb_var_name + ".getUByte";
case BASE_TYPE_CHAR:
case BASE_TYPE_NONE: return bb_var_name + ".get";
case BASE_TYPE_BOOL: return "0.toByte() != " + bb_var_name + ".get";
default: return bb_var_name + "." + namer_.Method("get", GenType(type));
}
}
// Returns the function name that is able to read a value of the given type.
std::string GenLookupByKey(flatbuffers::FieldDef *key_field,
const std::string &bb_var_name,
const char *num = nullptr) const {
auto type = key_field->value.type;
return ByteBufferGetter(type, bb_var_name) + "(" +
GenOffsetGetter(key_field, num) + ")";
}
// Returns the method name for use with add/put calls.
static std::string GenMethod(const Type &type) {
return IsStruct(type) ? "Struct" : "";
}
// Recursively generate arguments for a constructor, to deal with nested
// structs.
void GenStructArgs(const StructDef &struct_def, CodeWriter &writer,
const char *nameprefix) const {
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
auto &field = **it;
if (IsStruct(field.value.type)) {
// Generate arguments for a struct inside a struct. To ensure
// names don't clash, and to make it obvious these arguments are
// constructing a nested struct, prefix the name with the field
// name.
GenStructArgs(*field.value.type.struct_def, writer,
(nameprefix + (field.name + "_")).c_str());
} else {
writer += std::string(", ") + nameprefix + "\\";
writer += namer_.Field(field) + ": \\";
writer += GenType(field.value.type) + "\\";
}
}
}
// Recusively generate struct construction statements of the form:
// builder.putType(name);
// and insert manual padding.
void GenStructBody(const StructDef &struct_def, CodeWriter &writer,
const char *nameprefix) const {
writer.SetValue("align", NumToString(struct_def.minalign));
writer.SetValue("size", NumToString(struct_def.bytesize));
writer += "builder.prep({{align}}, {{size}})";
auto fields_vec = struct_def.fields.vec;
for (auto it = fields_vec.rbegin(); it != fields_vec.rend(); ++it) {
auto &field = **it;
if (field.padding) {
writer.SetValue("pad", NumToString(field.padding));
writer += "builder.pad({{pad}})";
}
if (IsStruct(field.value.type)) {
GenStructBody(*field.value.type.struct_def, writer,
(nameprefix + (field.name + "_")).c_str());
} else {
auto suffix = IsEnum(field.value.type) ? ".value" : "";
writer.SetValue("type", GenMethod(field.value.type));
writer.SetValue("argname",
nameprefix + namer_.Variable(field) + suffix);
writer += "builder.put{{type}}({{argname}})";
}
}
}
std::string GenOffsetGetter(flatbuffers::FieldDef *key_field,
const char *num = nullptr) const {
std::string key_offset =
"offset(" + NumToString(key_field->value.offset) + ", ";
if (num) {
key_offset += num;
key_offset += ", buffer)";
} else {
key_offset += "(bb.capacity - tableOffset).toOffset<Int>(), bb)";
}
return key_offset;
}
bool StructHasUnsignedField(StructDef &struct_def) {
auto vec = struct_def.fields.vec;
for (auto it = vec.begin(); it != vec.end(); ++it) {
auto &field = **it;
if (IsUnsigned(field.value.type.base_type)) { return true; }
}
return false;
}
// This method generate alias types for offset arrays. We need it
// to avoid unboxing/boxing of offsets when put into an array.
// e.g:
// Array<Offset<Monster>> generates boxing.
// So we creates a new type to avoid it:
// typealias MonterOffsetArray = IntArray
void GenStructOffsetAlias(StructDef &struct_def, CodeWriter &writer) const {
if (struct_def.generated) return;
auto name = namer_.Type(struct_def);
// This assumes offset as Ints always.
writer += "typealias " + name + "OffsetArray = OffsetArray<" + name + ">";
// public inline fun <T> MonsterOffsetArray(size: Int, crossinline call:
// (Int) -> Offset<T>): OffsetArray<T> {
// return OffsetArray(IntArray(size) { call(it).value })
// }
writer += "";
writer += "inline fun " + name +
"OffsetArray(size: Int, crossinline call: (Int) -> Offset<" +
name + ">): " + name + "OffsetArray =";
writer.IncrementIdentLevel();
writer += name + "OffsetArray(IntArray(size) { call(it).value })";
}
// This method generate alias types for offset arrays. We need it
// to avoid unboxing/boxing of offsets when put into an array.
// e.g:
// Array<Offset<Monster>> generates boxing.
// So we creates a new type to avoid it:
// typealias MonterOffsetArray = IntArray
void GenEnumOffsetAlias(EnumDef &enum_def, CodeWriter &writer) const {
if (enum_def.generated) return;
// This assumes offset as Ints always.
writer += "typealias " + namer_.Type(enum_def) +
"Array = " + GenTypeBasic(enum_def.underlying_type.base_type) +
"Array";
}
void GenStruct(StructDef &struct_def, CodeWriter &writer,
IDLOptions options) const {
if (struct_def.generated) return;
GenerateComment(struct_def.doc_comment, writer, &comment_config);
auto fixed = struct_def.fixed;
writer.SetValue("struct_name", namer_.Type(struct_def));
writer.SetValue("superclass", fixed ? "Struct" : "Table");
writer += "@Suppress(\"unused\")";
writer += "class {{struct_name}} : {{superclass}}() {\n";
writer.IncrementIdentLevel();
{
auto esc_type = namer_.EscapeKeyword(struct_def.name);
// Generate the init() method that sets the field in a pre-existing
// accessor object. This is to allow object reuse.
GenerateFunOneLine(writer, "init", "i: Int, buffer: ReadWriteBuffer",
esc_type, [&]() { writer += "reset(i, buffer)"; });
writer += ""; // line break
// Generate all getters
GenerateStructGetters(struct_def, writer);
// Generate Static Fields
GenerateCompanionObject(writer, [&]() {
if (!struct_def.fixed) {
FieldDef *key_field = nullptr;
// Generate version check method.
// Force compile time error if not using the same version
// runtime.
GenerateFunOneLine(
writer, "validateVersion", "", "",
[&]() { writer += "VERSION_2_0_8"; }, options.gen_jvmstatic);
writer += "";
GenerateGetRootAsAccessors(namer_.Type(struct_def), writer, options);
writer += "";
GenerateBufferHasIdentifier(struct_def, writer, options);
writer += "";
GenerateTableCreator(struct_def, writer, options);
GenerateStartStructMethod(struct_def, writer, options);
// Static Add for fields
auto fields = struct_def.fields.vec;
int field_pos = -1;
for (auto it = fields.begin(); it != fields.end(); ++it) {
auto &field = **it;
field_pos++;
if (field.deprecated) continue;
if (field.key) key_field = &field;
writer += "";
GenerateAddField(NumToString(field_pos), field, writer, options);
if (IsVector(field.value.type)) {
auto vector_type = field.value.type.VectorType();
if (!IsStruct(vector_type)) {
writer += "";
GenerateCreateVectorField(field, writer, options);
}
writer += "";
GenerateStartVectorField(field, writer, options);
}
}
writer += "";
GenerateEndStructMethod(struct_def, writer, options);
auto file_identifier = parser_.file_identifier_;
if (parser_.root_struct_def_ == &struct_def) {
writer += "";
GenerateFinishStructBuffer(struct_def, file_identifier, writer,
options);
writer += "";
GenerateFinishSizePrefixed(struct_def, file_identifier, writer,
options);
}
if (struct_def.has_key) {
writer += "";
GenerateLookupByKey(key_field, struct_def, writer, options);
}
} else {
writer += "";
GenerateStaticConstructor(struct_def, writer, options);
}
});
}
// class closing
writer.DecrementIdentLevel();
writer += "}";
}
// TODO: move key_field to reference instead of pointer
void GenerateLookupByKey(FieldDef *key_field, StructDef &struct_def,
CodeWriter &writer, const IDLOptions options) const {
std::stringstream params;
params << "obj: " << namer_.Type(struct_def) << "?"
<< ", ";
params << "vectorLocation: Int, ";
params << "key: " << GenTypeGet(key_field->value.type) << ", ";
params << "bb: ReadWriteBuffer";
auto statements = [&]() {
auto base_type = key_field->value.type.base_type;
writer.SetValue("struct_name", namer_.Type(struct_def));
if (base_type == BASE_TYPE_STRING) {
writer += "val byteKey = key.encodeToByteArray()";
}
writer += "var span = bb.getInt(vectorLocation - 4)";
writer += "var start = 0";
writer += "while (span != 0) {";
writer.IncrementIdentLevel();
writer += "var middle = span / 2";
writer +=
"val tableOffset = indirect(vector"
"Location + 4 * (start + middle), bb)";
if (IsString(key_field->value.type)) {
writer += "val comp = compareStrings(\\";
writer += GenOffsetGetter(key_field) + "\\";
writer += ", byteKey, bb)";
} else {
auto get_val = GenLookupByKey(key_field, "bb");
writer += "val value = " + get_val;
writer += "val comp = value.compareTo(key)";
}
writer += "when {";
writer.IncrementIdentLevel();
writer += "comp > 0 -> span = middle";
writer += "comp < 0 -> {";
writer.IncrementIdentLevel();
writer += "middle++";
writer += "start += middle";
writer += "span -= middle";
writer.DecrementIdentLevel();
writer += "}"; // end comp < 0
writer += "else -> {";
writer.IncrementIdentLevel();
writer += "return (obj ?: {{struct_name}}()).init(tableOffset, bb)";
writer.DecrementIdentLevel();
writer += "}"; // end else
writer.DecrementIdentLevel();
writer += "}"; // end when
writer.DecrementIdentLevel();
writer += "}"; // end while
writer += "return null";
};
GenerateFun(writer, "lookupByKey", params.str(),
namer_.Type(struct_def) + "?", statements,
options.gen_jvmstatic);
}
void GenerateFinishSizePrefixed(StructDef &struct_def,
const std::string &identifier,
CodeWriter &writer,
const IDLOptions options) const {
auto id = identifier.length() > 0 ? ", \"" + identifier + "\"" : "";
auto gen_type = "Offset<" + namer_.Type(struct_def.name) + ">";
auto params = "builder: FlatBufferBuilder, offset: " + gen_type;
auto method_name =
namer_.LegacyJavaMethod2("finishSizePrefixed", struct_def, "Buffer");
GenerateFunOneLine(
writer, method_name, params, "",
[&]() { writer += "builder.finishSizePrefixed(offset" + id + ")"; },
options.gen_jvmstatic);
}
void GenerateFinishStructBuffer(StructDef &struct_def,
const std::string &identifier,
CodeWriter &writer,
const IDLOptions options) const {
auto id = identifier.length() > 0 ? ", \"" + identifier + "\"" : "";
auto gen_type = "Offset<" + namer_.Type(struct_def.name) + ">";
auto params = "builder: FlatBufferBuilder, offset: " + gen_type;
auto method_name =
namer_.LegacyKotlinMethod("finish", struct_def, "Buffer");
GenerateFunOneLine(
writer, method_name, params, "",
[&]() { writer += "builder.finish(offset" + id + ")"; },
options.gen_jvmstatic);
}
void GenerateEndStructMethod(StructDef &struct_def, CodeWriter &writer,
const IDLOptions options) const {
// Generate end{{TableName}}(builder: FlatBufferBuilder) method
auto name = namer_.Method("end", struct_def.name);
auto params = "builder: FlatBufferBuilder";
auto returns = "Offset<" + namer_.Type(struct_def) + '>';
auto field_vec = struct_def.fields.vec;
GenerateFun(
writer, name, params, returns,
[&]() {
writer += "val o: " + returns + " = builder.endTable()";
writer.IncrementIdentLevel();
for (auto it = field_vec.begin(); it != field_vec.end(); ++it) {
auto &field = **it;
if (field.deprecated || !field.IsRequired()) { continue; }
writer.SetValue("offset", NumToString(field.value.offset));
writer.SetValue("field_name", field.name);
writer += "builder.required(o, {{offset}}, \"{{field_name}}\")";
}
writer.DecrementIdentLevel();
writer += "return o";
},
options.gen_jvmstatic);
}
// Generate a method to create a vector from a Kotlin array.
void GenerateCreateVectorField(FieldDef &field, CodeWriter &writer,
const IDLOptions options) const {
auto vector_type = field.value.type.VectorType();
auto method_name = namer_.Method("create", field, "vector");
auto array_param = GenerateKotlinOffsetArray(vector_type);
auto params = "builder: FlatBufferBuilder, vector:" + array_param;
auto return_type = GenType(field.value.type);
writer.SetValue("size", NumToString(InlineSize(vector_type)));
writer.SetValue("align", NumToString(InlineAlignment(vector_type)));
writer.SetValue("root", GenMethod(vector_type));
GenerateFun(
writer, method_name, params, return_type,
[&]() {
writer += "builder.startVector({{size}}, vector.size, {{align}})";
writer += "for (i in vector.size - 1 downTo 0) {";
writer.IncrementIdentLevel();
writer += "builder.add{{root}}(vector[i])";
writer.DecrementIdentLevel();
writer += "}";
writer += "return builder.endVector()";
},
options.gen_jvmstatic);
}
void GenerateStartVectorField(FieldDef &field, CodeWriter &writer,
const IDLOptions options) const {
// Generate a method to start a vector, data to be added manually
// after.
auto vector_type = field.value.type.VectorType();
auto params = "builder: FlatBufferBuilder, numElems: Int";
writer.SetValue("size", NumToString(InlineSize(vector_type)));
writer.SetValue("align", NumToString(InlineAlignment(vector_type)));
GenerateFunOneLine(
writer, namer_.Method("start", field, "Vector"), params, "",
[&]() {
writer += "builder.startVector({{size}}, numElems, {{align}})";
},
options.gen_jvmstatic);
}
void GenerateAddField(std::string field_pos, FieldDef &field,
CodeWriter &writer, const IDLOptions options) const {
auto field_type = GenType(field.value.type);
auto secondArg = namer_.Variable(field.name) + ": " + field_type;
auto content = [&]() {
auto method = GenMethod(field.value.type);
auto default_value = GenDefaultBufferValue(field);
auto field_param = namer_.Field(field);
if (IsEnum(field.value.type) || IsStruct(field.value.type)) {
field_param += ".value";
}
writer.SetValue("field_name", namer_.Field(field));
writer.SetValue("field_param", field_param);
writer.SetValue("method_name", method);
writer.SetValue("pos", field_pos);
writer.SetValue("default", default_value);
if (field.key) {
// field has key attribute, so always need to exist
// even if its value is equal to default.
// Generated code will bypass default checking
// resulting in { builder.addShort(name); slot(id); }
writer += "builder.add{{method_name}}({{field_name}})";
writer += "builder.slot({{pos}})";
} else {
writer += "builder.add{{method_name}}({{pos}}, \\";
writer += "{{field_param}}, {{default}})";
}
};
auto signature = namer_.LegacyKotlinMethod("add", field, "");
auto params = "builder: FlatBufferBuilder, " + secondArg;
if (field.key) {
GenerateFun(writer, signature, params, "", content,
options.gen_jvmstatic);
} else {
GenerateFunOneLine(writer, signature, params, "", content,
options.gen_jvmstatic);
}
}
// fun startMonster(builder: FlatBufferBuilder) = builder.startTable(11)
void GenerateStartStructMethod(StructDef &struct_def, CodeWriter &code,
const IDLOptions options) const {
GenerateFunOneLine(
code, namer_.LegacyJavaMethod2("start", struct_def, ""),
"builder: FlatBufferBuilder", "",
[&]() {
code += "builder.startTable(" +
NumToString(struct_def.fields.vec.size()) + ")";
},
options.gen_jvmstatic);
}
void GenerateTableCreator(StructDef &struct_def, CodeWriter &writer,
const IDLOptions options) const {
// Generate a method that creates a table in one go. This is only possible
// when the table has no struct fields, since those have to be created
// inline, and there's no way to do so in Java.
bool has_no_struct_fields = true;
int num_fields = 0;
auto fields_vec = struct_def.fields.vec;
for (auto it = fields_vec.begin(); it != fields_vec.end(); ++it) {
auto &field = **it;
if (field.deprecated) continue;
if (IsStruct(field.value.type)) {
has_no_struct_fields = false;
} else {
num_fields++;
}
}
// JVM specifications restrict default constructor params to be < 255.
// Longs and doubles take up 2 units, so we set the limit to be < 127.
if (has_no_struct_fields && num_fields && num_fields < 127) {
// Generate a table constructor of the form:
// public static int createName(FlatBufferBuilder builder, args...)
auto name = namer_.LegacyJavaMethod2("create", struct_def, "");
std::stringstream params;
params << "builder: FlatBufferBuilder";
for (auto it = fields_vec.begin(); it != fields_vec.end(); ++it) {
auto &field = **it;
if (field.deprecated) continue;
params << ", " << namer_.Variable(field);
if (!IsScalar(field.value.type.base_type)) {
params << "Offset: ";
} else {
params << ": ";
}
auto optional = field.IsScalarOptional() ? "?" : "";
params << GenType(field.value.type) << optional;
}
GenerateFun(
writer, name, params.str(), "Offset<" + namer_.Type(struct_def) + '>',
[&]() {
writer.SetValue("vec_size", NumToString(fields_vec.size()));
writer.SetValue("end_method",
namer_.Method("end", struct_def.name));
writer += "builder.startTable({{vec_size}})";
auto sortbysize = struct_def.sortbysize;
auto largest = sortbysize ? sizeof(largest_scalar_t) : 1;
for (size_t size = largest; size; size /= 2) {
for (auto it = fields_vec.rbegin(); it != fields_vec.rend();
++it) {
auto &field = **it;
auto base_type_size = SizeOf(field.value.type.base_type);
if (!field.deprecated &&
(!sortbysize || size == base_type_size)) {
writer.SetValue("field_name", namer_.Field(field));
// we wrap on null check for scalar optionals
writer += field.IsScalarOptional()
? "{{field_name}}?.run { \\"
: "\\";
writer += namer_.LegacyKotlinMethod("add", field, "") +
"(builder, {{field_name}}\\";
if (!IsScalar(field.value.type.base_type)) {
writer += "Offset\\";
}
// we wrap on null check for scalar optionals
writer += field.IsScalarOptional() ? ") }" : ")";
}
}
}
writer += "return {{end_method}}(builder)";
},
options.gen_jvmstatic);
}
}
void GenerateBufferHasIdentifier(StructDef &struct_def, CodeWriter &writer,
IDLOptions options) const {
auto file_identifier = parser_.file_identifier_;
// Check if a buffer has the identifier.
if (parser_.root_struct_def_ != &struct_def || !file_identifier.length())
return;
auto name = namer_.Function(struct_def);
GenerateFunOneLine(
writer, name + "BufferHasIdentifier", "buffer: ReadWriteBuffer",
"Boolean",
[&]() {
writer += "hasIdentifier(buffer, \"" + file_identifier + "\")";
},
options.gen_jvmstatic);
}
void GenerateStructGetters(StructDef &struct_def, CodeWriter &writer) const {
auto fields_vec = struct_def.fields.vec;
FieldDef *key_field = nullptr;
for (auto it = fields_vec.begin(); it != fields_vec.end(); ++it) {
auto &field = **it;
if (field.deprecated) continue;
if (field.key) key_field = &field;
GenerateComment(field.doc_comment, writer, &comment_config);
auto field_name = namer_.Field(field);
auto field_type = GenTypeGet(field.value.type);
auto field_default_value = GenDefaultValue(field);
auto return_type = GetterReturnType(field);
auto bbgetter = ByteBufferGetter(field.value.type, "bb");
auto offset_val = NumToString(field.value.offset);
auto offset_prefix =
"val o = offset(" + offset_val + "); return o != 0 ? ";
auto value_base_type = field.value.type.base_type;
// Most field accessors need to retrieve and test the field offset
// first, this is the offset value for that:
writer.SetValue("offset", NumToString(field.value.offset));
writer.SetValue("return_type", return_type);
writer.SetValue("field_type", field_type);
writer.SetValue("field_name", field_name);
writer.SetValue("field_default", field_default_value);
writer.SetValue("bbgetter", bbgetter);
// Generate the accessors that don't do object reuse.
if (value_base_type == BASE_TYPE_STRUCT) {
// Calls the accessor that takes an accessor object with a
// new object.
// val pos
// get() = pos(Vec3())
GenerateGetterOneLine(writer, field_name, return_type, [&]() {
writer += "{{field_name}}({{field_type}}())";
});
} else if (value_base_type == BASE_TYPE_VECTOR &&
field.value.type.element == BASE_TYPE_STRUCT) {
// Accessors for vectors of structs also take accessor objects,
// this generates a variant without that argument.
// ex: fun weapons(j: Int) = weapons(Weapon(), j)
GenerateFunOneLine(writer, field_name, "j: Int", return_type, [&]() {
writer += "{{field_name}}({{field_type}}(), j)";
});
}
if (IsScalar(value_base_type)) {
if (struct_def.fixed) {
GenerateGetterOneLine(writer, field_name, return_type, [&]() {
std::string found = "{{bbgetter}}(bufferPos + {{offset}})";
writer += WrapEnumValue(field.value.type, found);
});
} else {
GenerateGetterOneLine(writer, field_name, return_type, [&]() {
std::string found = "{{bbgetter}}(it + bufferPos)";
writer += LookupFieldOneLine(offset_val,
WrapEnumValue(field.value.type, found),
"{{field_default}}");
});
}
} else {
switch (value_base_type) {
case BASE_TYPE_STRUCT:
if (struct_def.fixed) {
// create getter with object reuse
// ex:
// fun pos(obj: Vec3) : Vec3? = obj.init(bufferPos + 4, bb)
// ? adds nullability annotation
GenerateFunOneLine(
writer, field_name, "obj: " + field_type, return_type, [&]() {
writer += "obj.init(bufferPos + {{offset}}, bb)";
});
} else {
// create getter with object reuse
// ex:
// fun pos(obj: Vec3) : Vec3? {
// val o = offset(4)
// return if(o != 0) {
// obj.init(o + bufferPos, bb)
// else {
// null
// }
// }
// ? adds nullability annotation
GenerateFunOneLine(
writer, field_name, "obj: " + field_type, return_type, [&]() {
auto fixed = field.value.type.struct_def->fixed;
writer.SetValue("seek", Indirect("it + bufferPos", fixed));
writer += LookupFieldOneLine(
offset_val, "obj.init({{seek}}, bb)", "null");
});
}
break;
case BASE_TYPE_STRING:
// create string getter
// e.g.
// val Name : String?
// get() = {
// val o = offset(10)
// return if (o != 0) string(o + bufferPos) else null
// }
// ? adds nullability annotation
GenerateGetterOneLine(writer, field_name, return_type, [&]() {
writer += LookupFieldOneLine(offset_val, "string(it + bufferPos)",
"null");
});
break;
case BASE_TYPE_VECTOR: {
// e.g.
// fun inventory(j: Int) : UByte {
// val o = offset(14)
// return if (o != 0) {
// bb.get(vector(it) + j * 1).toUByte()
// } else {
// 0
// }
// }
auto vectortype = field.value.type.VectorType();
std::string params = "j: Int";
if (vectortype.base_type == BASE_TYPE_STRUCT ||
vectortype.base_type == BASE_TYPE_UNION) {
params = "obj: " + field_type + ", j: Int";
}
GenerateFunOneLine(writer, field_name, params, return_type, [&]() {
auto inline_size = NumToString(InlineSize(vectortype));
auto index = "vector(it) + j * " + inline_size;
std::string found = "";
writer.SetValue("index", index);
if (IsEnum(vectortype)) {
found = "{{field_type}}({{bbgetter}}({{index}}))";
} else {
switch (vectortype.base_type) {
case BASE_TYPE_STRUCT: {
bool fixed = vectortype.struct_def->fixed;
writer.SetValue("index", Indirect(index, fixed));
found = "obj.init({{index}}, bb)";
break;
}
case BASE_TYPE_UNION:
found = "{{bbgetter}}(obj, {{index}})";
break;
case BASE_TYPE_UTYPE:
found = "{{field_type}}({{bbgetter}}({{index}}))";
break;
default: found = "{{bbgetter}}({{index}})";
}
}
writer +=
LookupFieldOneLine(offset_val, found, "{{field_default}}");
});
break;
}
case BASE_TYPE_UNION:
GenerateFunOneLine(
writer, field_name, "obj: " + field_type, return_type, [&]() {
writer += LookupFieldOneLine(
offset_val, bbgetter + "(obj, it + bufferPos)", "null");
});
break;
default: FLATBUFFERS_ASSERT(0);
}
}
if (value_base_type == BASE_TYPE_VECTOR) {
// Generate Lenght functions for vectors
GenerateGetterOneLine(writer, field_name + "Length", "Int", [&]() {
writer += LookupFieldOneLine(offset_val, "vectorLength(it)", "0");
});
// See if we should generate a by-key accessor.
if (field.value.type.element == BASE_TYPE_STRUCT &&
!field.value.type.struct_def->fixed) {
auto &sd = *field.value.type.struct_def;
auto &fields = sd.fields.vec;
for (auto kit = fields.begin(); kit != fields.end(); ++kit) {
auto &kfield = **kit;
if (kfield.key) {
auto qualified_name = TypeInNameSpace(sd);
auto name = namer_.Method(field, "ByKey");
auto params = "key: " + GenTypeGet(kfield.value.type);
auto rtype = qualified_name + "?";
GenerateFunOneLine(writer, name, params, rtype, [&]() {
writer += LookupFieldOneLine(
offset_val,
qualified_name + ".lookupByKey(null, vector(it), key, bb)",
"null");
});
auto param2 = "obj: " + qualified_name +
", key: " + GenTypeGet(kfield.value.type);
GenerateFunOneLine(writer, name, param2, rtype, [&]() {
writer += LookupFieldOneLine(
offset_val,
qualified_name + ".lookupByKey(obj, vector(it), key, bb)",
"null");
});
break;
}
}
}
}
if ((value_base_type == BASE_TYPE_VECTOR &&
IsScalar(field.value.type.VectorType().base_type)) ||
value_base_type == BASE_TYPE_STRING) {
auto end_idx =
NumToString(value_base_type == BASE_TYPE_STRING
? 1
: InlineSize(field.value.type.VectorType()));
// Generate a ByteBuffer accessor for strings & vectors of scalars.
// e.g.
// fun inventoryInByteBuffer(buffer: Bytebuffer):
// ByteBuffer = vectorAsBuffer(buffer, 14, 1)
GenerateFunOneLine(
writer, field_name + "AsBuffer", "", "ReadBuffer", [&]() {
writer.SetValue("end", end_idx);
writer += "vectorAsBuffer(bb, {{offset}}, {{end}})";
});
}
// generate object accessors if is nested_flatbuffer
// fun testnestedflatbufferAsMonster() : Monster?
//{ return testnestedflatbufferAsMonster(new Monster()); }
if (field.nested_flatbuffer) {
auto nested_type_name = TypeInNameSpace(*field.nested_flatbuffer);
auto nested_method_name =
field_name + "As" + field.nested_flatbuffer->name;
GenerateGetterOneLine(
writer, nested_method_name, nested_type_name + "?", [&]() {
writer += nested_method_name + "(" + nested_type_name + "())";
});
GenerateFunOneLine(
writer, nested_method_name, "obj: " + nested_type_name,
nested_type_name + "?", [&]() {
writer += LookupFieldOneLine(
offset_val, "obj.init(indirect(vector(it)), bb)", "null");
});
}
writer += ""; // Initial line break between fields
}
if (struct_def.has_key && !struct_def.fixed) {
// Key Comparison method
GenerateOverrideFun(
writer, "keysCompare",
"o1: Offset<*>, o2: Offset<*>, buffer: ReadWriteBuffer", "Int",
[&]() {
if (IsString(key_field->value.type)) {
writer.SetValue("offset", NumToString(key_field->value.offset));
writer +=
" return compareStrings(offset({{offset}}, o1, "
"buffer), offset({{offset}}, o2, buffer), buffer)";
} else {
auto getter1 = GenLookupByKey(key_field, "buffer", "o1");
auto getter2 = GenLookupByKey(key_field, "buffer", "o2");
writer += "val a = " + getter1;
writer += "val b = " + getter2;
writer += "return (a - b).toInt().sign()";
}
});
}
}
static std::string LiteralSuffix(const Type &type) {
auto base = IsVector(type) ? type.element : type.base_type;
switch (base) {
case BASE_TYPE_UINT:
case BASE_TYPE_UCHAR:
case BASE_TYPE_UTYPE:
case BASE_TYPE_USHORT: return "u";
case BASE_TYPE_ULONG: return "UL";
case BASE_TYPE_LONG: return "L";
default: return "";
}
}
std::string WrapEnumValue(const Type &type, const std::string value) const {
if (IsEnum(type)) { return GenType(type) + "(" + value + ")"; }
if (IsVector(type) && IsEnum(type.VectorType())) {
return GenType(type.VectorType()) + "(" + value + ")";
}
return value;
}
void GenerateCompanionObject(CodeWriter &code,
const std::function<void()> &callback) const {
code += "companion object {";
code.IncrementIdentLevel();
callback();
code.DecrementIdentLevel();
code += "}";
}
// Generate a documentation comment, if available.
void GenerateComment(const std::vector<std::string> &dc, CodeWriter &writer,
const CommentConfig *config) const {
if (dc.begin() == dc.end()) {
// Don't output empty comment blocks with 0 lines of comment content.
return;
}
if (config != nullptr && config->first_line != nullptr) {
writer += std::string(config->first_line);
}
std::string line_prefix =
((config != nullptr && config->content_line_prefix != nullptr)
? config->content_line_prefix
: "///");
for (auto it = dc.begin(); it != dc.end(); ++it) {
writer += line_prefix + *it;
}
if (config != nullptr && config->last_line != nullptr) {
writer += std::string(config->last_line);
}
}
void GenerateGetRootAsAccessors(const std::string &struct_name,
CodeWriter &writer,
IDLOptions options) const {
// Generate a special accessor for the table that when used as the root
// ex: fun getRootAsMonster(buffer: ByteBuffer): Monster {...}
writer.SetValue("gr_name", struct_name);
// create convenience method that doesn't require an existing object
GenerateJvmStaticAnnotation(writer, options.gen_jvmstatic);
GenerateFunOneLine(writer, "asRoot", "buffer: ReadWriteBuffer", struct_name,
[&]() { writer += "asRoot(buffer, {{gr_name}}())"; });
// create method that allows object reuse
// ex: fun Monster getRootAsMonster(buffer: ByteBuffer, obj: Monster) {...}
GenerateJvmStaticAnnotation(writer, options.gen_jvmstatic);
GenerateFunOneLine(
writer, "asRoot", "buffer: ReadWriteBuffer, obj: {{gr_name}}",
struct_name, [&]() {
writer +=
"obj.init(buffer.getInt(buffer.limit) + buffer.limit, buffer)";
});
}
void GenerateStaticConstructor(const StructDef &struct_def, CodeWriter &code,
const IDLOptions options) const {
// create a struct constructor function
auto params = StructConstructorParams(struct_def);
GenerateFun(
code, namer_.LegacyJavaMethod2("create", struct_def, ""), params,
"Offset<" + namer_.Type(struct_def) + '>',
[&]() {
GenStructBody(struct_def, code, "");
code += "return Offset(builder.offset())";
},
options.gen_jvmstatic);
}
std::string StructConstructorParams(const StructDef &struct_def,
const std::string &prefix = "") const {
// builder: FlatBufferBuilder
std::stringstream out;
auto field_vec = struct_def.fields.vec;
if (prefix.empty()) { out << "builder: FlatBufferBuilder"; }
for (auto it = field_vec.begin(); it != field_vec.end(); ++it) {
auto &field = **it;
if (IsStruct(field.value.type)) {
// Generate arguments for a struct inside a struct. To ensure
// names don't clash, and to make it obvious these arguments are
// constructing a nested struct, prefix the name with the field
// name.
out << StructConstructorParams(*field.value.type.struct_def,
prefix + (namer_.Variable(field) + "_"));
} else {
out << ", " << prefix << namer_.Variable(field) << ": "
<< GenType(field.value.type);
}
}
return out.str();
}
static void GenerateVarGetterSetterOneLine(CodeWriter &writer,
const std::string &name,
const std::string &type,
const std::string &getter,
const std::string &setter) {
// Generates Kotlin getter for properties
// e.g.:
// val prop: Mytype
// get() = {
// return x
// }
writer.SetValue("name", name);
writer.SetValue("type", type);
writer += "var {{name}} : {{type}}";
writer.IncrementIdentLevel();
writer += "get() = " + getter;
writer += "set(value) = " + setter;
writer.DecrementIdentLevel();
}
static void GeneratePropertyOneLine(CodeWriter &writer,
const std::string &name,
const std::string &type,
const std::function<void()> &body) {
// Generates Kotlin getter for properties
// e.g.:
// val prop: Mytype = x
writer.SetValue("_name", name);
writer.SetValue("_type", type);
writer += "val {{_name}} : {{_type}} = \\";
body();
}
static void GenerateGetterOneLine(CodeWriter &writer, const std::string &name,
const std::string &type,
const std::function<void()> &body) {
// Generates Kotlin getter for properties
// e.g.:
// val prop: Mytype get() = x
writer.SetValue("_name", name);
writer.SetValue("_type", type);
writer += "val {{_name}} : {{_type}} get() = \\";
body();
}
static void GenerateGetter(CodeWriter &writer, const std::string &name,
const std::string &type,
const std::function<void()> &body) {
// Generates Kotlin getter for properties
// e.g.:
// val prop: Mytype
// get() = {
// return x
// }
writer.SetValue("name", name);
writer.SetValue("type", type);
writer += "val {{name}} : {{type}}";
writer.IncrementIdentLevel();
writer += "get() {";
writer.IncrementIdentLevel();
body();
writer.DecrementIdentLevel();
writer += "}";
writer.DecrementIdentLevel();
}
static void GenerateFun(CodeWriter &writer, const std::string &name,
const std::string &params,
const std::string &returnType,
const std::function<void()> &body,
bool gen_jvmstatic = false) {
// Generates Kotlin function
// e.g.:
// fun path(j: Int): Vec3 {
// return path(Vec3(), j)
// }
auto noreturn = returnType.empty();
writer.SetValue("name", name);
writer.SetValue("params", params);
writer.SetValue("return_type", noreturn ? "" : ": " + returnType);
GenerateJvmStaticAnnotation(writer, gen_jvmstatic);
writer += "fun {{name}}({{params}}) {{return_type}} {";
writer.IncrementIdentLevel();
body();
writer.DecrementIdentLevel();
writer += "}";
}
static void GenerateFunOneLine(CodeWriter &writer, const std::string &name,
const std::string &params,
const std::string &returnType,
const std::function<void()> &body,
bool gen_jvmstatic = false) {
// Generates Kotlin function
// e.g.:
// fun path(j: Int): Vec3 = return path(Vec3(), j)
auto ret = returnType.empty() ? "" : " : " + returnType;
GenerateJvmStaticAnnotation(writer, gen_jvmstatic);
writer += "fun " + name + "(" + params + ")" + ret + " = \\";
body();
}
static void GenerateOverrideFun(CodeWriter &writer, const std::string &name,
const std::string &params,
const std::string &returnType,
const std::function<void()> &body) {
// Generates Kotlin function
// e.g.:
// override fun path(j: Int): Vec3 = return path(Vec3(), j)
writer += "override \\";
GenerateFun(writer, name, params, returnType, body);
}
static void GenerateOverrideFunOneLine(CodeWriter &writer,
const std::string &name,
const std::string &params,
const std::string &returnType,
const std::string &statement) {
// Generates Kotlin function
// e.g.:
// override fun path(j: Int): Vec3 = return path(Vec3(), j)
writer.SetValue("name", name);
writer.SetValue("params", params);
writer.SetValue("return_type",
returnType.empty() ? "" : " : " + returnType);
writer += "override fun {{name}}({{params}}){{return_type}} = \\";
writer += statement;
}
static std::string LookupFieldOneLine(const std::string &offset,
const std::string &found,
const std::string &not_found) {
return "lookupField(" + offset + ", " + not_found + " ) { " + found + " }";
}
static std::string Indirect(const std::string &index, bool fixed) {
// We apply indirect() and struct is not fixed.
if (!fixed) return "indirect(" + index + ")";
return index;
}
static std::string NotFoundReturn(BaseType el) {
switch (el) {
case BASE_TYPE_FLOAT: return "0.0f";
case BASE_TYPE_DOUBLE: return "0.0";
case BASE_TYPE_BOOL: return "false";
case BASE_TYPE_LONG:
case BASE_TYPE_INT:
case BASE_TYPE_CHAR:
case BASE_TYPE_SHORT: return "0";
case BASE_TYPE_UINT:
case BASE_TYPE_UCHAR:
case BASE_TYPE_USHORT:
case BASE_TYPE_UTYPE: return "0u";
case BASE_TYPE_ULONG: return "0uL";
default: return "null";
}
}
// Prepend @JvmStatic to methods in companion object.
static void GenerateJvmStaticAnnotation(CodeWriter &code,
bool gen_jvmstatic) {
if (gen_jvmstatic) { code += "@JvmStatic"; }
}
const IdlNamer namer_;
};
} // namespace kotlin
static bool GenerateKotlinKMP(const Parser &parser, const std::string &path,
const std::string &file_name) {
kotlin::KotlinKMPGenerator generator(parser, path, file_name);
return generator.generate();
}
namespace {
class KotlinKMPCodeGenerator : public CodeGenerator {
public:
Status GenerateCode(const Parser &parser, const std::string &path,
const std::string &filename) override {
if (!GenerateKotlinKMP(parser, path, filename)) { return Status::ERROR; }
return Status::OK;
}
Status GenerateCode(const uint8_t *, int64_t,
const CodeGenOptions &) override {
return Status::NOT_IMPLEMENTED;
}
Status GenerateMakeRule(const Parser &parser, const std::string &path,
const std::string &filename,
std::string &output) override {
(void)parser;
(void)path;
(void)filename;
(void)output;
return Status::NOT_IMPLEMENTED;
}
Status GenerateGrpcCode(const Parser &parser, const std::string &path,
const std::string &filename) override {
(void)parser;
(void)path;
(void)filename;
return Status::NOT_IMPLEMENTED;
}
Status GenerateRootFile(const Parser &parser,
const std::string &path) override {
(void)parser;
(void)path;
return Status::NOT_IMPLEMENTED;
}
bool IsSchemaOnly() const override { return true; }
bool SupportsBfbsGeneration() const override { return false; }
bool SupportsRootFileGeneration() const override { return false; }
IDLOptions::Language Language() const override {
return IDLOptions::kKotlinKmp;
}
std::string LanguageName() const override { return "Kotlin"; }
};
} // namespace
std::unique_ptr<CodeGenerator> NewKotlinKMPCodeGenerator() {
return std::unique_ptr<KotlinKMPCodeGenerator>(new KotlinKMPCodeGenerator());
}
} // namespace flatbuffers
Reference in New Issue Copy Permalink