// Generate an accessor struct, builder structs & function for a table. static void GenTable(const Parser &parser, StructDef &struct_def, const GeneratorOptions &opts, std::string *code_ptr) { if (struct_def.generated) return; std::string &code = *code_ptr; // Generate an accessor struct, with methods of the form: // type name() const { return GetField<type>(offset, defaultval); } GenComment(struct_def.doc_comment, code_ptr); code += "struct " + struct_def.name; code += " FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table"; code += " {\n"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { auto &field = **it; if (!field.deprecated) { // Deprecated fields won't be accessible. GenComment(field.doc_comment, code_ptr, " "); code += " " + GenTypeGet(parser, field.value.type, " ", "const ", " *", true); code += field.name + "() const { return "; // Call a different accessor for pointers, that indirects. std::string call = IsScalar(field.value.type.base_type) ? "GetField<" : (IsStruct(field.value.type) ? "GetStruct<" : "GetPointer<"); call += GenTypeGet(parser, field.value.type, "", "const ", " *", false); call += ">(" + NumToString(field.value.offset); // Default value as second arg for non-pointer types. if (IsScalar(field.value.type.base_type)) call += ", " + field.value.constant; call += ")"; code += GenUnderlyingCast(parser, field, true, call); code += "; }\n"; auto nested = field.attributes.Lookup("nested_flatbuffer"); if (nested) { auto nested_root = parser.structs_.Lookup(nested->constant); assert(nested_root); // Guaranteed to exist by parser. code += " const " + nested_root->name + " *" + field.name; code += "_nested_root() const { return flatbuffers::GetRoot<"; code += nested_root->name + ">(" + field.name + "()->Data()); }\n"; } // Generate a comparison function for this field if it is a key. if (field.key) { code += " bool KeyCompareLessThan(const " + struct_def.name; code += " *o) const { return "; if (field.value.type.base_type == BASE_TYPE_STRING) code += "*"; code += field.name + "() < "; if (field.value.type.base_type == BASE_TYPE_STRING) code += "*"; code += "o->" + field.name + "(); }\n"; code += " int KeyCompareWithValue("; if (field.value.type.base_type == BASE_TYPE_STRING) { code += "const char *val) const { return strcmp(" + field.name; code += "()->c_str(), val); }\n"; } else { code += GenTypeBasic(parser, field.value.type, false); code += " val) const { return " + field.name + "() < val ? -1 : "; code += field.name + "() > val; }\n"; } } } } // Generate a verifier function that can check a buffer from an untrusted // source will never cause reads outside the buffer. code += " bool Verify(flatbuffers::Verifier &verifier) const {\n"; code += " return VerifyTableStart(verifier)"; std::string prefix = " &&\n "; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { auto &field = **it; if (!field.deprecated) { code += prefix + "VerifyField"; if (field.required) code += "Required"; code += "<" + GenTypeSize(parser, field.value.type); code += ">(verifier, " + NumToString(field.value.offset); code += " /* " + field.name + " */)"; switch (field.value.type.base_type) { case BASE_TYPE_UNION: code += prefix + "Verify" + field.value.type.enum_def->name; code += "(verifier, " + field.name + "(), " + field.name + "_type())"; break; case BASE_TYPE_STRUCT: if (!field.value.type.struct_def->fixed) { code += prefix + "verifier.VerifyTable(" + field.name; code += "())"; } break; case BASE_TYPE_STRING: code += prefix + "verifier.Verify(" + field.name + "())"; break; case BASE_TYPE_VECTOR: code += prefix + "verifier.Verify(" + field.name + "())"; switch (field.value.type.element) { case BASE_TYPE_STRING: { code += prefix + "verifier.VerifyVectorOfStrings(" + field.name; code += "())"; break; } case BASE_TYPE_STRUCT: { if (!field.value.type.struct_def->fixed) { code += prefix + "verifier.VerifyVectorOfTables(" + field.name; code += "())"; } break; } default: break; } break; default: break; } } } code += prefix + "verifier.EndTable()"; code += ";\n }\n"; code += "};\n\n"; // Generate a builder struct, with methods of the form: // void add_name(type name) { fbb_.AddElement<type>(offset, name, default); } code += "struct " + struct_def.name; code += "Builder {\n flatbuffers::FlatBufferBuilder &fbb_;\n"; code += " flatbuffers::uoffset_t start_;\n"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { auto &field = **it; if (!field.deprecated) { code += " void add_" + field.name + "("; code += GenTypeWire(parser, field.value.type, " ", true) + field.name; code += ") { fbb_.Add"; if (IsScalar(field.value.type.base_type)) { code += "Element<" + GenTypeWire(parser, field.value.type, "", false); code += ">"; } else if (IsStruct(field.value.type)) { code += "Struct"; } else { code += "Offset"; } code += "(" + NumToString(field.value.offset) + ", "; code += GenUnderlyingCast(parser, field, false, field.name); if (IsScalar(field.value.type.base_type)) code += ", " + field.value.constant; code += "); }\n"; } } code += " " + struct_def.name; code += "Builder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) "; code += "{ start_ = fbb_.StartTable(); }\n"; code += " " + struct_def.name + "Builder &operator=(const "; code += struct_def.name + "Builder &);\n"; code += " flatbuffers::Offset<" + struct_def.name; code += "> Finish() {\n auto o = flatbuffers::Offset<" + struct_def.name; code += ">(fbb_.EndTable(start_, "; code += NumToString(struct_def.fields.vec.size()) + "));\n"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { auto &field = **it; if (!field.deprecated && field.required) { code += " fbb_.Required(o, " + NumToString(field.value.offset); code += "); // " + field.name + "\n"; } } code += " return o;\n }\n};\n\n"; // Generate a convenient CreateX function that uses the above builder // to create a table in one go. code += "inline flatbuffers::Offset<" + struct_def.name + "> Create"; code += struct_def.name; code += "(flatbuffers::FlatBufferBuilder &_fbb"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { auto &field = **it; if (!field.deprecated) { code += ",\n " + GenTypeWire(parser, field.value.type, " ", true); code += field.name + " = "; if (field.value.type.enum_def && IsScalar(field.value.type.base_type)) { auto ev = field.value.type.enum_def->ReverseLookup( static_cast<int>(StringToInt(field.value.constant.c_str())), false); if (ev) { code += WrapInNameSpace(parser, field.value.type.enum_def->defined_namespace, GenEnumVal(*field.value.type.enum_def, *ev, opts)); } else { code += GenUnderlyingCast(parser, field, true, field.value.constant); } } else { code += field.value.constant; } } } code += ") {\n " + struct_def.name + "Builder builder_(_fbb);\n"; for (size_t size = struct_def.sortbysize ? sizeof(largest_scalar_t) : 1; size; size /= 2) { for (auto it = struct_def.fields.vec.rbegin(); it != struct_def.fields.vec.rend(); ++it) { auto &field = **it; if (!field.deprecated && (!struct_def.sortbysize || size == SizeOf(field.value.type.base_type))) { code += " builder_.add_" + field.name + "(" + field.name + ");\n"; } } } code += " return builder_.Finish();\n}\n\n"; }
// Generate an accessor struct, builder structs & function for a table. static void GenTable(StructDef &struct_def, std::string *code_ptr) { if (struct_def.generated) return; std::string &code = *code_ptr; // Generate an accessor struct, with methods of the form: // type name() const { return GetField<type>(offset, defaultval); } GenComment(struct_def.doc_comment, code_ptr); code += "struct " + struct_def.name + " : private flatbuffers::Table"; code += " {\n"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { auto &field = **it; if (!field.deprecated) { // Deprecated fields won't be accessible. GenComment(field.doc_comment, code_ptr, " "); code += " " + GenTypeGet(field.value.type, " ", "const ", " *"); code += field.name + "() const { return "; // Call a different accessor for pointers, that indirects. code += IsScalar(field.value.type.base_type) ? "GetField<" : (IsStruct(field.value.type) ? "GetStruct<" : "GetPointer<"); code += GenTypeGet(field.value.type, "", "const ", " *") + ">("; code += NumToString(field.value.offset); // Default value as second arg for non-pointer types. if (IsScalar(field.value.type.base_type)) code += ", " + field.value.constant; code += "); }\n"; } } // Generate a verifier function that can check a buffer from an untrusted // source will never cause reads outside the buffer. code += " bool Verify(const flatbuffers::Verifier &verifier) const {\n"; code += " return VerifyTable(verifier)"; std::string prefix = " &&\n "; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { auto &field = **it; if (!field.deprecated) { code += prefix + "VerifyField<" + GenTypeSize(field.value.type); code += ">(verifier, " + NumToString(field.value.offset); code += " /* " + field.name + " */)"; switch (field.value.type.base_type) { case BASE_TYPE_UNION: code += prefix + "Verify" + field.value.type.enum_def->name; code += "(verifier, " + field.name + "(), " + field.name + "_type())"; break; case BASE_TYPE_STRUCT: if (!field.value.type.struct_def->fixed) { code += prefix + "verifier.VerifyTable(" + field.name; code += "())"; } break; case BASE_TYPE_STRING: code += prefix + "verifier.Verify(" + field.name + "())"; break; case BASE_TYPE_VECTOR: code += prefix + "verifier.Verify(" + field.name + "())"; switch (field.value.type.element) { case BASE_TYPE_STRING: { code += prefix + "verifier.VerifyVectorOfStrings(" + field.name; code += "())"; break; } case BASE_TYPE_STRUCT: { if (!field.value.type.struct_def->fixed) { code += prefix + "verifier.VerifyVectorOfTables(" + field.name; code += "())"; } break; } default: break; } break; default: break; } } } code += ";\n }\n"; code += "};\n\n"; // Generate a builder struct, with methods of the form: // void add_name(type name) { fbb_.AddElement<type>(offset, name, default); } code += "struct " + struct_def.name; code += "Builder {\n flatbuffers::FlatBufferBuilder &fbb_;\n"; code += " flatbuffers::uoffset_t start_;\n"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { auto &field = **it; if (!field.deprecated) { code += " void add_" + field.name + "("; code += GenTypeWire(field.value.type, " ") + field.name + ") { fbb_.Add"; if (IsScalar(field.value.type.base_type)) code += "Element<" + GenTypeWire(field.value.type, "") + ">"; else if (IsStruct(field.value.type)) code += "Struct"; else code += "Offset"; code += "(" + NumToString(field.value.offset) + ", " + field.name; if (IsScalar(field.value.type.base_type)) code += ", " + field.value.constant; code += "); }\n"; } } code += " " + struct_def.name; code += "Builder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) "; code += "{ start_ = fbb_.StartTable(); }\n"; code += " " + struct_def.name + "Builder &operator=(const "; code += struct_def.name + "Builder &);\n"; code += " flatbuffers::Offset<" + struct_def.name; code += "> Finish() { return flatbuffers::Offset<" + struct_def.name; code += ">(fbb_.EndTable(start_, "; code += NumToString(struct_def.fields.vec.size()) + ")); }\n};\n\n"; // Generate a convenient CreateX function that uses the above builder // to create a table in one go. code += "inline flatbuffers::Offset<" + struct_def.name + "> Create"; code += struct_def.name; code += "(flatbuffers::FlatBufferBuilder &_fbb"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { auto &field = **it; if (!field.deprecated) { code += ", " + GenTypeWire(field.value.type, " ") + field.name; } } code += ") {\n " + struct_def.name + "Builder builder_(_fbb);\n"; for (size_t size = struct_def.sortbysize ? sizeof(largest_scalar_t) : 1; size; size /= 2) { for (auto it = struct_def.fields.vec.rbegin(); it != struct_def.fields.vec.rend(); ++it) { auto &field = **it; if (!field.deprecated && (!struct_def.sortbysize || size == SizeOf(field.value.type.base_type))) { code += " builder_.add_" + field.name + "(" + field.name + ");\n"; } } } code += " return builder_.Finish();\n}\n\n"; }