1 /*
2 * Copyright 2014 Google Inc. All rights reserved.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 // independent from idl_parser, since this code is not needed for most clients
18
19 #include "flatbuffers/code_generators.h"
20 #include "flatbuffers/flatbuffers.h"
21 #include "flatbuffers/idl.h"
22 #include "flatbuffers/util.h"
23 #include "idl_namer.h"
24
25 namespace flatbuffers {
26 namespace java {
27
28 namespace {
29
JavaDefaultConfig()30 static Namer::Config JavaDefaultConfig() {
31 return {
32 /*types=*/Case::kKeep,
33 /*constants=*/Case::kScreamingSnake,
34 /*methods=*/Case::kLowerCamel,
35 /*functions=*/Case::kLowerCamel,
36 /*fields=*/Case::kLowerCamel,
37 /*variables=*/Case::kLowerCamel,
38 /*variants=*/Case::kKeep,
39 /*enum_variant_seperator=*/".",
40 /*escape_keywords=*/Namer::Config::Escape::AfterConvertingCase,
41 /*namespaces=*/Case::kKeep,
42 /*namespace_seperator=*/".",
43 /*object_prefix=*/"",
44 /*object_suffix=*/"T",
45 /*keyword_prefix=*/"",
46 /*keyword_suffix=*/"_",
47 /*filenames=*/Case::kKeep,
48 /*directories=*/Case::kKeep,
49 /*output_path=*/"",
50 /*filename_suffix=*/"_generated",
51 /*filename_extension=*/".java",
52 };
53 }
54
JavaKeywords()55 static std::set<std::string> JavaKeywords() {
56 return {
57 "abstract", "continue", "for", "new", "switch",
58 "assert", "default", "goto", "package", "synchronized",
59 "boolean", "do", "if", "private", "this",
60 "break", "double", "implements", "protected", "throw",
61 "byte", "else", "import", "public", "throws",
62 "case", "enum", "instanceof", "return", "transient",
63 "catch", "extends", "int", "short", "try",
64 "char", "final", "interface", "static", "void",
65 "class", "finally", "long", "strictfp", "volatile",
66 "const", "float", "native", "super", "while",
67 };
68 }
69
70 static const TypedFloatConstantGenerator JavaFloatGen("Double.", "Float.", "NaN",
71 "POSITIVE_INFINITY",
72 "NEGATIVE_INFINITY");
73
74 static const CommentConfig comment_config = {
75 "/**",
76 " *",
77 " */",
78 };
79
80 } // namespace
81
82 class JavaGenerator : public BaseGenerator {
83 struct FieldArrayLength {
84 std::string name;
85 int length;
86 };
87
88 public:
JavaGenerator(const Parser & parser,const std::string & path,const std::string & file_name)89 JavaGenerator(const Parser &parser, const std::string &path,
90 const std::string &file_name)
91 : BaseGenerator(parser, path, file_name, "", ".", "java"),
92 cur_name_space_(nullptr),
93 namer_(WithFlagOptions(JavaDefaultConfig(), parser.opts, path),
94 JavaKeywords()) {}
95
96 JavaGenerator &operator=(const JavaGenerator &);
generate()97 bool generate() {
98 std::string one_file_code;
99 cur_name_space_ = parser_.current_namespace_;
100
101 for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
102 ++it) {
103 std::string enumcode;
104 auto &enum_def = **it;
105 if (!parser_.opts.one_file) cur_name_space_ = enum_def.defined_namespace;
106 GenEnum(enum_def, enumcode);
107 if (parser_.opts.one_file) {
108 one_file_code += enumcode;
109 } else {
110 if (!SaveType(enum_def.name, *enum_def.defined_namespace, enumcode,
111 /* needs_includes= */ false))
112 return false;
113 }
114
115 if (parser_.opts.generate_object_based_api && enum_def.is_union) {
116 enumcode = "";
117 GenEnum_ObjectAPI(enum_def, enumcode);
118 auto class_name = namer_.Type(enum_def) + "Union";
119 if (parser_.opts.one_file) {
120 one_file_code += enumcode;
121 } else {
122 if (!SaveType(class_name, *enum_def.defined_namespace, enumcode,
123 /* needs_includes= */ false))
124 return false;
125 }
126 }
127 }
128
129 for (auto it = parser_.structs_.vec.begin();
130 it != parser_.structs_.vec.end(); ++it) {
131 std::string declcode;
132 auto &struct_def = **it;
133 if (!parser_.opts.one_file)
134 cur_name_space_ = struct_def.defined_namespace;
135 GenStruct(struct_def, declcode, parser_.opts);
136 if (parser_.opts.one_file) {
137 one_file_code += declcode;
138 } else {
139 if (!SaveType(struct_def.name, *struct_def.defined_namespace, declcode,
140 /* needs_includes= */ true))
141 return false;
142 }
143
144 if (parser_.opts.generate_object_based_api) {
145 declcode = "";
146 GenStruct_ObjectAPI(struct_def, declcode);
147 auto class_name = namer_.ObjectType(struct_def);
148 if (parser_.opts.one_file) {
149 one_file_code += declcode;
150 } else {
151 if (!SaveType(class_name, *struct_def.defined_namespace, declcode,
152 /* needs_includes= */ true))
153 return false;
154 }
155 }
156 }
157
158 if (parser_.opts.one_file) {
159 return SaveType(file_name_, *parser_.current_namespace_, one_file_code,
160 /* needs_includes= */ true);
161 }
162 return true;
163 }
164
165 // Save out the generated code for a single class while adding
166 // declaration boilerplate.
SaveType(const std::string & defname,const Namespace & ns,const std::string & classcode,bool needs_includes) const167 bool SaveType(const std::string &defname, const Namespace &ns,
168 const std::string &classcode, bool needs_includes) const {
169 if (!classcode.length()) return true;
170
171 std::string code;
172 code = "// " + std::string(FlatBuffersGeneratedWarning()) + "\n\n";
173
174 const std::string namespace_name = FullNamespace(".", ns);
175 if (!namespace_name.empty()) {
176 code += "package " + namespace_name + ";";
177 code += "\n\n";
178 }
179 if (needs_includes) {
180 code +=
181 "import java.nio.*;\nimport java.lang.*;\nimport "
182 "java.util.*;\nimport com.google.flatbuffers.*;\n";
183 if (parser_.opts.gen_nullable) {
184 code += "\nimport javax.annotation.Nullable;\n";
185 }
186 if (parser_.opts.java_checkerframework) {
187 code += "\nimport org.checkerframework.dataflow.qual.Pure;\n";
188 }
189 code += "\n";
190 }
191
192 code += classcode;
193 if (!namespace_name.empty()) code += "";
194 const std::string dirs = namer_.Directories(ns);
195 EnsureDirExists(dirs);
196 const std::string filename =
197 dirs + namer_.File(defname, /*skips=*/SkipFile::Suffix);
198 return SaveFile(filename.c_str(), code, false);
199 }
200
CurrentNameSpace() const201 const Namespace *CurrentNameSpace() const { return cur_name_space_; }
202
GenNullableAnnotation(const Type & t) const203 std::string GenNullableAnnotation(const Type &t) const {
204 return parser_.opts.gen_nullable &&
205 !IsScalar(DestinationType(t, true).base_type) &&
206 t.base_type != BASE_TYPE_VECTOR
207 ? " @Nullable "
208 : "";
209 }
210
GenPureAnnotation(const Type & t) const211 std::string GenPureAnnotation(const Type &t) const {
212 return parser_.opts.java_checkerframework &&
213 !IsScalar(DestinationType(t, true).base_type)
214 ? " @Pure "
215 : "";
216 }
217
GenTypeBasic(const Type & type) const218 std::string GenTypeBasic(const Type &type) const {
219 // clang-format off
220 static const char * const java_typename[] = {
221 #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, ...) \
222 #JTYPE,
223 FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
224 #undef FLATBUFFERS_TD
225 };
226 // clang-format on
227 return java_typename[type.base_type];
228 }
229
GenTypePointer(const Type & type) const230 std::string GenTypePointer(const Type &type) const {
231 switch (type.base_type) {
232 case BASE_TYPE_STRING: return "String";
233 case BASE_TYPE_VECTOR: return GenTypeGet(type.VectorType());
234 case BASE_TYPE_STRUCT: return namer_.NamespacedType(*type.struct_def);
235 case BASE_TYPE_UNION: FLATBUFFERS_FALLTHROUGH(); // else fall thru
236 default: return "Table";
237 }
238 }
239
GenTypeGet(const Type & type) const240 std::string GenTypeGet(const Type &type) const {
241 return IsScalar(type.base_type)
242 ? GenTypeBasic(type)
243 : (IsArray(type) ? GenTypeGet(type.VectorType())
244 : GenTypePointer(type));
245 }
246
247 // Find the destination type the user wants to receive the value in (e.g.
248 // one size higher signed types for unsigned serialized values in Java).
DestinationType(const Type & type,bool vectorelem) const249 Type DestinationType(const Type &type, bool vectorelem) const {
250 switch (type.base_type) {
251 // We use int for both uchar/ushort, since that generally means less
252 // casting than using short for uchar.
253 case BASE_TYPE_UCHAR: return Type(BASE_TYPE_INT);
254 case BASE_TYPE_USHORT: return Type(BASE_TYPE_INT);
255 case BASE_TYPE_UINT: return Type(BASE_TYPE_LONG);
256 case BASE_TYPE_ARRAY:
257 case BASE_TYPE_VECTOR:
258 if (vectorelem) return DestinationType(type.VectorType(), vectorelem);
259 FLATBUFFERS_FALLTHROUGH(); // else fall thru
260 default: return type;
261 }
262 }
263
GenOffsetType() const264 std::string GenOffsetType() const { return "int"; }
265
GenOffsetConstruct(const std::string & variable_name) const266 std::string GenOffsetConstruct(const std::string &variable_name) const {
267 return variable_name;
268 }
269
GenVectorOffsetType() const270 std::string GenVectorOffsetType() const { return "int"; }
271
272 // Generate destination type name
GenTypeNameDest(const Type & type) const273 std::string GenTypeNameDest(const Type &type) const {
274 return GenTypeGet(DestinationType(type, true));
275 }
276
277 // Mask to turn serialized value into destination type value.
DestinationMask(const Type & type,bool vectorelem) const278 std::string DestinationMask(const Type &type, bool vectorelem) const {
279 switch (type.base_type) {
280 case BASE_TYPE_UCHAR: return " & 0xFF";
281 case BASE_TYPE_USHORT: return " & 0xFFFF";
282 case BASE_TYPE_UINT: return " & 0xFFFFFFFFL";
283 case BASE_TYPE_VECTOR:
284 if (vectorelem) return DestinationMask(type.VectorType(), vectorelem);
285 FLATBUFFERS_FALLTHROUGH(); // else fall thru
286 default: return "";
287 }
288 }
289
290 // Casts necessary to correctly read serialized data
DestinationCast(const Type & type) const291 std::string DestinationCast(const Type &type) const {
292 if (IsSeries(type)) {
293 return DestinationCast(type.VectorType());
294 } else {
295 // Cast necessary to correctly read serialized unsigned values.
296 if (type.base_type == BASE_TYPE_UINT) return "(long)";
297 }
298 return "";
299 }
300
301 // Cast statements for mutator method parameters.
302 // In Java, parameters representing unsigned numbers need to be cast down to
303 // their respective type. For example, a long holding an unsigned int value
304 // would be cast down to int before being put onto the buffer.
SourceCast(const Type & type,bool castFromDest) const305 std::string SourceCast(const Type &type, bool castFromDest) const {
306 if (IsSeries(type)) {
307 return SourceCast(type.VectorType(), castFromDest);
308 } else {
309 if (castFromDest) {
310 if (type.base_type == BASE_TYPE_UINT)
311 return "(int) ";
312 else if (type.base_type == BASE_TYPE_USHORT)
313 return "(short) ";
314 else if (type.base_type == BASE_TYPE_UCHAR)
315 return "(byte) ";
316 }
317 }
318 return "";
319 }
320
SourceCast(const Type & type) const321 std::string SourceCast(const Type &type) const {
322 return SourceCast(type, true);
323 }
324
SourceCastBasic(const Type & type,bool castFromDest) const325 std::string SourceCastBasic(const Type &type, bool castFromDest) const {
326 return IsScalar(type.base_type) ? SourceCast(type, castFromDest) : "";
327 }
328
SourceCastBasic(const Type & type) const329 std::string SourceCastBasic(const Type &type) const {
330 return SourceCastBasic(type, true);
331 }
332
GenEnumDefaultValue(const FieldDef & field) const333 std::string GenEnumDefaultValue(const FieldDef &field) const {
334 auto &value = field.value;
335 FLATBUFFERS_ASSERT(value.type.enum_def);
336 auto &enum_def = *value.type.enum_def;
337 auto enum_val = enum_def.FindByValue(value.constant);
338 return enum_val ? namer_.NamespacedEnumVariant(enum_def, *enum_val)
339 : value.constant;
340 }
341
GenDefaultValue(const FieldDef & field) const342 std::string GenDefaultValue(const FieldDef &field) const {
343 auto &value = field.value;
344 auto constant = field.IsScalarOptional() ? "0" : value.constant;
345 auto longSuffix = "L";
346 switch (value.type.base_type) {
347 case BASE_TYPE_BOOL: return constant == "0" ? "false" : "true";
348 case BASE_TYPE_ULONG: {
349 // Converts the ulong into its bits signed equivalent
350 uint64_t defaultValue = StringToUInt(constant.c_str());
351 return NumToString(static_cast<int64_t>(defaultValue)) + longSuffix;
352 }
353 case BASE_TYPE_UINT:
354 case BASE_TYPE_LONG: return constant + longSuffix;
355 default:
356 if (IsFloat(value.type.base_type)) {
357 if (field.IsScalarOptional()) {
358 return value.type.base_type == BASE_TYPE_DOUBLE ? "0.0" : "0f";
359 }
360 return JavaFloatGen.GenFloatConstant(field);
361 } else {
362 return constant;
363 }
364 }
365 }
366
GenDefaultValueBasic(const FieldDef & field) const367 std::string GenDefaultValueBasic(const FieldDef &field) const {
368 auto &value = field.value;
369 if (!IsScalar(value.type.base_type)) { return "0"; }
370 return GenDefaultValue(field);
371 }
372
GenEnum(EnumDef & enum_def,std::string & code) const373 void GenEnum(EnumDef &enum_def, std::string &code) const {
374 if (enum_def.generated) return;
375
376 // Generate enum definitions of the form:
377 // public static (final) int name = value;
378 // In Java, we use ints rather than the Enum feature, because we want them
379 // to map directly to how they're used in C/C++ and file formats.
380 // That, and Java Enums are expensive, and not universally liked.
381 GenComment(enum_def.doc_comment, &code, &comment_config);
382
383 code += "@SuppressWarnings(\"unused\")\n";
384 if (enum_def.attributes.Lookup("private")) {
385 // For Java, we leave the enum unmarked to indicate package-private
386 } else {
387 code += "public ";
388 }
389 code += "final class " + namer_.Type(enum_def);
390 code += " {\n";
391 code += " private " + namer_.Type(enum_def) + "() { }\n";
392 for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
393 auto &ev = **it;
394 GenComment(ev.doc_comment, &code, &comment_config, " ");
395 code += " public static final ";
396 code += GenTypeBasic(DestinationType(enum_def.underlying_type, false));
397 code += " ";
398 code += namer_.Variant(ev) + " = ";
399 code += enum_def.ToString(ev);
400 code += ";\n";
401 }
402
403 // Generate a string table for enum values.
404 // Problem is, if values are very sparse that could generate really big
405 // tables. Ideally in that case we generate a map lookup instead, but for
406 // the moment we simply don't output a table at all.
407 auto range = enum_def.Distance();
408 // Average distance between values above which we consider a table
409 // "too sparse". Change at will.
410 static const uint64_t kMaxSparseness = 5;
411 if (range / static_cast<uint64_t>(enum_def.size()) < kMaxSparseness &&
412 GenTypeBasic(DestinationType(enum_def.underlying_type, false)) !=
413 "long") {
414 code += "\n public static final String";
415 code += "[] names = { ";
416 const EnumVal *prev = enum_def.Vals().front();
417 for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end();
418 ++it) {
419 const EnumVal &ev = **it;
420 for (auto k = enum_def.Distance(prev, &ev); k > 1; --k)
421 code += "\"\", ";
422 prev = &ev;
423 code += "\"" + namer_.Variant(ev) + "\", ";
424 }
425 code += "};\n\n";
426 code += " public static ";
427 code += "String";
428 code += " name";
429 code += "(int e) { return names[e";
430 if (enum_def.MinValue()->IsNonZero())
431 code += " - " + namer_.Variant(enum_def.MinValue()->name);
432 code += "]; }\n";
433 }
434
435 // Close the class
436 code += "}\n\n";
437 }
438
439 // Returns the function name that is able to read a value of the given type.
GenGetter(const Type & type) const440 std::string GenGetter(const Type &type) const {
441 switch (type.base_type) {
442 case BASE_TYPE_STRING: return "__string";
443 case BASE_TYPE_STRUCT: return "__struct";
444 case BASE_TYPE_UNION: return "__union";
445 case BASE_TYPE_VECTOR: return GenGetter(type.VectorType());
446 case BASE_TYPE_ARRAY: return GenGetter(type.VectorType());
447 default: {
448 std::string getter = "bb.get";
449 if (type.base_type == BASE_TYPE_BOOL) {
450 getter = "0!=" + getter;
451 } else if (GenTypeBasic(type) != "byte") {
452 getter += ConvertCase(GenTypeBasic(type), Case::kUpperCamel);
453 }
454 return getter;
455 }
456 }
457 }
458
459 // Returns the function name that is able to read a value of the given type.
GenGetterForLookupByKey(flatbuffers::FieldDef * key_field,const std::string & data_buffer,const char * num=nullptr) const460 std::string GenGetterForLookupByKey(flatbuffers::FieldDef *key_field,
461 const std::string &data_buffer,
462 const char *num = nullptr) const {
463 auto type = key_field->value.type;
464 auto dest_mask = DestinationMask(type, true);
465 auto dest_cast = DestinationCast(type);
466 auto getter = data_buffer + ".get";
467 if (GenTypeBasic(type) != "byte") {
468 getter += ConvertCase(GenTypeBasic(type), Case::kUpperCamel);
469 }
470 getter = dest_cast + getter + "(" + GenOffsetGetter(key_field, num) + ")" +
471 dest_mask;
472 return getter;
473 }
474
475 // Direct mutation is only allowed for scalar fields.
476 // Hence a setter method will only be generated for such fields.
GenSetter(const Type & type) const477 std::string GenSetter(const Type &type) const {
478 if (IsScalar(type.base_type)) {
479 std::string setter = "bb.put";
480 if (GenTypeBasic(type) != "byte" && type.base_type != BASE_TYPE_BOOL) {
481 setter += ConvertCase(GenTypeBasic(type), Case::kUpperCamel);
482 }
483 return setter;
484 } else {
485 return "";
486 }
487 }
488
489 // Returns the method name for use with add/put calls.
GenMethod(const Type & type) const490 std::string GenMethod(const Type &type) const {
491 return IsScalar(type.base_type)
492 ? ConvertCase(GenTypeBasic(type), Case::kUpperCamel)
493 : (IsStruct(type) ? "Struct" : "Offset");
494 }
495
496 // Recursively generate arguments for a constructor, to deal with nested
497 // structs.
GenStructArgs(const StructDef & struct_def,std::string & code,const char * nameprefix,size_t array_count=0) const498 void GenStructArgs(const StructDef &struct_def, std::string &code,
499 const char *nameprefix, size_t array_count = 0) const {
500 for (auto it = struct_def.fields.vec.begin();
501 it != struct_def.fields.vec.end(); ++it) {
502 auto &field = **it;
503 const auto &field_type = field.value.type;
504 const auto array_field = IsArray(field_type);
505 const auto &type = array_field ? field_type.VectorType()
506 : DestinationType(field_type, false);
507 const auto array_cnt = array_field ? (array_count + 1) : array_count;
508 if (IsStruct(type)) {
509 // Generate arguments for a struct inside a struct. To ensure names
510 // don't clash, and to make it obvious these arguments are constructing
511 // a nested struct, prefix the name with the field name.
512 GenStructArgs(*field_type.struct_def, code,
513 (nameprefix + (field.name + "_")).c_str(), array_cnt);
514 } else {
515 code += ", ";
516 code += GenTypeNameDest(field.value.type);
517 for (size_t i = 0; i < array_cnt; i++) code += "[]";
518 code += " ";
519 code += nameprefix;
520 code += namer_.Field(field);
521 }
522 }
523 }
524
525 // Recusively generate struct construction statements of the form:
526 // builder.putType(name);
527 // and insert manual padding.
GenStructBody(const StructDef & struct_def,std::string & code,const char * nameprefix,size_t index=0,bool in_array=false) const528 void GenStructBody(const StructDef &struct_def, std::string &code,
529 const char *nameprefix, size_t index = 0,
530 bool in_array = false) const {
531 std::string indent((index + 1) * 2, ' ');
532 code += indent + " builder.prep(";
533 code += NumToString(struct_def.minalign) + ", ";
534 code += NumToString(struct_def.bytesize) + ");\n";
535 for (auto it = struct_def.fields.vec.rbegin();
536 it != struct_def.fields.vec.rend(); ++it) {
537 auto &field = **it;
538 const auto &field_type = field.value.type;
539 if (field.padding) {
540 code += indent + " builder.pad(";
541 code += NumToString(field.padding) + ");\n";
542 }
543 if (IsStruct(field_type)) {
544 GenStructBody(*field_type.struct_def, code,
545 (nameprefix + (field.name + "_")).c_str(), index,
546 in_array);
547 } else {
548 const auto &type =
549 IsArray(field_type) ? field_type.VectorType() : field_type;
550 const auto index_var = "_idx" + NumToString(index);
551 if (IsArray(field_type)) {
552 code += indent + " for (int " + index_var + " = ";
553 code += NumToString(field_type.fixed_length);
554 code += "; " + index_var + " > 0; " + index_var + "--) {\n";
555 in_array = true;
556 }
557 if (IsStruct(type)) {
558 GenStructBody(*field_type.struct_def, code,
559 (nameprefix + (field.name + "_")).c_str(), index + 1,
560 in_array);
561 } else {
562 code += IsArray(field_type) ? " " : "";
563 code += indent + " builder.put";
564 code += GenMethod(type) + "(";
565 code += SourceCast(type);
566 auto argname = nameprefix + namer_.Variable(field);
567 code += argname;
568 size_t array_cnt = index + (IsArray(field_type) ? 1 : 0);
569 for (size_t i = 0; in_array && i < array_cnt; i++) {
570 code += "[_idx" + NumToString(i) + "-1]";
571 }
572 code += ");\n";
573 }
574 if (IsArray(field_type)) { code += indent + " }\n"; }
575 }
576 }
577 }
578
GenOffsetGetter(flatbuffers::FieldDef * key_field,const char * num=nullptr) const579 std::string GenOffsetGetter(flatbuffers::FieldDef *key_field,
580 const char *num = nullptr) const {
581 std::string key_offset = "";
582 key_offset += "__offset(" + NumToString(key_field->value.offset) + ", ";
583 if (num) {
584 key_offset += num;
585 key_offset += ", _bb)";
586 } else {
587 key_offset += "bb.capacity()";
588 key_offset += " - tableOffset, bb)";
589 }
590 return key_offset;
591 }
592
GenLookupKeyGetter(flatbuffers::FieldDef * key_field) const593 std::string GenLookupKeyGetter(flatbuffers::FieldDef *key_field) const {
594 std::string key_getter = " ";
595 key_getter += "int tableOffset = ";
596 key_getter += "__indirect(vectorLocation + 4 * (start + middle)";
597 key_getter += ", bb);\n ";
598 if (IsString(key_field->value.type)) {
599 key_getter += "int comp = ";
600 key_getter += "compareStrings(";
601 key_getter += GenOffsetGetter(key_field);
602 key_getter += ", byteKey, bb);\n";
603 } else {
604 auto get_val = GenGetterForLookupByKey(key_field, "bb");
605 key_getter += GenTypeNameDest(key_field->value.type) + " val = ";
606 key_getter += get_val + ";\n";
607 key_getter += " int comp = val > key ? 1 : val < key ? -1 : 0;\n";
608 }
609 return key_getter;
610 }
611
GenKeyGetter(flatbuffers::FieldDef * key_field) const612 std::string GenKeyGetter(flatbuffers::FieldDef *key_field) const {
613 std::string key_getter = "";
614 auto data_buffer = "_bb";
615 if (IsString(key_field->value.type)) {
616 key_getter += " return ";
617 key_getter += "";
618 key_getter += "compareStrings(";
619 key_getter += GenOffsetGetter(key_field, "o1") + ", ";
620 key_getter += GenOffsetGetter(key_field, "o2") + ", " + data_buffer + ")";
621 key_getter += ";";
622 } else {
623 auto field_getter = GenGetterForLookupByKey(key_field, data_buffer, "o1");
624 key_getter +=
625 "\n " + GenTypeNameDest(key_field->value.type) + " val_1 = ";
626 key_getter +=
627 field_getter + ";\n " + GenTypeNameDest(key_field->value.type);
628 key_getter += " val_2 = ";
629 field_getter = GenGetterForLookupByKey(key_field, data_buffer, "o2");
630 key_getter += field_getter + ";\n";
631 key_getter += " return val_1 > val_2 ? 1 : val_1 < val_2 ? -1 : 0;\n ";
632 }
633 return key_getter;
634 }
635
GenStruct(StructDef & struct_def,std::string & code,const IDLOptions & opts) const636 void GenStruct(StructDef &struct_def, std::string &code,
637 const IDLOptions &opts) const {
638 if (struct_def.generated) return;
639
640 // Generate a struct accessor class, with methods of the form:
641 // public type name() { return bb.getType(i + offset); }
642 // or for tables of the form:
643 // public type name() {
644 // int o = __offset(offset); return o != 0 ? bb.getType(o + i) : default;
645 // }
646 GenComment(struct_def.doc_comment, &code, &comment_config);
647
648 if (parser_.opts.gen_generated) {
649 code += "@javax.annotation.Generated(value=\"flatc\")\n";
650 }
651 code += "@SuppressWarnings(\"unused\")\n";
652 if (struct_def.attributes.Lookup("private")) {
653 // For Java, we leave the struct unmarked to indicate package-private
654 } else {
655 code += "public ";
656 }
657 const auto struct_class = namer_.Type(struct_def);
658 code += "final class " + struct_class;
659 code += " extends ";
660 code += struct_def.fixed ? "Struct" : "Table";
661 code += " {\n";
662
663 if (!struct_def.fixed) {
664 // Generate verson check method.
665 // Force compile time error if not using the same version runtime.
666 code += " public static void ValidateVersion() {";
667 code += " Constants.";
668 code += "FLATBUFFERS_2_0_0(); ";
669 code += "}\n";
670
671 // Generate a special accessor for the table that when used as the root
672 // of a FlatBuffer
673 const std::string method_name =
674 namer_.LegacyJavaMethod2("getRootAs", struct_def, "");
675 const std::string method_signature =
676 " public static " + struct_class + " " + method_name;
677
678 // create convenience method that doesn't require an existing object
679 code += method_signature + "(ByteBuffer _bb) ";
680 code +=
681 "{ return " + method_name + "(_bb, new " + struct_class + "()); }\n";
682
683 // create method that allows object reuse
684 code +=
685 method_signature + "(ByteBuffer _bb, " + struct_class + " obj) { ";
686 code += "_bb.order(ByteOrder.LITTLE_ENDIAN); ";
687 code += "return (obj.__assign(_bb.getInt(_bb.";
688 code += "position()";
689 code += ") + _bb.";
690 code += "position()";
691 code += ", _bb)); }\n";
692 if (parser_.root_struct_def_ == &struct_def) {
693 if (parser_.file_identifier_.length()) {
694 // Check if a buffer has the identifier.
695 code += " public static ";
696 code += "boolean " +
697 namer_.LegacyJavaMethod2(
698 "", struct_def, "BufferHasIdentifier(ByteBuffer _bb)") +
699 " { return ";
700 code += "__has_identifier(_bb, \"";
701 code += parser_.file_identifier_;
702 code += "\"); }\n";
703 }
704 }
705 }
706 // Generate the __init method that sets the field in a pre-existing
707 // accessor object. This is to allow object reuse.
708 code += " public void __init(int _i, ByteBuffer _bb) ";
709 code += "{ ";
710 code += "__reset(_i, _bb); ";
711 code += "}\n";
712 code += " public " + struct_class + " __assign(int _i, ByteBuffer _bb) ";
713 code += "{ __init(_i, _bb); return this; }\n\n";
714 for (auto it = struct_def.fields.vec.begin();
715 it != struct_def.fields.vec.end(); ++it) {
716 auto &field = **it;
717 if (field.deprecated) continue;
718 GenComment(field.doc_comment, &code, &comment_config, " ");
719 const std::string type_name = GenTypeGet(field.value.type);
720 const std::string type_name_dest = GenTypeNameDest(field.value.type);
721 const std::string dest_mask = DestinationMask(field.value.type, true);
722 const std::string dest_cast = DestinationCast(field.value.type);
723 const std::string src_cast = SourceCast(field.value.type);
724 const std::string method_start =
725 " public " +
726 (field.IsRequired() ? "" : GenNullableAnnotation(field.value.type)) +
727 GenPureAnnotation(field.value.type) + type_name_dest + " " +
728 namer_.Field(field);
729 const std::string obj = "obj";
730
731 // Most field accessors need to retrieve and test the field offset first,
732 // this is the prefix code for that:
733 auto offset_prefix =
734 IsArray(field.value.type)
735 ? " { return "
736 : (" { int o = __offset(" + NumToString(field.value.offset) +
737 "); return o != 0 ? ");
738 // Generate the accessors that don't do object reuse.
739 if (field.value.type.base_type == BASE_TYPE_STRUCT) {
740 // Calls the accessor that takes an accessor object with a new object.
741 code += method_start + "() { return ";
742 code += namer_.Field(field);
743 code += "(new ";
744 code += type_name + "()); }\n";
745 } else if (IsSeries(field.value.type) &&
746 field.value.type.element == BASE_TYPE_STRUCT) {
747 // Accessors for vectors of structs also take accessor objects, this
748 // generates a variant without that argument.
749 code += method_start + "(int j) { return ";
750 code += namer_.Field(field);
751 code += "(new " + type_name + "(), j); }\n";
752 }
753
754 if (field.IsScalarOptional()) { code += GenOptionalScalarCheck(field); }
755 std::string getter = dest_cast + GenGetter(field.value.type);
756 code += method_start;
757 std::string member_suffix = "; ";
758 if (IsScalar(field.value.type.base_type)) {
759 code += "()";
760 member_suffix += "";
761 if (struct_def.fixed) {
762 code += " { return " + getter;
763 code += "(bb_pos + ";
764 code += NumToString(field.value.offset) + ")";
765 code += dest_mask;
766 } else {
767 code += offset_prefix + getter;
768 code += "(o + bb_pos)" + dest_mask;
769 code += " : ";
770 code += GenDefaultValue(field);
771 }
772 } else {
773 switch (field.value.type.base_type) {
774 case BASE_TYPE_STRUCT:
775 code += "(" + type_name + " obj)";
776 if (struct_def.fixed) {
777 code += " { return " + obj + ".__assign(";
778 code += "bb_pos + " + NumToString(field.value.offset) + ", ";
779 code += "bb)";
780 } else {
781 code += offset_prefix;
782 code += obj + ".__assign(";
783 code += field.value.type.struct_def->fixed
784 ? "o + bb_pos"
785 : "__indirect(o + bb_pos)";
786 code += ", bb) : null";
787 }
788 break;
789 case BASE_TYPE_STRING:
790 code += "()";
791 member_suffix += "";
792 code += offset_prefix + getter + "(o + ";
793 code += "bb_pos) : null";
794 break;
795 case BASE_TYPE_ARRAY: FLATBUFFERS_FALLTHROUGH(); // fall thru
796 case BASE_TYPE_VECTOR: {
797 auto vectortype = field.value.type.VectorType();
798 code += "(";
799 if (vectortype.base_type == BASE_TYPE_STRUCT) {
800 code += type_name + " obj, ";
801 getter = obj + ".__assign";
802 } else if (vectortype.base_type == BASE_TYPE_UNION) {
803 code += type_name + " obj, ";
804 }
805 code += "int j)";
806 const auto body = offset_prefix + getter + "(";
807 if (vectortype.base_type == BASE_TYPE_UNION) {
808 code += body + "obj, ";
809 } else {
810 code += body;
811 }
812 std::string index;
813 if (IsArray(field.value.type)) {
814 index += "bb_pos + " + NumToString(field.value.offset) + " + ";
815 } else {
816 index += "__vector(o) + ";
817 }
818 index += "j * " + NumToString(InlineSize(vectortype));
819 if (vectortype.base_type == BASE_TYPE_STRUCT) {
820 code += vectortype.struct_def->fixed
821 ? index
822 : "__indirect(" + index + ")";
823 code += ", bb";
824 } else {
825 code += index;
826 }
827 code += ")" + dest_mask;
828 if (!IsArray(field.value.type)) {
829 code += " : ";
830 code += field.value.type.element == BASE_TYPE_BOOL
831 ? "false"
832 : (IsScalar(field.value.type.element) ? "0" : "null");
833 }
834
835 break;
836 }
837 case BASE_TYPE_UNION:
838 code += "(" + type_name + " obj)" + offset_prefix + getter;
839 code += "(obj, o + bb_pos) : null";
840 break;
841 default: FLATBUFFERS_ASSERT(0);
842 }
843 }
844 code += member_suffix;
845 code += "}\n";
846 if (IsVector(field.value.type)) {
847 code += " public int " + namer_.Field(field);
848 code += "Length";
849 code += "()";
850 code += offset_prefix;
851 code += "__vector_len(o) : 0; ";
852 code += "";
853 code += "}\n";
854 // See if we should generate a by-key accessor.
855 if (field.value.type.element == BASE_TYPE_STRUCT &&
856 !field.value.type.struct_def->fixed) {
857 auto &sd = *field.value.type.struct_def;
858 auto &fields = sd.fields.vec;
859 for (auto kit = fields.begin(); kit != fields.end(); ++kit) {
860 auto &key_field = **kit;
861 if (key_field.key) {
862 auto qualified_name = namer_.NamespacedType(sd);
863 code += " public " + qualified_name + " ";
864 code += namer_.Method(field) + "ByKey(";
865 code += GenTypeNameDest(key_field.value.type) + " key)";
866 code += offset_prefix;
867 code += qualified_name + ".__lookup_by_key(";
868 code += "null, ";
869 code += "__vector(o), key, ";
870 code += "bb) : null; ";
871 code += "}\n";
872 code += " public " + qualified_name + " ";
873 code += namer_.Method(field) + "ByKey(";
874 code += qualified_name + " obj, ";
875 code += GenTypeNameDest(key_field.value.type) + " key)";
876 code += offset_prefix;
877 code += qualified_name + ".__lookup_by_key(obj, ";
878 code += "__vector(o), key, ";
879 code += "bb) : null; ";
880 code += "}\n";
881 break;
882 }
883 }
884 }
885 }
886 // Generate the accessors for vector of structs with vector access object
887 if (IsVector(field.value.type)) {
888 std::string vector_type_name;
889 const auto &element_base_type = field.value.type.VectorType().base_type;
890 if (IsScalar(element_base_type)) {
891 vector_type_name =
892 ConvertCase(type_name, Case::kUpperCamel) + "Vector";
893 } else if (element_base_type == BASE_TYPE_STRING) {
894 vector_type_name = "StringVector";
895 } else if (element_base_type == BASE_TYPE_UNION) {
896 vector_type_name = "UnionVector";
897 } else {
898 vector_type_name = type_name + ".Vector";
899 }
900 auto vector_method_start = GenNullableAnnotation(field.value.type) +
901 " public " + vector_type_name + " " +
902 namer_.Field(field, "vector");
903 code += vector_method_start + "() { return ";
904 code += namer_.Field(field, "vector");
905 code += "(new " + vector_type_name + "()); }\n";
906 code += vector_method_start + "(" + vector_type_name + " obj)";
907 code += offset_prefix + obj + ".__assign(";
908 code += "__vector(o), ";
909 if (!IsScalar(element_base_type)) {
910 auto vectortype = field.value.type.VectorType();
911 code += NumToString(InlineSize(vectortype)) + ", ";
912 }
913 code += "bb) : null" + member_suffix + "}\n";
914 }
915 // Generate a ByteBuffer accessor for strings & vectors of scalars.
916 if ((IsVector(field.value.type) &&
917 IsScalar(field.value.type.VectorType().base_type)) ||
918 IsString(field.value.type)) {
919 code += " public ByteBuffer ";
920 code += namer_.Field(field);
921 code += "AsByteBuffer() { return ";
922 code += "__vector_as_bytebuffer(";
923 code += NumToString(field.value.offset) + ", ";
924 code += NumToString(IsString(field.value.type)
925 ? 1
926 : InlineSize(field.value.type.VectorType()));
927 code += "); }\n";
928 code += " public ByteBuffer ";
929 code += namer_.Field(field);
930 code += "InByteBuffer(ByteBuffer _bb) { return ";
931 code += "__vector_in_bytebuffer(_bb, ";
932 code += NumToString(field.value.offset) + ", ";
933 code += NumToString(IsString(field.value.type)
934 ? 1
935 : InlineSize(field.value.type.VectorType()));
936 code += "); }\n";
937 }
938 // generate object accessors if is nested_flatbuffer
939 if (field.nested_flatbuffer) {
940 auto nested_type_name = namer_.NamespacedType(*field.nested_flatbuffer);
941 auto nested_method_name =
942 namer_.Field(field) + "As" + field.nested_flatbuffer->name;
943 auto get_nested_method_name = nested_method_name;
944 code += " public " + nested_type_name + " ";
945 code += nested_method_name + "() { return ";
946 code +=
947 get_nested_method_name + "(new " + nested_type_name + "()); }\n";
948 code += " public " + nested_type_name + " ";
949 code += get_nested_method_name + "(";
950 code += nested_type_name + " obj";
951 code += ") { int o = __offset(";
952 code += NumToString(field.value.offset) + "); ";
953 code += "return o != 0 ? " + obj + ".__assign(";
954 code += "";
955 code += "__indirect(__vector(o)), ";
956 code += "bb) : null; }\n";
957 }
958 // Generate mutators for scalar fields or vectors of scalars.
959 if (parser_.opts.mutable_buffer) {
960 auto is_series = (IsSeries(field.value.type));
961 const auto &underlying_type =
962 is_series ? field.value.type.VectorType() : field.value.type;
963 // Boolean parameters have to be explicitly converted to byte
964 // representation.
965 auto setter_parameter = underlying_type.base_type == BASE_TYPE_BOOL
966 ? "(byte)(" + field.name + " ? 1 : 0)"
967 : field.name;
968 // A vector mutator also needs the index of the vector element it should
969 // mutate.
970 auto mutator_params = (is_series ? "(int j, " : "(") +
971 GenTypeNameDest(underlying_type) + " " +
972 field.name + ") { ";
973 auto setter_index =
974 is_series
975 ? (IsArray(field.value.type)
976 ? "bb_pos + " + NumToString(field.value.offset)
977 : "__vector(o)") +
978 +" + j * " + NumToString(InlineSize(underlying_type))
979 : (struct_def.fixed
980 ? "bb_pos + " + NumToString(field.value.offset)
981 : "o + bb_pos");
982 if (IsScalar(underlying_type.base_type) && !IsUnion(field.value.type)) {
983 code += " public ";
984 code += struct_def.fixed ? "void " : "boolean ";
985 code += namer_.Method("mutate", field);
986 code += mutator_params;
987 if (struct_def.fixed) {
988 code += GenSetter(underlying_type) + "(" + setter_index + ", ";
989 code += src_cast + setter_parameter + "); }\n";
990 } else {
991 code += "int o = __offset(";
992 code += NumToString(field.value.offset) + ");";
993 code += " if (o != 0) { " + GenSetter(underlying_type);
994 code += "(" + setter_index + ", " + src_cast + setter_parameter +
995 "); return true; } else { return false; } }\n";
996 }
997 }
998 }
999 if (parser_.opts.java_primitive_has_method &&
1000 IsScalar(field.value.type.base_type) && !struct_def.fixed) {
1001 auto vt_offset_constant = " public static final int VT_" +
1002 namer_.Constant(field) + " = " +
1003 NumToString(field.value.offset) + ";";
1004
1005 code += vt_offset_constant;
1006 code += "\n";
1007 }
1008 }
1009 code += "\n";
1010 auto struct_has_create = false;
1011 std::set<flatbuffers::FieldDef *> field_has_create_set;
1012 flatbuffers::FieldDef *key_field = nullptr;
1013 if (struct_def.fixed) {
1014 struct_has_create = true;
1015 // create a struct constructor function
1016 code += " public static " + GenOffsetType() + " ";
1017 code += "create";
1018 code += struct_class + "(FlatBufferBuilder builder";
1019 GenStructArgs(struct_def, code, "");
1020 code += ") {\n";
1021 GenStructBody(struct_def, code, "");
1022 code += " return ";
1023 code += GenOffsetConstruct("builder." + std::string("offset()"));
1024 code += ";\n }\n";
1025 } else {
1026 // Generate a method that creates a table in one go. This is only possible
1027 // when the table has no struct fields, since those have to be created
1028 // inline, and there's no way to do so in Java.
1029 bool has_no_struct_fields = true;
1030 int num_fields = 0;
1031 for (auto it = struct_def.fields.vec.begin();
1032 it != struct_def.fields.vec.end(); ++it) {
1033 auto &field = **it;
1034 if (field.deprecated) continue;
1035 if (IsStruct(field.value.type)) {
1036 has_no_struct_fields = false;
1037 } else {
1038 num_fields++;
1039 }
1040 }
1041 // JVM specifications restrict default constructor params to be < 255.
1042 // Longs and doubles take up 2 units, so we set the limit to be < 127.
1043 if (has_no_struct_fields && num_fields && num_fields < 127) {
1044 struct_has_create = true;
1045 // Generate a table constructor of the form:
1046 // public static int createName(FlatBufferBuilder builder, args...)
1047 code += " public static " + GenOffsetType() + " ";
1048 code += namer_.LegacyJavaMethod2("create", struct_def, "");
1049 code += "(FlatBufferBuilder builder";
1050 for (auto it = struct_def.fields.vec.begin();
1051 it != struct_def.fields.vec.end(); ++it) {
1052 auto &field = **it;
1053 auto field_name = namer_.Field(field);
1054 if (field.deprecated) continue;
1055 code += ",\n ";
1056 code += GenTypeBasic(DestinationType(field.value.type, false));
1057 code += " ";
1058 code += field_name;
1059 if (!IsScalar(field.value.type.base_type)) code += "Offset";
1060 }
1061 code += ") {\n builder.";
1062 code += "startTable(";
1063 code += NumToString(struct_def.fields.vec.size()) + ");\n";
1064 for (size_t size = struct_def.sortbysize ? sizeof(largest_scalar_t) : 1;
1065 size; size /= 2) {
1066 for (auto it = struct_def.fields.vec.rbegin();
1067 it != struct_def.fields.vec.rend(); ++it) {
1068 auto &field = **it;
1069 auto field_name = namer_.Field(field);
1070 if (!field.deprecated &&
1071 (!struct_def.sortbysize ||
1072 size == SizeOf(field.value.type.base_type))) {
1073 code += " " + struct_class + ".";
1074 code += namer_.Method("add", field) + "(builder, " + field_name;
1075 if (!IsScalar(field.value.type.base_type)) code += "Offset";
1076 code += ");\n";
1077 }
1078 }
1079 }
1080 code += " return " + struct_class + ".";
1081 code += namer_.LegacyJavaMethod2("end", struct_def, "");
1082 code += "(builder);\n }\n\n";
1083 }
1084 // Generate a set of static methods that allow table construction,
1085 // of the form:
1086 // public static void addName(FlatBufferBuilder builder, short name)
1087 // { builder.addShort(id, name, default); }
1088 // Unlike the Create function, these always work.
1089 code += " public static void start";
1090 code += struct_class;
1091 code += "(FlatBufferBuilder builder) { builder.";
1092 code += "startTable(";
1093 code += NumToString(struct_def.fields.vec.size()) + "); }\n";
1094 for (auto it = struct_def.fields.vec.begin();
1095 it != struct_def.fields.vec.end(); ++it) {
1096 auto &field = **it;
1097 if (field.deprecated) continue;
1098
1099 code += " public static void " + namer_.Method("add", field);
1100 code += "(FlatBufferBuilder builder, ";
1101 code += GenTypeBasic(DestinationType(field.value.type, false));
1102 auto argname = namer_.Field(field);
1103 if (!IsScalar(field.value.type.base_type)) argname += "Offset";
1104 code += " " + argname + ") { builder.add";
1105 code += GenMethod(field.value.type) + "(";
1106
1107 if (field.key) {
1108 // field has key attribute, so always need to exist
1109 // even if its value is equal to default.
1110 // Generated code will bypass default checking
1111 // resulting in { builder.addShort(name); slot(id); }
1112 key_field = &field;
1113 code += SourceCastBasic(field.value.type);
1114 code += argname;
1115 code += "); builder.slot(" +
1116 NumToString(it - struct_def.fields.vec.begin()) + "); }\n";
1117 } else {
1118 code += NumToString(it - struct_def.fields.vec.begin()) + ", ";
1119 code += SourceCastBasic(field.value.type);
1120 code += argname;
1121 code += ", ";
1122 code += SourceCastBasic(field.value.type);
1123 code += GenDefaultValue(field);
1124 code += "); }\n";
1125 }
1126 if (IsVector(field.value.type)) {
1127 auto vector_type = field.value.type.VectorType();
1128 auto alignment = InlineAlignment(vector_type);
1129 auto elem_size = InlineSize(vector_type);
1130 if (!IsStruct(vector_type)) {
1131 field_has_create_set.insert(&field);
1132 // generate a method to create a vector from a java array.
1133 if ((vector_type.base_type == BASE_TYPE_CHAR ||
1134 vector_type.base_type == BASE_TYPE_UCHAR)) {
1135 // Handle byte[] and ByteBuffers separately for Java
1136 code += " public static " + GenVectorOffsetType() + " ";
1137 code += namer_.Method("create", field);
1138 code += "Vector(FlatBufferBuilder builder, byte[] data) ";
1139 code += "{ return builder.createByteVector(data); }\n";
1140
1141 code += " public static " + GenVectorOffsetType() + " ";
1142 code += namer_.Method("create", field);
1143 code += "Vector(FlatBufferBuilder builder, ByteBuffer data) ";
1144 code += "{ return builder.createByteVector(data); }\n";
1145 } else {
1146 code += " public static " + GenVectorOffsetType() + " ";
1147 code += namer_.Method("create", field);
1148 code += "Vector(FlatBufferBuilder builder, ";
1149 code += GenTypeBasic(DestinationType(vector_type, false)) +
1150 "[] data) ";
1151 code += "{ builder.startVector(";
1152 code += NumToString(elem_size);
1153 code += ", data.length, ";
1154 code += NumToString(alignment);
1155 code += "); for (int i = data.";
1156 code += "length - 1; i >= 0; i--) builder.";
1157 code += "add";
1158 code += GenMethod(vector_type);
1159 code += "(";
1160 code += SourceCastBasic(vector_type);
1161 code += "data[i]";
1162 code += "); return ";
1163 code += "builder.endVector(); }\n";
1164 }
1165 }
1166 // Generate a method to start a vector, data to be added manually
1167 // after.
1168 code += " public static void " + namer_.Method("start", field);
1169 code += "Vector(FlatBufferBuilder builder, int numElems) ";
1170 code += "{ builder.startVector(";
1171 code += NumToString(elem_size);
1172 code += ", numElems, " + NumToString(alignment);
1173 code += "); }\n";
1174 }
1175 }
1176 code += " public static " + GenOffsetType() + " ";
1177 code += namer_.LegacyJavaMethod2("end", struct_def, "");
1178 code += "(FlatBufferBuilder builder) {\n int o = builder.";
1179 code += "endTable();\n";
1180 for (auto it = struct_def.fields.vec.begin();
1181 it != struct_def.fields.vec.end(); ++it) {
1182 auto &field = **it;
1183 if (!field.deprecated && field.IsRequired()) {
1184 code += " builder.required(o, ";
1185 code += NumToString(field.value.offset);
1186 code += "); // " + field.name + "\n";
1187 }
1188 }
1189 code += " return " + GenOffsetConstruct("o") + ";\n }\n";
1190 if (parser_.root_struct_def_ == &struct_def) {
1191 std::string size_prefix[] = { "", "SizePrefixed" };
1192 for (int i = 0; i < 2; ++i) {
1193 code += " public static void ";
1194 code += namer_.LegacyJavaMethod2("finish" + size_prefix[i],
1195 struct_def, "Buffer");
1196 code += "(FlatBufferBuilder builder, " + GenOffsetType();
1197 code += " offset) {";
1198 code += " builder.finish" + size_prefix[i] + "(offset";
1199
1200 if (parser_.file_identifier_.length())
1201 code += ", \"" + parser_.file_identifier_ + "\"";
1202 code += "); }\n";
1203 }
1204 }
1205 }
1206 // Only generate key compare function for table,
1207 // because `key_field` is not set for struct
1208 if (struct_def.has_key && !struct_def.fixed) {
1209 FLATBUFFERS_ASSERT(key_field);
1210 code += "\n @Override\n protected int keysCompare(";
1211 code += "Integer o1, Integer o2, ByteBuffer _bb) {";
1212 code += GenKeyGetter(key_field);
1213 code += " }\n";
1214
1215 code += "\n public static " + struct_class;
1216 code += " __lookup_by_key(";
1217 code += struct_class + " obj, ";
1218 code += "int vectorLocation, ";
1219 code += GenTypeNameDest(key_field->value.type);
1220 code += " key, ByteBuffer bb) {\n";
1221 if (IsString(key_field->value.type)) {
1222 code += " byte[] byteKey = ";
1223 code += "key.getBytes(java.nio.charset.StandardCharsets.UTF_8);\n";
1224 }
1225 code += " int span = ";
1226 code += "bb.getInt(vectorLocation - 4);\n";
1227 code += " int start = 0;\n";
1228 code += " while (span != 0) {\n";
1229 code += " int middle = span / 2;\n";
1230 code += GenLookupKeyGetter(key_field);
1231 code += " if (comp > 0) {\n";
1232 code += " span = middle;\n";
1233 code += " } else if (comp < 0) {\n";
1234 code += " middle++;\n";
1235 code += " start += middle;\n";
1236 code += " span -= middle;\n";
1237 code += " } else {\n";
1238 code += " return ";
1239 code += "(obj == null ? new " + struct_class + "() : obj)";
1240 code += ".__assign(tableOffset, bb);\n";
1241 code += " }\n }\n";
1242 code += " return null;\n";
1243 code += " }\n";
1244 }
1245 GenVectorAccessObject(struct_def, code);
1246 if (opts.generate_object_based_api) {
1247 GenPackUnPack_ObjectAPI(struct_def, code, opts, struct_has_create,
1248 field_has_create_set);
1249 }
1250 code += "}\n\n";
1251 }
1252
GenOptionalScalarCheck(FieldDef & field) const1253 std::string GenOptionalScalarCheck(FieldDef &field) const {
1254 if (!field.IsScalarOptional()) return "";
1255 return " public boolean " + namer_.Method("has", field) +
1256 "() { return 0 != __offset(" + NumToString(field.value.offset) +
1257 "); }\n";
1258 }
1259
GenVectorAccessObject(StructDef & struct_def,std::string & code) const1260 void GenVectorAccessObject(StructDef &struct_def, std::string &code) const {
1261 // Generate a vector of structs accessor class.
1262 code += "\n";
1263 code += " ";
1264 if (!struct_def.attributes.Lookup("private")) code += "public ";
1265 code += "static ";
1266 code += "final ";
1267 code += "class Vector extends ";
1268 code += "BaseVector {\n";
1269
1270 // Generate the __assign method that sets the field in a pre-existing
1271 // accessor object. This is to allow object reuse.
1272 std::string method_indent = " ";
1273 code += method_indent + "public Vector ";
1274 code += "__assign(int _vector, int _element_size, ByteBuffer _bb) { ";
1275 code += "__reset(_vector, _element_size, _bb); return this; }\n\n";
1276
1277 auto type_name = namer_.Type(struct_def);
1278 auto method_start = method_indent + "public " + type_name + " get";
1279 // Generate the accessors that don't do object reuse.
1280 code += method_start + "(int j) { return get";
1281 code += "(new " + type_name + "(), j); }\n";
1282 code += method_start + "(" + type_name + " obj, int j) { ";
1283 code += " return obj.__assign(";
1284 std::string index = "__element(j)";
1285 code += struct_def.fixed ? index : "__indirect(" + index + ", bb)";
1286 code += ", bb); }\n";
1287 // See if we should generate a by-key accessor.
1288 if (!struct_def.fixed) {
1289 auto &fields = struct_def.fields.vec;
1290 for (auto kit = fields.begin(); kit != fields.end(); ++kit) {
1291 auto &key_field = **kit;
1292 if (key_field.key) {
1293 auto nullable_annotation =
1294 parser_.opts.gen_nullable ? "@Nullable " : "";
1295 code += method_indent + nullable_annotation;
1296 code += "public " + type_name + " ";
1297 code += "getByKey(";
1298 code += GenTypeNameDest(key_field.value.type) + " key) { ";
1299 code += " return __lookup_by_key(null, ";
1300 code += "__vector(), key, ";
1301 code += "bb); ";
1302 code += "}\n";
1303 code += method_indent + nullable_annotation;
1304 code += "public " + type_name + " ";
1305 code += "getByKey(";
1306 code += type_name + " obj, ";
1307 code += GenTypeNameDest(key_field.value.type) + " key) { ";
1308 code += " return __lookup_by_key(obj, ";
1309 code += "__vector(), key, ";
1310 code += "bb); ";
1311 code += "}\n";
1312 break;
1313 }
1314 }
1315 }
1316 code += " }\n";
1317 }
1318
GenEnum_ObjectAPI(EnumDef & enum_def,std::string & code) const1319 void GenEnum_ObjectAPI(EnumDef &enum_def, std::string &code) const {
1320 if (enum_def.generated) return;
1321 code += "import com.google.flatbuffers.FlatBufferBuilder;\n\n";
1322
1323 if (!enum_def.attributes.Lookup("private")) { code += "public "; }
1324 auto union_name = namer_.Type(enum_def) + "Union";
1325 auto union_type =
1326 GenTypeBasic(DestinationType(enum_def.underlying_type, false));
1327 code += "class " + union_name + " {\n";
1328 // Type
1329 code += " private " + union_type + " type;\n";
1330 // Value
1331 code += " private Object value;\n";
1332 code += "\n";
1333 // getters and setters
1334 code += " public " + union_type + " getType() { return type; }\n\n";
1335 code += " public void setType(" + union_type +
1336 " type) { this.type = type; }\n\n";
1337 code += " public Object getValue() { return value; }\n\n";
1338 code += " public void setValue(Object value) { this.value = value; }\n\n";
1339 // Constructor
1340 code += " public " + union_name + "() {\n";
1341 code +=
1342 " this.type = " + namer_.EnumVariant(enum_def, *enum_def.Vals()[0]) +
1343 ";\n";
1344 code += " this.value = null;\n";
1345 code += " }\n\n";
1346 // As
1347 for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
1348 auto &ev = **it;
1349 if (ev.union_type.base_type == BASE_TYPE_NONE) continue;
1350 auto type_name = GenTypeGet_ObjectAPI(ev.union_type, false, true);
1351 if (ev.union_type.base_type == BASE_TYPE_STRUCT &&
1352 ev.union_type.struct_def->attributes.Lookup("private")) {
1353 code += " ";
1354 } else {
1355 code += " public ";
1356 }
1357 code += type_name + " as" + ev.name + "() { return (" + type_name +
1358 ") value; }\n";
1359 }
1360 code += "\n";
1361 // pack()
1362 code += " public static int pack(FlatBufferBuilder builder, " +
1363 union_name + " _o) {\n";
1364 code += " switch (_o.type) {\n";
1365 for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
1366 auto &ev = **it;
1367 if (ev.union_type.base_type == BASE_TYPE_NONE) {
1368 continue;
1369 } else {
1370 code += " case " + namer_.EnumVariant(enum_def, ev) + ": return ";
1371 if (IsString(ev.union_type)) {
1372 code += "builder.createString(_o.as" + ev.name + "());\n";
1373 } else {
1374 code += GenTypeGet(ev.union_type) + ".pack(builder, _o.as" + ev.name +
1375 "());\n";
1376 }
1377 }
1378 }
1379 code += " default: return 0;\n";
1380 code += " }\n";
1381 code += " }\n";
1382 code += "}\n\n";
1383 }
1384
GenUnionUnPack_ObjectAPI(const EnumDef & enum_def,std::string & code,const std::string & type_name,const std::string & field_name,bool is_vector) const1385 void GenUnionUnPack_ObjectAPI(const EnumDef &enum_def, std::string &code,
1386 const std::string &type_name,
1387 const std::string &field_name,
1388 bool is_vector) const {
1389 const std::string variable_type =
1390 is_vector ? type_name.substr(0, type_name.length() - 2) : type_name;
1391 const std::string variable_name =
1392 "_" + namer_.Variable("o", field_name) + (is_vector ? "Element" : "");
1393 const std::string type_params = is_vector ? "_j" : "";
1394 const std::string value_params = is_vector ? ", _j" : "";
1395 const std::string indent = (is_vector ? " " : " ");
1396
1397 code += indent + variable_type + " " + variable_name + " = new " +
1398 variable_type + "();\n";
1399 code += indent +
1400 GenTypeBasic(DestinationType(enum_def.underlying_type, false)) +
1401 " " + variable_name + "Type = " + field_name + "Type(" +
1402 type_params + ");\n";
1403 code += indent + variable_name + ".setType(" + variable_name + "Type);\n";
1404 code += indent + "Table " + variable_name + "Value;\n";
1405 code += indent + "switch (" + variable_name + "Type) {\n";
1406 for (auto eit = enum_def.Vals().begin(); eit != enum_def.Vals().end();
1407 ++eit) {
1408 auto &ev = **eit;
1409 if (ev.union_type.base_type == BASE_TYPE_NONE) {
1410 continue;
1411 } else {
1412 if (ev.union_type.base_type == BASE_TYPE_STRING ||
1413 (ev.union_type.base_type == BASE_TYPE_STRUCT &&
1414 ev.union_type.struct_def->fixed)) {
1415 continue; // This branch is due to bad implemantation of Unions in
1416 // Java which doesn't handle non Table types. Should be
1417 // deleted when issue #6561 is fixed.
1418 }
1419 code += indent + " case " +
1420 namer_.NamespacedEnumVariant(enum_def, ev) + ":\n";
1421 auto actual_type = GenTypeGet(ev.union_type);
1422 code += indent + " " + variable_name + "Value = " + field_name +
1423 "(new " + actual_type + "()" + value_params + ");\n";
1424 code += indent + " " + variable_name + ".setValue(" + variable_name +
1425 "Value != null ? ((" + actual_type + ") " + variable_name +
1426 "Value).unpack() : null);\n";
1427 code += indent + " break;\n";
1428 }
1429 }
1430 code += indent + " default: break;\n";
1431 code += indent + "}\n";
1432 if (is_vector) {
1433 code += indent + "_" + namer_.Variable("o", field_name) +
1434 "[_j] = " + variable_name + ";\n";
1435 }
1436 }
1437
GenPackUnPack_ObjectAPI(StructDef & struct_def,std::string & code,const IDLOptions & opts,bool struct_has_create,const std::set<FieldDef * > & field_has_create) const1438 void GenPackUnPack_ObjectAPI(
1439 StructDef &struct_def, std::string &code, const IDLOptions &opts,
1440 bool struct_has_create,
1441 const std::set<FieldDef *> &field_has_create) const {
1442 auto struct_name = namer_.ObjectType(struct_def);
1443 // unpack()
1444 code += " public " + struct_name + " unpack() {\n";
1445 code += " " + struct_name + " _o = new " + struct_name + "();\n";
1446 code += " unpackTo(_o);\n";
1447 code += " return _o;\n";
1448 code += " }\n";
1449 // unpackTo()
1450 code += " public void unpackTo(" + struct_name + " _o) {\n";
1451 for (auto it = struct_def.fields.vec.begin();
1452 it != struct_def.fields.vec.end(); ++it) {
1453 const auto &field = **it;
1454 if (field.deprecated) continue;
1455 if (field.value.type.base_type == BASE_TYPE_UTYPE) continue;
1456 if (field.value.type.element == BASE_TYPE_UTYPE) continue;
1457 const auto accessor = namer_.Method(field);
1458 const auto variable = "_" + namer_.Variable("o", field);
1459 const auto get_field = namer_.Method("get", field);
1460 const auto set_field = namer_.Method("set", field);
1461
1462 auto type_name = GenTypeGet_ObjectAPI(field.value.type, false, true);
1463 if (field.IsScalarOptional())
1464 type_name = ConvertPrimitiveTypeToObjectWrapper_ObjectAPI(type_name);
1465 auto start = " " + type_name + " " + variable + " = ";
1466 auto call_setter = true;
1467 switch (field.value.type.base_type) {
1468 case BASE_TYPE_STRUCT: {
1469 auto fixed = struct_def.fixed && field.value.type.struct_def->fixed;
1470 if (fixed) {
1471 code +=
1472 " " + accessor + "().unpackTo(_o." + get_field + "());\n";
1473 } else {
1474 code += " if (" + accessor + "() != null) ";
1475 if (field.value.type.struct_def->fixed) {
1476 code += accessor + "().unpackTo(_o." + get_field + "());\n";
1477 } else {
1478 code += "_o." + set_field + "(" + accessor + "().unpack());\n";
1479 }
1480 code += " else _o." + set_field + "(null);\n";
1481 }
1482 call_setter = false;
1483 break;
1484 }
1485 case BASE_TYPE_ARRAY: {
1486 auto length_str = NumToString(field.value.type.fixed_length);
1487 auto unpack_method =
1488 field.value.type.struct_def == nullptr ? "" : ".unpack()";
1489 code += start + "_o." + get_field + "();\n";
1490 code += " for (int _j = 0; _j < " + length_str + "; ++_j) { " +
1491 variable + "[_j] = " + accessor + "(_j)" + unpack_method +
1492 "; }\n";
1493 call_setter = false;
1494 break;
1495 }
1496 case BASE_TYPE_VECTOR:
1497 if (field.value.type.element == BASE_TYPE_UNION) {
1498 code += start + "new " +
1499 GenConcreteTypeGet_ObjectAPI(field.value.type)
1500 .substr(0, type_name.length() - 1) +
1501 accessor + "Length()];\n";
1502 code +=
1503 " for (int _j = 0; _j < " + accessor + "Length(); ++_j) {\n";
1504 GenUnionUnPack_ObjectAPI(*field.value.type.enum_def, code,
1505 type_name, accessor, true);
1506 code += " }\n";
1507 } else if (field.value.type.element != BASE_TYPE_UTYPE) {
1508 auto fixed = field.value.type.struct_def == nullptr;
1509 const auto length_accessor = namer_.Method(field, "length");
1510 code += start + "new " +
1511 GenConcreteTypeGet_ObjectAPI(field.value.type)
1512 .substr(0, type_name.length() - 1) +
1513 length_accessor + "()];\n";
1514 code +=
1515 " for (int _j = 0; _j < " + length_accessor + "(); ++_j) {";
1516 code += variable + "[_j] = ";
1517 if (fixed) {
1518 code += accessor + "(_j)";
1519 } else {
1520 code += "(" + accessor + "(_j) != null ? " + accessor +
1521 "(_j).unpack() : null)";
1522 }
1523 code += ";}\n";
1524 }
1525 break;
1526 case BASE_TYPE_UTYPE: break;
1527 case BASE_TYPE_UNION: {
1528 GenUnionUnPack_ObjectAPI(*field.value.type.enum_def, code, type_name,
1529 accessor, false);
1530 break;
1531 }
1532 default: {
1533 if (field.IsScalarOptional()) {
1534 code += start + namer_.Method("has", field) + "() ? " + accessor +
1535 "() : null;\n";
1536 } else {
1537 code += start + accessor + "();\n";
1538 }
1539 break;
1540 }
1541 }
1542 if (call_setter) {
1543 code += " _o." + set_field + "(" + variable + ");\n";
1544 }
1545 }
1546 code += " }\n";
1547 // pack()
1548 code += " public static " + GenOffsetType() +
1549 " pack(FlatBufferBuilder builder, " + struct_name + " _o) {\n";
1550 code += " if (_o == null) return 0;\n";
1551 for (auto it = struct_def.fields.vec.begin();
1552 it != struct_def.fields.vec.end(); ++it) {
1553 auto &field = **it;
1554 if (field.deprecated) continue;
1555 const auto field_name = namer_.Field(field);
1556 const auto variable = "_" + namer_.Variable("o", field);
1557 const auto get_field = namer_.Method("get", field);
1558 // pre
1559 switch (field.value.type.base_type) {
1560 case BASE_TYPE_STRUCT: {
1561 if (!field.value.type.struct_def->fixed) {
1562 code += " " + GenOffsetType() + " _" + namer_.Variable(field) +
1563 " = _o." + get_field +
1564 "() == null ? 0 : " + GenTypeGet(field.value.type) +
1565 ".pack(builder, _o." + get_field + "());\n";
1566 } else if (struct_def.fixed && struct_has_create) {
1567 std::vector<FieldArrayLength> array_lengths;
1568 FieldArrayLength tmp_array_length = {
1569 field.name,
1570 field.value.type.fixed_length,
1571 };
1572 array_lengths.push_back(tmp_array_length);
1573 GenStructPackDecl_ObjectAPI(*field.value.type.struct_def,
1574 array_lengths, code);
1575 }
1576 break;
1577 }
1578 case BASE_TYPE_STRING: {
1579 code += " int _" + field_name + " = _o." + get_field +
1580 "() == null ? 0 : "
1581 "builder.createString(_o." +
1582 get_field + "());\n";
1583 break;
1584 }
1585 case BASE_TYPE_VECTOR: {
1586 if (field_has_create.find(&field) != field_has_create.end()) {
1587 auto property_name = field_name;
1588 auto gen_for_loop = true;
1589 std::string array_name = "__" + field_name;
1590 std::string array_type = "";
1591 std::string element_type = "";
1592 std::string to_array = "";
1593 switch (field.value.type.element) {
1594 case BASE_TYPE_STRING: {
1595 array_type = "int";
1596 element_type = "String";
1597 to_array = "builder.createString(_e)";
1598 break;
1599 }
1600 case BASE_TYPE_STRUCT:
1601 array_type = "int";
1602 element_type =
1603 GenTypeGet_ObjectAPI(field.value.type, true, true);
1604 ;
1605 to_array = GenTypeGet(field.value.type) + ".pack(builder, _e)";
1606 break;
1607 case BASE_TYPE_UTYPE:
1608 property_name = field_name.substr(0, field_name.size() - 4);
1609 array_type = GenTypeBasic(DestinationType(
1610 field.value.type.enum_def->underlying_type, false));
1611 element_type = field.value.type.enum_def->name + "Union";
1612 to_array = "_o." + namer_.Method("get", property_name) +
1613 "()[_j].getType()";
1614 break;
1615 case BASE_TYPE_UNION:
1616 array_type = "int";
1617 element_type =
1618 namer_.NamespacedType(*field.value.type.enum_def) + "Union";
1619 to_array = element_type + ".pack(builder, _o." +
1620 namer_.Method("get", property_name) + "()[_j])";
1621 break;
1622 case BASE_TYPE_UCHAR: // TODO this branch of the switch is due to
1623 // inconsistent behavior in unsigned byte.
1624 // Read further at Issue #6574.
1625 array_type = "byte";
1626 element_type = "int";
1627 to_array = "(byte) _e";
1628 break;
1629 default:
1630 gen_for_loop = false;
1631 array_name = "_o." + namer_.Method("get", property_name) + "()";
1632 array_type = GenTypeNameDest(field.value.type);
1633 element_type = array_type;
1634 to_array = "_e";
1635 break;
1636 }
1637 code += " int _" + field_name + " = 0;\n";
1638 code += " if (_o." + namer_.Method("get", property_name) +
1639 "() != null) {\n";
1640 if (gen_for_loop) {
1641 code += " " + array_type + "[] " + array_name + " = new " +
1642 array_type + "[_o." +
1643 namer_.Method("get", property_name) + "().length];\n";
1644 code += " int _j = 0;\n";
1645 code += " for (" + element_type + " _e : _o." +
1646 namer_.Method("get", property_name) + "()) { ";
1647 code += array_name + "[_j] = " + to_array + "; _j++;}\n";
1648 }
1649 code += " _" + field_name + " = " +
1650 namer_.Method("create", field) + "Vector(builder, " +
1651 array_name + ");\n";
1652 code += " }\n";
1653 } else {
1654 auto type_name = GenTypeGet(field.value.type);
1655 auto element_type_name =
1656 GenTypeGet_ObjectAPI(field.value.type, true, true);
1657 auto pack_method =
1658 field.value.type.struct_def == nullptr
1659 ? "builder.add" + GenMethod(field.value.type.VectorType()) +
1660 "(" + variable + "[_j]);"
1661 : type_name + ".pack(builder, " + variable + "[_j]);";
1662 code += " int _" + field_name + " = 0;\n";
1663 code += " " + element_type_name + "[] " + variable + " = _o." +
1664 get_field + "();\n";
1665 code += " if (" + variable + " != null) {\n";
1666 code += " " + namer_.Method("start", field) +
1667 "Vector(builder, " + variable + ".length);\n";
1668 code += " for (int _j = " + variable +
1669 ".length - 1; _j >=0; _j--) { ";
1670 code += pack_method + "}\n";
1671 code += " _" + field_name + " = builder.endVector();\n";
1672 code += " }\n";
1673 }
1674 break;
1675 }
1676 case BASE_TYPE_ARRAY: {
1677 if (field.value.type.struct_def != nullptr) {
1678 std::vector<FieldArrayLength> array_lengths;
1679 FieldArrayLength tmp_array_length = {
1680 field.name,
1681 field.value.type.fixed_length,
1682 };
1683 array_lengths.push_back(tmp_array_length);
1684 GenStructPackDecl_ObjectAPI(*field.value.type.struct_def,
1685 array_lengths, code);
1686 } else {
1687 code += " " +
1688 GenTypeGet_ObjectAPI(field.value.type, false, true) + " _" +
1689 field_name + " = _o." + get_field + "();\n";
1690 }
1691 break;
1692 }
1693 case BASE_TYPE_UNION: {
1694 code += " " +
1695 GenTypeBasic(DestinationType(
1696 field.value.type.enum_def->underlying_type, false)) +
1697 " _" + field_name + "Type = _o." + get_field +
1698 "() == null ? " +
1699 namer_.NamespacedType(*field.value.type.enum_def) +
1700 ".NONE : " + "_o." + get_field + "().getType();\n";
1701 code += " " + GenOffsetType() + " _" + field_name + " = _o." +
1702 get_field + "() == null ? 0 : " +
1703 namer_.NamespacedType(*field.value.type.enum_def) +
1704 "Union.pack(builder, _o." + get_field + "());\n";
1705 break;
1706 }
1707 default: break;
1708 }
1709 }
1710 if (struct_has_create) {
1711 // Create
1712 code += " return " +
1713 namer_.LegacyJavaMethod2("create", struct_def, "") + "(\n";
1714 code += " builder";
1715 for (auto it = struct_def.fields.vec.begin();
1716 it != struct_def.fields.vec.end(); ++it) {
1717 auto &field = **it;
1718 if (field.deprecated) continue;
1719 const auto field_name = namer_.Field(field);
1720 const auto get_field = namer_.Method("get", field);
1721 switch (field.value.type.base_type) {
1722 case BASE_TYPE_STRUCT: {
1723 if (struct_def.fixed) {
1724 GenStructPackCall_ObjectAPI(*field.value.type.struct_def, code,
1725 " _" + field_name + "_");
1726 } else {
1727 code += ",\n";
1728 if (field.value.type.struct_def->fixed) {
1729 if (opts.generate_object_based_api)
1730 code += " _o." + field_name;
1731 else
1732 // Seems like unreachable code
1733 code += " " + GenTypeGet(field.value.type) +
1734 ".Pack(builder, _o." + field_name + ")";
1735 } else {
1736 code += " _" + field_name;
1737 }
1738 }
1739 break;
1740 }
1741 case BASE_TYPE_ARRAY: {
1742 if (field.value.type.struct_def != nullptr) {
1743 GenStructPackCall_ObjectAPI(*field.value.type.struct_def, code,
1744 " _" + field_name + "_");
1745 } else {
1746 code += ",\n";
1747 code += " _" + field_name;
1748 }
1749 break;
1750 }
1751 case BASE_TYPE_UNION: FLATBUFFERS_FALLTHROUGH(); // fall thru
1752 case BASE_TYPE_UTYPE: FLATBUFFERS_FALLTHROUGH(); // fall thru
1753 case BASE_TYPE_STRING: FLATBUFFERS_FALLTHROUGH(); // fall thru
1754 case BASE_TYPE_VECTOR: {
1755 code += ",\n";
1756 code += " _" + field_name;
1757 break;
1758 }
1759 default: // scalar
1760 code += ",\n";
1761 code += " _o." + get_field + "()";
1762 break;
1763 }
1764 }
1765 code += ");\n";
1766 } else {
1767 // Start, End
1768 code += " " + namer_.LegacyJavaMethod2("start", struct_def, "") +
1769 "(builder);\n";
1770 for (auto it = struct_def.fields.vec.begin();
1771 it != struct_def.fields.vec.end(); ++it) {
1772 auto &field = **it;
1773 if (field.deprecated) continue;
1774 const auto arg = "_" + namer_.Variable(field);
1775 const auto get_field = namer_.Method("get", field);
1776 const auto add_field = namer_.Method("add", field);
1777
1778 switch (field.value.type.base_type) {
1779 case BASE_TYPE_STRUCT: {
1780 if (field.value.type.struct_def->fixed) {
1781 code += " " + add_field + "(builder, " +
1782 GenTypeGet(field.value.type) + ".pack(builder, _o." +
1783 get_field + "()));\n";
1784 } else {
1785 code += " " + add_field + "(builder, " + arg + ");\n";
1786 }
1787 break;
1788 }
1789 case BASE_TYPE_STRING: FLATBUFFERS_FALLTHROUGH(); // fall thru
1790 case BASE_TYPE_ARRAY: FLATBUFFERS_FALLTHROUGH(); // fall thru
1791 case BASE_TYPE_VECTOR: {
1792 code += " " + add_field + "(builder, " + arg + ");\n";
1793 break;
1794 }
1795 case BASE_TYPE_UTYPE: break;
1796 case BASE_TYPE_UNION: {
1797 code += " " + add_field + "Type(builder, " + arg + "Type);\n";
1798 code += " " + add_field + "(builder, " + arg + ");\n";
1799 break;
1800 }
1801 // scalar
1802 default: {
1803 if (field.IsScalarOptional()) {
1804 code += " if (_o." + get_field + "() != null) { " + add_field +
1805 "(builder, _o." + get_field + "()); }\n";
1806 } else {
1807 code +=
1808 " " + add_field + "(builder, _o." + get_field + "());\n";
1809 }
1810 break;
1811 }
1812 }
1813 }
1814 code += " return " + namer_.LegacyJavaMethod2("end", struct_def, "") +
1815 "(builder);\n";
1816 }
1817 code += " }\n";
1818 }
1819
GenStructPackDecl_ObjectAPI(const StructDef & struct_def,std::vector<FieldArrayLength> & array_lengths,std::string & code) const1820 void GenStructPackDecl_ObjectAPI(const StructDef &struct_def,
1821 std::vector<FieldArrayLength> &array_lengths,
1822 std::string &code) const {
1823 for (auto it = struct_def.fields.vec.begin();
1824 it != struct_def.fields.vec.end(); ++it) {
1825 const FieldDef &field = **it;
1826 const bool is_array = IsArray(field.value.type);
1827 const Type &field_type =
1828 is_array ? field.value.type.VectorType() : field.value.type;
1829 FieldArrayLength tmp_array_length = {
1830 field.name,
1831 field_type.fixed_length,
1832 };
1833 array_lengths.push_back(tmp_array_length);
1834 if (field_type.struct_def != nullptr) {
1835 GenStructPackDecl_ObjectAPI(*field_type.struct_def, array_lengths,
1836 code);
1837 } else {
1838 std::vector<FieldArrayLength> array_only_lengths;
1839 for (size_t i = 0; i < array_lengths.size(); ++i) {
1840 if (array_lengths[i].length > 0) {
1841 array_only_lengths.push_back(array_lengths[i]);
1842 }
1843 }
1844 std::string name;
1845 for (size_t i = 0; i < array_lengths.size(); ++i) {
1846 name += "_" + namer_.Variable(array_lengths[i].name);
1847 }
1848 code += " " + GenTypeBasic(field_type);
1849 if (array_only_lengths.size() > 0) {
1850 for (size_t i = 0; i < array_only_lengths.size(); ++i) {
1851 code += "[]";
1852 }
1853 code += " " + name + " = ";
1854 code += "new " + GenTypeBasic(field_type) + "[";
1855 for (size_t i = 0; i < array_only_lengths.size(); ++i) {
1856 if (i != 0) { code += "]["; }
1857 code += NumToString(array_only_lengths[i].length);
1858 }
1859 code += "];\n";
1860 code += " ";
1861 // initialize array
1862 for (size_t i = 0; i < array_only_lengths.size(); ++i) {
1863 auto idx = "idx" + NumToString(i);
1864 code += "for (int " + idx + " = 0; " + idx + " < " +
1865 NumToString(array_only_lengths[i].length) + "; ++" + idx +
1866 ") {";
1867 }
1868 for (size_t i = 0; i < array_only_lengths.size(); ++i) {
1869 auto idx = "idx" + NumToString(i);
1870 if (i == 0) {
1871 code += name + "[" + idx;
1872 } else {
1873 code += "][" + idx;
1874 }
1875 }
1876 code += "] = _o";
1877 for (size_t i = 0, j = 0; i < array_lengths.size(); ++i) {
1878 code += "." + namer_.Method("get", array_lengths[i].name) + "()";
1879 if (array_lengths[i].length <= 0) continue;
1880 code += "[idx" + NumToString(j++) + "]";
1881 }
1882 code += ";";
1883 for (size_t i = 0; i < array_only_lengths.size(); ++i) {
1884 code += "}";
1885 }
1886 } else {
1887 code += " " + name + " = ";
1888 code += "_o";
1889 for (size_t i = 0; i < array_lengths.size(); ++i) {
1890 code += "." + namer_.Method("get", array_lengths[i].name) + "()";
1891 }
1892 code += ";";
1893 }
1894 code += "\n";
1895 }
1896 array_lengths.pop_back();
1897 }
1898 }
1899
GenStructPackCall_ObjectAPI(const StructDef & struct_def,std::string & code,std::string prefix) const1900 void GenStructPackCall_ObjectAPI(const StructDef &struct_def,
1901 std::string &code,
1902 std::string prefix) const {
1903 for (auto it = struct_def.fields.vec.begin();
1904 it != struct_def.fields.vec.end(); ++it) {
1905 auto &field = **it;
1906 const auto &field_type = field.value.type;
1907 if (field_type.struct_def != nullptr) {
1908 GenStructPackCall_ObjectAPI(*field_type.struct_def, code,
1909 prefix + namer_.Field(field) + "_");
1910 } else {
1911 code += ",\n";
1912 code += prefix + namer_.Field(field);
1913 }
1914 }
1915 }
1916
ConvertPrimitiveTypeToObjectWrapper_ObjectAPI(const std::string & type_name) const1917 std::string ConvertPrimitiveTypeToObjectWrapper_ObjectAPI(
1918 const std::string &type_name) const {
1919 if (type_name == "boolean")
1920 return "Boolean";
1921 else if (type_name == "byte")
1922 return "Byte";
1923 else if (type_name == "char")
1924 return "Character";
1925 else if (type_name == "short")
1926 return "Short";
1927 else if (type_name == "int")
1928 return "Integer";
1929 else if (type_name == "long")
1930 return "Long";
1931 else if (type_name == "float")
1932 return "Float";
1933 else if (type_name == "double")
1934 return "Double";
1935 return type_name;
1936 }
1937
GenTypeGet_ObjectAPI(const flatbuffers::Type & type,bool vectorelem,bool wrap_in_namespace) const1938 std::string GenTypeGet_ObjectAPI(const flatbuffers::Type &type,
1939 bool vectorelem,
1940 bool wrap_in_namespace) const {
1941 auto type_name = GenTypeNameDest(type);
1942 // Replace to ObjectBaseAPI Type Name
1943 switch (type.base_type) {
1944 case BASE_TYPE_STRUCT: FLATBUFFERS_FALLTHROUGH(); // fall thru
1945 case BASE_TYPE_ARRAY: FLATBUFFERS_FALLTHROUGH(); // fall thru
1946 case BASE_TYPE_VECTOR: {
1947 if (type.struct_def != nullptr) {
1948 auto type_name_length = type.struct_def->name.length();
1949 auto new_type_name = namer_.ObjectType(*type.struct_def);
1950 type_name.replace(type_name.length() - type_name_length,
1951 type_name_length, new_type_name);
1952 } else if (type.element == BASE_TYPE_UNION) {
1953 if (wrap_in_namespace) {
1954 type_name = namer_.NamespacedType(*type.enum_def) + "Union";
1955 } else {
1956 type_name = namer_.Type(*type.enum_def) + "Union";
1957 }
1958 }
1959 break;
1960 }
1961
1962 case BASE_TYPE_UNION: {
1963 if (wrap_in_namespace) {
1964 type_name = namer_.NamespacedType(*type.enum_def) + "Union";
1965 } else {
1966 type_name = namer_.Type(*type.enum_def) + "Union";
1967 }
1968 break;
1969 }
1970 default: break;
1971 }
1972 if (vectorelem) { return type_name; }
1973 switch (type.base_type) {
1974 case BASE_TYPE_ARRAY: FLATBUFFERS_FALLTHROUGH(); // fall thru
1975 case BASE_TYPE_VECTOR: {
1976 type_name = type_name + "[]";
1977 break;
1978 }
1979 default: break;
1980 }
1981 return type_name;
1982 }
1983
GenConcreteTypeGet_ObjectAPI(const flatbuffers::Type & type) const1984 std::string GenConcreteTypeGet_ObjectAPI(
1985 const flatbuffers::Type &type) const {
1986 auto type_name = GenTypeNameDest(type);
1987 // Replace to ObjectBaseAPI Type Name
1988 switch (type.base_type) {
1989 case BASE_TYPE_STRUCT: FLATBUFFERS_FALLTHROUGH(); // fall thru
1990 case BASE_TYPE_ARRAY: FLATBUFFERS_FALLTHROUGH(); // fall thru
1991 case BASE_TYPE_VECTOR: {
1992 if (type.struct_def != nullptr) {
1993 auto type_name_length = type.struct_def->name.length();
1994 auto new_type_name = namer_.ObjectType(*type.struct_def);
1995 type_name.replace(type_name.length() - type_name_length,
1996 type_name_length, new_type_name);
1997 } else if (type.element == BASE_TYPE_UNION) {
1998 type_name = namer_.NamespacedType(*type.enum_def) + "Union";
1999 }
2000 break;
2001 }
2002
2003 case BASE_TYPE_UNION: {
2004 type_name = namer_.NamespacedType(*type.enum_def) + "Union";
2005 break;
2006 }
2007 default: break;
2008 }
2009
2010 switch (type.base_type) {
2011 case BASE_TYPE_ARRAY: FLATBUFFERS_FALLTHROUGH(); // fall thru
2012 case BASE_TYPE_VECTOR: {
2013 type_name = type_name + "[]";
2014 break;
2015 }
2016 default: break;
2017 }
2018 return type_name;
2019 }
2020
GenStruct_ObjectAPI(const StructDef & struct_def,std::string & code) const2021 void GenStruct_ObjectAPI(const StructDef &struct_def,
2022 std::string &code) const {
2023 if (struct_def.generated) return;
2024 if (struct_def.attributes.Lookup("private")) {
2025 // For Java, we leave the enum unmarked to indicate package-private
2026 } else {
2027 code += "public ";
2028 }
2029
2030 const auto class_name = namer_.ObjectType(struct_def);
2031 code += "class " + class_name;
2032 code += " {\n";
2033 // Generate Properties
2034 for (auto it = struct_def.fields.vec.begin();
2035 it != struct_def.fields.vec.end(); ++it) {
2036 const auto &field = **it;
2037 if (field.deprecated) continue;
2038 if (field.value.type.base_type == BASE_TYPE_UTYPE) continue;
2039 if (field.value.type.element == BASE_TYPE_UTYPE) continue;
2040 auto type_name = GenTypeGet_ObjectAPI(field.value.type, false, true);
2041 if (field.IsScalarOptional())
2042 type_name = ConvertPrimitiveTypeToObjectWrapper_ObjectAPI(type_name);
2043 const auto field_name = namer_.Field(field);
2044 code += " private " + type_name + " " + field_name + ";\n";
2045 }
2046 // Generate Java getters and setters
2047 code += "\n";
2048 for (auto it = struct_def.fields.vec.begin();
2049 it != struct_def.fields.vec.end(); ++it) {
2050 const auto &field = **it;
2051 if (field.deprecated) continue;
2052 if (field.value.type.base_type == BASE_TYPE_UTYPE) continue;
2053 if (field.value.type.element == BASE_TYPE_UTYPE) continue;
2054 const auto field_name = namer_.Field(field);
2055 const auto get_field = namer_.Method("get", field);
2056 auto type_name = GenTypeGet_ObjectAPI(field.value.type, false, true);
2057 if (field.IsScalarOptional())
2058 type_name = ConvertPrimitiveTypeToObjectWrapper_ObjectAPI(type_name);
2059
2060 code += " public " + type_name + " " + get_field + "() { return " +
2061 field_name + "; }\n\n";
2062 std::string array_validation = "";
2063 if (field.value.type.base_type == BASE_TYPE_ARRAY) {
2064 array_validation =
2065 "if (" + field_name + " != null && " + field_name +
2066 ".length == " + NumToString(field.value.type.fixed_length) + ") ";
2067 }
2068 code += " public void " + namer_.Method("set", field) + "(" + type_name +
2069 " " + field_name + ") { " + array_validation + "this." +
2070 field_name + " = " + field_name + "; }\n\n";
2071 }
2072 // Generate Constructor
2073 code += "\n";
2074 code += " public " + class_name + "() {\n";
2075 for (auto it = struct_def.fields.vec.begin();
2076 it != struct_def.fields.vec.end(); ++it) {
2077 const auto &field = **it;
2078 if (field.deprecated) continue;
2079 if (field.value.type.base_type == BASE_TYPE_UTYPE) continue;
2080 if (field.value.type.element == BASE_TYPE_UTYPE) continue;
2081 const auto get_field = namer_.Method("get", field);
2082
2083 code += " this." + namer_.Field(field) + " = ";
2084 const auto type_name =
2085 GenTypeGet_ObjectAPI(field.value.type, false, true);
2086 if (IsScalar(field.value.type.base_type)) {
2087 if (field.IsScalarOptional()) {
2088 code += "null;\n";
2089 } else {
2090 code += GenDefaultValue(field) + ";\n";
2091 }
2092 } else {
2093 switch (field.value.type.base_type) {
2094 case BASE_TYPE_STRUCT: {
2095 if (IsStruct(field.value.type)) {
2096 code += "new " + type_name + "();\n";
2097 } else {
2098 code += "null;\n";
2099 }
2100 break;
2101 }
2102 case BASE_TYPE_ARRAY: {
2103 code += "new " + type_name.substr(0, type_name.length() - 1) +
2104 NumToString(field.value.type.fixed_length) + "];\n";
2105 break;
2106 }
2107 default: {
2108 code += "null;\n";
2109 break;
2110 }
2111 }
2112 }
2113 }
2114 code += " }\n";
2115 if (parser_.root_struct_def_ == &struct_def) {
2116 const std::string struct_type = namer_.Type(struct_def);
2117 code += " public static " + class_name +
2118 " deserializeFromBinary(byte[] fbBuffer) {\n";
2119 code += " return " + struct_type + "." +
2120 namer_.LegacyJavaMethod2("getRootAs", struct_def, "") +
2121 "(ByteBuffer.wrap(fbBuffer)).unpack();\n";
2122 code += " }\n";
2123 code += " public byte[] serializeToBinary() {\n";
2124 code += " FlatBufferBuilder fbb = new FlatBufferBuilder();\n";
2125 code += " " + struct_type + "." +
2126 namer_.LegacyJavaMethod2("finish", struct_def, "Buffer") +
2127 "(fbb, " + struct_type + ".pack(fbb, this));\n";
2128 code += " return fbb.sizedByteArray();\n";
2129 code += " }\n";
2130 }
2131 code += "}\n\n";
2132 }
2133
2134 // This tracks the current namespace used to determine if a type need to be
2135 // prefixed by its namespace
2136 const Namespace *cur_name_space_;
2137 const IdlNamer namer_;
2138 };
2139 } // namespace java
2140
GenerateJava(const Parser & parser,const std::string & path,const std::string & file_name)2141 bool GenerateJava(const Parser &parser, const std::string &path,
2142 const std::string &file_name) {
2143 java::JavaGenerator generator(parser, path, file_name);
2144 return generator.generate();
2145 }
2146
2147 } // namespace flatbuffers
2148