Lines Matching refs:code_
89 code_ += "#include \"" + *it + "\"";
99 code_ += "#include \"" + parser_.opts.include_prefix +
104 if (num_includes) code_ += "";
122 code_.Clear();
123 code_ += "// " + std::string(FlatBuffersGeneratedWarning()) + "\n\n";
126 code_ += "#ifndef " + include_guard;
127 code_ += "#define " + include_guard;
128 code_ += "";
131 code_ += "#pragma clang system_header\n\n";
134 code_ += "#include \"flatbuffers/flatbuffers.h\"";
136 code_ += "#include \"flatbuffers/flexbuffers.h\"";
138 code_ += "";
153 code_ += "struct " + Name(struct_def) + ";";
155 code_ += "struct " +
159 code_ += "";
249 code_.SetValue("STRUCT_NAME", name);
250 code_.SetValue("CPP_NAME", cpp_name);
251 code_.SetValue("NULLABLE_EXT", NullableExtension());
254 code_ += "inline \\";
255 code_ += "const {{CPP_NAME}} *{{NULLABLE_EXT}}Get{{STRUCT_NAME}}(const void *buf) {";
256 code_ += " return flatbuffers::GetRoot<{{CPP_NAME}}>(buf);";
257 code_ += "}";
258 code_ += "";
261 code_ += "inline \\";
262 code_ += "{{STRUCT_NAME}} *GetMutable{{STRUCT_NAME}}(void *buf) {";
263 code_ += " return flatbuffers::GetMutableRoot<{{STRUCT_NAME}}>(buf);";
264 code_ += "}";
265 code_ += "";
270 code_ += "inline const char *{{STRUCT_NAME}}Identifier() {";
271 code_ += " return \"" + parser_.file_identifier_ + "\";";
272 code_ += "}";
273 code_ += "";
276 code_ += "inline \\";
277 code_ += "bool {{STRUCT_NAME}}BufferHasIdentifier(const void *buf) {";
278 code_ += " return flatbuffers::BufferHasIdentifier(";
279 code_ += " buf, {{STRUCT_NAME}}Identifier());";
280 code_ += "}";
281 code_ += "";
286 code_.SetValue("ID", name + "Identifier()");
288 code_.SetValue("ID", "nullptr");
291 code_ += "inline bool Verify{{STRUCT_NAME}}Buffer(";
292 code_ += " flatbuffers::Verifier &verifier) {";
293 code_ += " return verifier.VerifyBuffer<{{CPP_NAME}}>({{ID}});";
294 code_ += "}";
295 code_ += "";
299 code_ += "inline const char *{{STRUCT_NAME}}Extension() {";
300 code_ += " return \"" + parser_.file_extension_ + "\";";
301 code_ += "}";
302 code_ += "";
306 code_ += "inline void Finish{{STRUCT_NAME}}Buffer(";
307 code_ += " flatbuffers::FlatBufferBuilder &fbb,";
308 code_ += " flatbuffers::Offset<{{CPP_NAME}}> root) {";
310 code_ += " fbb.Finish(root, {{STRUCT_NAME}}Identifier());";
312 code_ += " fbb.Finish(root);";
313 code_ += "}";
314 code_ += "";
320 code_.SetValue("UNPACK_RETURN",
322 code_.SetValue("UNPACK_TYPE",
325 code_ += "inline {{UNPACK_RETURN}} UnPack{{STRUCT_NAME}}(";
326 code_ += " const void *buf,";
327 code_ += " const flatbuffers::resolver_function_t *res = nullptr) {";
328 code_ += " return {{UNPACK_TYPE}}\\";
329 code_ += "(Get{{STRUCT_NAME}}(buf)->UnPack(res));";
330 code_ += "}";
331 code_ += "";
338 code_ += "#endif // " + include_guard;
341 const auto final_code = code_.ToString();
346 CodeWriter code_;
370 code_ += text + "\\";
642 code_.SetValue("NAME", struct_def->name);
643 code_ += "inline flatbuffers::TypeTable *{{NAME}}TypeTable();";
644 code_ += "";
649 code_.SetValue("NAME", struct_def ? struct_def->name : enum_def->name);
650 code_.SetValue("SEQ_TYPE", struct_def
656 code_.SetValue("NUM_FIELDS", NumToString(num_fields));
738 code_.SetValue("TYPES", ts);
739 code_.SetValue("REFS", rs);
740 code_.SetValue("NAMES", ns);
741 code_.SetValue("VALUES", vs);
742 code_ += "inline flatbuffers::TypeTable *{{NAME}}TypeTable() {";
744 code_ += " static flatbuffers::TypeCode type_codes[] = {";
745 code_ += " {{TYPES}}";
746 code_ += " };";
749 code_ += " static flatbuffers::TypeFunction type_refs[] = {";
750 code_ += " {{REFS}}";
751 code_ += " };";
754 code_ += " static const int32_t values[] = { {{VALUES}} };";
759 code_ += " static const char *names[] = {";
760 code_ += " {{NAMES}}";
761 code_ += " };";
763 code_ += " static flatbuffers::TypeTable tt = {";
764 code_ += std::string(" flatbuffers::{{SEQ_TYPE}}, {{NUM_FIELDS}}, ") +
769 code_ += " };";
770 code_ += " return &tt;";
771 code_ += "}";
772 code_ += "";
779 code_.SetValue("ENUM_NAME", Name(enum_def));
780 code_.SetValue("BASE_TYPE", GenTypeBasic(enum_def.underlying_type, false));
781 code_.SetValue("SEP", "");
784 code_ += GenEnumDecl(enum_def) + "\\";
786 code_ += " : {{BASE_TYPE}}\\";
787 code_ += " {";
796 code_.SetValue("KEY", GenEnumValDecl(enum_def, Name(ev)));
797 code_.SetValue("VALUE", NumToString(ev.value));
798 code_ += "{{SEP}} {{KEY}} = {{VALUE}}\\";
799 code_.SetValue("SEP", ",\n");
809 code_.SetValue("SEP", ",\n");
811 code_.SetValue("KEY", GenEnumValDecl(enum_def, "NONE"));
812 code_.SetValue("VALUE", "0");
813 code_ += "{{SEP}} {{KEY}} = {{VALUE}}\\";
815 code_.SetValue("KEY", GenEnumValDecl(enum_def, "ANY"));
816 code_.SetValue("VALUE", NumToString(anyv));
817 code_ += "{{SEP}} {{KEY}} = {{VALUE}}\\";
819 code_.SetValue("KEY",GenEnumValDecl(enum_def, "MIN"));
820 code_.SetValue("VALUE", GenEnumValDecl(enum_def, minv->name));
821 code_ += "{{SEP}} {{KEY}} = {{VALUE}}\\";
823 code_.SetValue("KEY",GenEnumValDecl(enum_def, "MAX"));
824 code_.SetValue("VALUE", GenEnumValDecl(enum_def, maxv->name));
825 code_ += "{{SEP}} {{KEY}} = {{VALUE}}\\";
828 code_ += "";
829 code_ += "};";
832 code_ += "DEFINE_BITMASK_OPERATORS({{ENUM_NAME}}, {{BASE_TYPE}})";
834 code_ += "";
838 code_ += "inline {{ENUM_NAME}} (&EnumValues{{ENUM_NAME}}())[" + num_fields + "] {";
839 code_ += " static {{ENUM_NAME}} values[] = {";
845 code_ += " " + value + suffix;
847 code_ += " };";
848 code_ += " return values;";
849 code_ += "}";
850 code_ += "";
863 code_ += "inline const char **EnumNames{{ENUM_NAME}}() {";
864 code_ += " static const char *names[] = {";
871 code_ += " \"\",";
873 code_ += " \"" + Name(ev) + "\",";
875 code_ += " nullptr";
876 code_ += " };";
878 code_ += " return names;";
879 code_ += "}";
880 code_ += "";
882 code_ += "inline const char *EnumName{{ENUM_NAME}}({{ENUM_NAME}} e) {";
884 code_ += " const size_t index = static_cast<int>(e)\\";
887 code_ += " - static_cast<int>(" + vals + ")\\";
889 code_ += ";";
891 code_ += " return EnumNames{{ENUM_NAME}}()[index];";
892 code_ += "}";
893 code_ += "";
903 code_ += "template<typename T> struct {{ENUM_NAME}}Traits {";
907 code_ += "template<> struct {{ENUM_NAME}}Traits<" + name + "> {";
911 code_ += " static const {{ENUM_NAME}} enum_value = " + value + ";";
912 code_ += "};";
913 code_ += "";
919 code_.SetValue("NAME", Name(enum_def));
920 code_.SetValue("NONE",
923 code_ += "struct {{NAME}}Union {";
924 code_ += " {{NAME}} type;";
925 code_ += " void *value;";
926 code_ += "";
927 code_ += " {{NAME}}Union() : type({{NONE}}), value(nullptr) {}";
928 code_ += " {{NAME}}Union({{NAME}}Union&& u) FLATBUFFERS_NOEXCEPT :";
929 code_ += " type({{NONE}}), value(nullptr)";
930 code_ += " { std::swap(type, u.type); std::swap(value, u.value); }";
931 code_ += " {{NAME}}Union(const {{NAME}}Union &) FLATBUFFERS_NOEXCEPT;";
932 code_ += " {{NAME}}Union &operator=(const {{NAME}}Union &u) FLATBUFFERS_NOEXCEPT";
933 code_ += " { {{NAME}}Union t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }";
934 code_ += " {{NAME}}Union &operator=({{NAME}}Union &&u) FLATBUFFERS_NOEXCEPT";
935 code_ += " { std::swap(type, u.type); std::swap(value, u.value); return *this; }";
936 code_ += " ~{{NAME}}Union() { Reset(); }";
937 code_ += "";
938 code_ += " void Reset();";
939 code_ += "";
941 code_ += "#ifndef FLATBUFFERS_CPP98_STL";
942 code_ += " template <typename T>";
943 code_ += " void Set(T&& val) {";
944 code_ += " Reset();";
945 code_ += " type = {{NAME}}Traits<typename T::TableType>::enum_value;";
946 code_ += " if (type != {{NONE}}) {";
947 code_ += " value = new T(std::forward<T>(val));";
948 code_ += " }";
949 code_ += " }";
950 code_ += "#endif // FLATBUFFERS_CPP98_STL";
951 code_ += "";
953 code_ += " " + UnionUnPackSignature(enum_def, true) + ";";
954 code_ += " " + UnionPackSignature(enum_def, true) + ";";
955 code_ += "";
967 code_.SetValue("NATIVE_TYPE", native_type);
968 code_.SetValue("NATIVE_NAME", Name(ev));
969 code_.SetValue("NATIVE_ID", GetEnumValUse(enum_def, ev));
971 code_ += " {{NATIVE_TYPE}} *As{{NATIVE_NAME}}() {";
972 code_ += " return type == {{NATIVE_ID}} ?";
973 code_ += " reinterpret_cast<{{NATIVE_TYPE}} *>(value) : nullptr;";
974 code_ += " }";
976 code_ += " const {{NATIVE_TYPE}} *As{{NATIVE_NAME}}() const {";
977 code_ += " return type == {{NATIVE_ID}} ?";
978 code_ += " reinterpret_cast<const {{NATIVE_TYPE}} *>(value) : nullptr;";
979 code_ += " }";
981 code_ += "};";
982 code_ += "";
986 code_ += UnionVerifySignature(enum_def) + ";";
987 code_ += UnionVectorVerifySignature(enum_def) + ";";
988 code_ += "";
998 code_.SetValue("ENUM_NAME", Name(enum_def));
1000 code_ += "inline " + UnionVerifySignature(enum_def) + " {";
1001 code_ += " switch (type) {";
1005 code_.SetValue("LABEL", GetEnumValUse(enum_def, ev));
1008 code_.SetValue("TYPE", GetUnionElement(ev, true, true));
1009 code_ += " case {{LABEL}}: {";
1014 code_ += " return true;";
1016 code_ += getptr;
1017 code_ += " return verifier.VerifyTable(ptr);";
1020 code_ += getptr;
1021 code_ += " return verifier.Verify(ptr);";
1025 code_ += " }";
1027 code_ += " case {{LABEL}}: {";
1028 code_ += " return true;"; // "NONE" enum value.
1029 code_ += " }";
1032 code_ += " default: return false;";
1033 code_ += " }";
1034 code_ += "}";
1035 code_ += "";
1037 code_ += "inline " + UnionVectorVerifySignature(enum_def) + " {";
1038 code_ += " if (values->size() != types->size()) return false;";
1039 code_ += " for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {";
1040 code_ += " if (!Verify" + Name(enum_def) + "(";
1041 code_ += " verifier, values->Get(i), types->GetEnum<" + Name(enum_def) + ">(i))) {";
1042 code_ += " return false;";
1043 code_ += " }";
1044 code_ += " }";
1045 code_ += " return true;";
1046 code_ += "}";
1047 code_ += "";
1051 code_ += "inline " + UnionUnPackSignature(enum_def, false) + " {";
1052 code_ += " switch (type) {";
1060 code_.SetValue("LABEL", GetEnumValUse(enum_def, ev));
1061 code_.SetValue("TYPE", GetUnionElement(ev, true, true));
1062 code_ += " case {{LABEL}}: {";
1063 code_ += " auto ptr = reinterpret_cast<const {{TYPE}} *>(obj);";
1066 code_ += " return new " +
1069 code_ += " return ptr->UnPack(resolver);";
1072 code_ += " return new std::string(ptr->c_str(), ptr->size());";
1076 code_ += " }";
1078 code_ += " default: return nullptr;";
1079 code_ += " }";
1080 code_ += "}";
1081 code_ += "";
1083 code_ += "inline " + UnionPackSignature(enum_def, false) + " {";
1084 code_ += " switch (type) {";
1092 code_.SetValue("LABEL", GetEnumValUse(enum_def, ev));
1093 code_.SetValue("TYPE", NativeName(GetUnionElement(ev, true, true, true),
1095 code_.SetValue("NAME", GetUnionElement(ev, false, true));
1096 code_ += " case {{LABEL}}: {";
1097 code_ += " auto ptr = reinterpret_cast<const {{TYPE}} *>(value);";
1100 code_ += " return _fbb.CreateStruct(*ptr).Union();";
1102 code_ +=
1106 code_ += " return _fbb.CreateString(*ptr).Union();";
1110 code_ += " }";
1112 code_ += " default: return 0;";
1113 code_ += " }";
1114 code_ += "}";
1115 code_ += "";
1118 code_ += "inline {{ENUM_NAME}}Union::{{ENUM_NAME}}Union(const "
1121 code_ += " switch (type) {";
1128 code_.SetValue("LABEL", GetEnumValUse(enum_def, ev));
1129 code_.SetValue("TYPE", NativeName(GetUnionElement(ev, true, true, true),
1131 code_ += " case {{LABEL}}: {";
1146 code_ += " value = new {{TYPE}}(*reinterpret_cast<{{TYPE}} *>"
1149 code_ += " assert(false); // {{TYPE}} not copyable.";
1151 code_ += " break;";
1152 code_ += " }";
1154 code_ += " default:";
1155 code_ += " break;";
1156 code_ += " }";
1157 code_ += "}";
1158 code_ += "";
1161 code_.SetValue("NONE",
1164 code_ += "inline void {{ENUM_NAME}}Union::Reset() {";
1165 code_ += " switch (type) {";
1172 code_.SetValue("LABEL", GetEnumValUse(enum_def, ev));
1173 code_.SetValue("TYPE", NativeName(GetUnionElement(ev, true, true, true),
1175 code_ += " case {{LABEL}}: {";
1176 code_ += " auto ptr = reinterpret_cast<{{TYPE}} *>(value);";
1177 code_ += " delete ptr;";
1178 code_ += " break;";
1179 code_ += " }";
1181 code_ += " default: break;";
1182 code_ += " }";
1183 code_ += " value = nullptr;";
1184 code_ += " type = {{NONE}};";
1185 code_ += "}";
1186 code_ += "";
1220 code_.SetValue("NAME", fullname);
1221 code_.SetValue("CONSTEXPR", "FLATBUFFERS_CONSTEXPR");
1222 code_ += " static {{CONSTEXPR}} const char *GetFullyQualifiedName() {";
1223 code_ += " return \"{{NAME}}\";";
1224 code_ += " }";
1252 code_.SetValue("PRE", prefix);
1253 code_.SetValue("PARAM_NAME", Name(field));
1255 code_.SetValue("PARAM_TYPE", "const char *");
1256 code_.SetValue("PARAM_VALUE", "nullptr");
1259 code_.SetValue("PARAM_TYPE", "const std::vector<" + type + "> *");
1260 code_.SetValue("PARAM_VALUE", "nullptr");
1262 code_.SetValue("PARAM_TYPE", GenTypeWire(field.value.type, " ", true));
1263 code_.SetValue("PARAM_VALUE", GetDefaultScalarValue(field));
1265 code_ += "{{PRE}}{{PARAM_TYPE}}{{PARAM_NAME}} = {{PARAM_VALUE}}\\";
1277 code_.SetValue("FIELD_TYPE", full_type);
1278 code_.SetValue("FIELD_NAME", Name(field));
1279 code_ += " {{FIELD_TYPE}}{{FIELD_NAME}};";
1323 code_.SetValue("NATIVE_NAME", NativeName(Name(struct_def), &struct_def, parser_.opts));
1324 code_.SetValue("INIT_LIST", initializer_list);
1326 code_ += " {{NATIVE_NAME}}(){{INIT_LIST}} {";
1327 code_ += " }";
1332 code_ += " inline void *operator new (std::size_t count) {";
1333 code_ += " return " + native_custom_alloc->constant + "<{{NATIVE_NAME}}>().allocate(count / sizeof({{NATIVE_NAME}}));";
1334 code_ += " }";
1335 code_ += " inline void operator delete (void *ptr) {";
1336 code_ += " return " + native_custom_alloc->constant + "<{{NATIVE_NAME}}>().deallocate(static_cast<{{NATIVE_NAME}}*>(ptr),1);";
1337 code_ += " }";
1343 code_.SetValue("STRUCT_NAME", Name(struct_def));
1344 code_.SetValue("NATIVE_NAME", native_name);
1347 code_ += "struct {{NATIVE_NAME}} : public flatbuffers::NativeTable {";
1348 code_ += " typedef {{STRUCT_NAME}} TableType;";
1356 code_ += "};";
1357 code_ += "";
1362 code_.SetValue("PRE", prefix);
1363 code_.SetValue("NAME", Name(field));
1364 code_.SetValue("REQUIRED", field.required ? "Required" : "");
1365 code_.SetValue("SIZE", GenTypeSize(field.value.type));
1366 code_.SetValue("OFFSET", GenFieldOffsetName(field));
1368 code_ +=
1371 code_ += "{{PRE}}VerifyOffset{{REQUIRED}}(verifier, {{OFFSET}})\\";
1376 code_.SetValue("ENUM_NAME", field.value.type.enum_def->name);
1377 code_.SetValue("SUFFIX", UnionTypeFieldSuffix());
1378 code_ += "{{PRE}}Verify{{ENUM_NAME}}(verifier, {{NAME}}(), "
1384 code_ += "{{PRE}}verifier.VerifyTable({{NAME}}())\\";
1389 code_ += "{{PRE}}verifier.Verify({{NAME}}())\\";
1393 code_ += "{{PRE}}verifier.Verify({{NAME}}())\\";
1397 code_ += "{{PRE}}verifier.VerifyVectorOfStrings({{NAME}}())\\";
1402 code_ += "{{PRE}}verifier.VerifyVectorOfTables({{NAME}}())\\";
1407 code_.SetValue("ENUM_NAME", field.value.type.enum_def->name);
1408 code_ += "{{PRE}}Verify{{ENUM_NAME}}Vector(verifier, {{NAME}}(), {{NAME}}_type())\\";
1432 code_.SetValue("STRUCT_NAME", Name(struct_def));
1433 code_ += "struct {{STRUCT_NAME}} FLATBUFFERS_FINAL_CLASS"
1436 code_ += " typedef {{NATIVE_NAME}} NativeTableType;";
1445 code_.SetValue("SEP", "");
1446 code_ += " enum {";
1455 code_.SetValue("OFFSET_NAME", GenFieldOffsetName(field));
1456 code_.SetValue("OFFSET_VALUE", NumToString(field.value.offset));
1457 code_ += "{{SEP}} {{OFFSET_NAME}} = {{OFFSET_VALUE}}\\";
1458 code_.SetValue("SEP", ",\n");
1460 code_ += "";
1461 code_ += " };";
1475 code_.SetValue("FIELD_NAME", Name(field));
1499 code_.SetValue("FIELD_TYPE",
1501 code_.SetValue("FIELD_VALUE", GenUnderlyingCast(field, true, call));
1502 code_.SetValue("NULLABLE_EXT", NullableExtension());
1504 code_ += " {{FIELD_TYPE}}{{FIELD_NAME}}() const {";
1505 code_ += " return {{FIELD_VALUE}};";
1506 code_ += " }";
1511 code_ += " template<typename T> "
1523 code_.SetValue("U_GET_TYPE", Name(field) + UnionTypeFieldSuffix());
1524 code_.SetValue("U_ELEMENT_TYPE", WrapInNameSpace(
1526 code_.SetValue("U_FIELD_TYPE", "const " + full_struct_name + " *");
1527 code_.SetValue("U_FIELD_NAME",
1529 code_.SetValue("U_NULLABLE", NullableExtension());
1532 code_ += " {{U_FIELD_TYPE}}{{U_NULLABLE}}{{U_FIELD_NAME}}() const {";
1533 code_ += " return {{U_GET_TYPE}}() == {{U_ELEMENT_TYPE}} ? "
1536 code_ += " }";
1543 code_.SetValue("SET_FN", "SetField<" + type + ">");
1544 code_.SetValue("OFFSET_NAME", offset_str);
1545 code_.SetValue("FIELD_TYPE", GenTypeBasic(field.value.type, true));
1546 code_.SetValue("FIELD_VALUE",
1548 code_.SetValue("DEFAULT_VALUE", GenDefaultConstant(field));
1550 code_ += " bool mutate_{{FIELD_NAME}}({{FIELD_TYPE}} "
1552 code_ += " return {{SET_FN}}({{OFFSET_NAME}}, {{FIELD_VALUE}}, {{DEFAULT_VALUE}});";
1553 code_ += " }";
1558 code_.SetValue("FIELD_TYPE", type);
1559 code_.SetValue("FIELD_VALUE",
1562 code_ += " {{FIELD_TYPE}}mutable_{{FIELD_NAME}}() {";
1563 code_ += " return {{FIELD_VALUE}};";
1564 code_ += " }";
1576 code_.SetValue("CPP_NAME", TranslateNameSpace(qualified_name));
1578 code_ += " const {{CPP_NAME}} *{{FIELD_NAME}}_nested_root() const {";
1579 code_ += " auto data = {{FIELD_NAME}}()->Data();";
1580 code_ += " return flatbuffers::GetRoot<{{CPP_NAME}}>(data);";
1581 code_ += " }";
1585 code_ += " flexbuffers::Reference {{FIELD_NAME}}_flexbuffer_root()"
1587 code_ += " auto v = {{FIELD_NAME}}();";
1588 code_ += " return flexbuffers::GetRoot(v->Data(), v->size());";
1589 code_ += " }";
1596 code_ += " bool KeyCompareLessThan(const {{STRUCT_NAME}} *o) const {";
1598 code_ += " return *{{FIELD_NAME}}() < *o->{{FIELD_NAME}}();";
1600 code_ += " return {{FIELD_NAME}}() < o->{{FIELD_NAME}}();";
1602 code_ += " }";
1605 code_ += " int KeyCompareWithValue(const char *val) const {";
1606 code_ += " return strcmp({{FIELD_NAME}}()->c_str(), val);";
1607 code_ += " }";
1615 code_.SetValue("KEY_TYPE", type);
1616 code_ += " int KeyCompareWithValue({{KEY_TYPE}} val) const {";
1617 code_ += " const auto key = {{FIELD_NAME}}();";
1618 code_ += " if (key < val) {";
1619 code_ += " return -1;";
1620 code_ += " } else if (key > val) {";
1621 code_ += " return 1;";
1622 code_ += " } else {";
1623 code_ += " return 0;";
1624 code_ += " }";
1625 code_ += " }";
1632 code_ += " bool Verify(flatbuffers::Verifier &verifier) const {";
1633 code_ += " return VerifyTableStart(verifier)\\";
1643 code_ += " &&\n verifier.EndTable();";
1644 code_ += " }";
1648 code_ += " " + TableUnPackSignature(struct_def, true, parser_.opts) + ";";
1649 code_ += " " + TableUnPackToSignature(struct_def, true, parser_.opts) + ";";
1650 code_ += " " + TablePackSignature(struct_def, true, parser_.opts) + ";";
1653 code_ += "};"; // End of table.
1654 code_ += "";
1668 code_.SetValue("FIELD_NAME", Name(field));
1679 code_.SetValue("U_ELEMENT_TYPE", WrapInNameSpace(
1681 code_.SetValue("U_FIELD_TYPE", "const " + full_struct_name + " *");
1682 code_.SetValue("U_ELEMENT_NAME", full_struct_name);
1683 code_.SetValue("U_FIELD_NAME",
1687 code_ += "template<> "
1690 code_ += " return {{U_FIELD_NAME}}();";
1691 code_ += "}";
1692 code_ += "";
1701 code_ += TableCreateSignature(struct_def, true, parser_.opts) + ";";
1702 code_ += "";
1707 code_.SetValue("STRUCT_NAME", Name(struct_def));
1710 code_ += "struct {{STRUCT_NAME}}Builder {";
1711 code_ += " flatbuffers::FlatBufferBuilder &fbb_;";
1712 code_ += " flatbuffers::uoffset_t start_;";
1734 code_.SetValue("FIELD_NAME", Name(field));
1735 code_.SetValue("FIELD_TYPE", GenTypeWire(field.value.type, " ", true));
1736 code_.SetValue("ADD_OFFSET", Name(struct_def) + "::" + offset);
1737 code_.SetValue("ADD_NAME", name);
1738 code_.SetValue("ADD_VALUE", value);
1741 code_.SetValue("ADD_FN", "AddElement<" + type + ">");
1743 code_.SetValue("ADD_FN", "AddStruct");
1745 code_.SetValue("ADD_FN", "AddOffset");
1748 code_ += " void add_{{FIELD_NAME}}({{FIELD_TYPE}}{{FIELD_NAME}}) {";
1749 code_ += " fbb_.{{ADD_FN}}(\\";
1751 code_ += "{{ADD_OFFSET}}, {{ADD_NAME}}, {{ADD_VALUE}});";
1753 code_ += "{{ADD_OFFSET}}, {{ADD_NAME}});";
1755 code_ += " }";
1760 code_ += " explicit {{STRUCT_NAME}}Builder(flatbuffers::FlatBufferBuilder &_fbb)";
1761 code_ += " : fbb_(_fbb) {";
1762 code_ += " start_ = fbb_.StartTable();";
1763 code_ += " }";
1766 code_ += " {{STRUCT_NAME}}Builder &operator="
1770 code_ += " flatbuffers::Offset<{{STRUCT_NAME}}> Finish() {";
1771 code_ += " const auto end = fbb_.EndTable(start_);";
1772 code_ += " auto o = flatbuffers::Offset<{{STRUCT_NAME}}>(end);";
1778 code_.SetValue("FIELD_NAME", Name(field));
1779 code_.SetValue("OFFSET_NAME", GenFieldOffsetName(field));
1780 code_ += " fbb_.Required(o, {{STRUCT_NAME}}::{{OFFSET_NAME}});";
1783 code_ += " return o;";
1784 code_ += " }";
1785 code_ += "};";
1786 code_ += "";
1790 code_ += "inline flatbuffers::Offset<{{STRUCT_NAME}}> "
1792 code_ += " flatbuffers::FlatBufferBuilder &_fbb\\";
1800 code_ += ") {";
1802 code_ += " {{STRUCT_NAME}}Builder builder_(_fbb);";
1810 code_.SetValue("FIELD_NAME", Name(field));
1811 code_ += " builder_.add_{{FIELD_NAME}}({{FIELD_NAME}});";
1815 code_ += " return builder_.Finish();";
1816 code_ += "}";
1817 code_ += "";
1821 code_ += "inline flatbuffers::Offset<{{STRUCT_NAME}}> "
1823 code_ += " flatbuffers::FlatBufferBuilder &_fbb\\";
1834 code_.SetValue("CREATE_NAME", TranslateNameSpace(qualified_create_name));
1836 code_ += ") {";
1837 code_ += " return {{CREATE_NAME}}{{STRUCT_NAME}}(";
1838 code_ += " _fbb\\";
1843 code_.SetValue("FIELD_NAME", Name(field));
1846 code_ += ",\n {{FIELD_NAME}} ? "
1850 code_ += ",\n {{FIELD_NAME}} ? "
1853 code_ += ",\n {{FIELD_NAME}}\\";
1857 code_ += ");";
1858 code_ += "}";
1859 code_ += "";
2129 code_.SetValue("STRUCT_NAME", Name(struct_def));
2130 code_.SetValue("NATIVE_NAME", NativeName(Name(struct_def), &struct_def, parser_.opts));
2134 code_ += "inline " + TableUnPackSignature(struct_def, false, parser_.opts) + " {";
2135 code_ += " auto _o = new {{NATIVE_NAME}}();";
2136 code_ += " UnPackTo(_o, _resolver);";
2137 code_ += " return _o;";
2138 code_ += "}";
2139 code_ += "";
2141 code_ += "inline " + TableUnPackToSignature(struct_def, false, parser_.opts) + " {";
2142 code_ += " (void)_o;";
2143 code_
2159 code_.SetValue("FIELD_NAME", Name(field));
2163 code_ += std::string(prefix) + check + statement + postfix;
2165 code_ += "}";
2166 code_ += "";
2170 code_ += "inline " + TablePackSignature(struct_def, false, parser_.opts) + " {";
2171 code_ += " return Create{{STRUCT_NAME}}(_fbb, _o, _rehasher);";
2172 code_ += "}";
2173 code_ += "";
2176 code_ += "inline " + TableCreateSignature(struct_def, false, parser_.opts) + " {";
2177 code_ += " (void)_rehasher;";
2178 code_ += " (void)_o;";
2180 code_ +=
2195 code_ += " auto _" + Name(field) + " = " + GenCreateParam(field) + ";";
2199 code_.SetValue("CREATE_NAME", TranslateNameSpace(qualified_create_name));
2201 code_ += " return {{CREATE_NAME}}{{STRUCT_NAME}}(";
2202 code_ += " _fbb\\";
2223 code_ += ",\n &_" + Name(field) + "\\";
2225 code_ += ",\n _" + Name(field) + "\\";
2228 code_ += ");";
2229 code_ += "}";
2230 code_ += "";
2270 code_.SetValue("ALIGN", NumToString(struct_def.minalign));
2271 code_.SetValue("STRUCT_NAME", Name(struct_def));
2273 code_ += "MANUALLY_ALIGNED_STRUCT({{ALIGN}}) "
2275 code_ += " private:";
2281 code_.SetValue("FIELD_TYPE",
2283 code_.SetValue("FIELD_NAME", Name(field));
2284 code_ += " {{FIELD_TYPE}}{{FIELD_NAME}}_;";
2289 code_ += padding;
2294 code_ += "";
2295 code_ += " public:";
2299 code_ += " {{STRUCT_NAME}}() {";
2300 code_ += " memset(this, 0, sizeof({{STRUCT_NAME}}));";
2301 code_ += " }";
2333 code_.SetValue("ARG_LIST", arg_list);
2334 code_.SetValue("INIT_LIST", init_list);
2335 code_ += " {{STRUCT_NAME}}({{ARG_LIST}})";
2336 code_ += " : {{INIT_LIST}} {";
2344 code_ += padding;
2347 code_ += " }";
2361 code_.SetValue("FIELD_NAME", Name(field));
2362 code_.SetValue("FIELD_TYPE", field_type);
2363 code_.SetValue("FIELD_VALUE", GenUnderlyingCast(field, true, value));
2366 code_ += " {{FIELD_TYPE}}{{FIELD_NAME}}() const {";
2367 code_ += " return {{FIELD_VALUE}};";
2368 code_ += " }";
2372 code_.SetValue("FIELD_TYPE", mut_field_type);
2374 code_.SetValue("ARG", GenTypeBasic(field.value.type, true));
2375 code_.SetValue("FIELD_VALUE",
2378 code_ += " void mutate_{{FIELD_NAME}}({{ARG}} _{{FIELD_NAME}}) {";
2379 code_ += " flatbuffers::WriteScalar(&{{FIELD_NAME}}_, "
2381 code_ += " }";
2383 code_ += " {{FIELD_TYPE}}mutable_{{FIELD_NAME}}() {";
2384 code_ += " return {{FIELD_NAME}}_;";
2385 code_ += " }";
2391 code_ += " bool KeyCompareLessThan(const {{STRUCT_NAME}} *o) const {";
2392 code_ += " return {{FIELD_NAME}}() < o->{{FIELD_NAME}}();";
2393 code_ += " }";
2400 code_.SetValue("KEY_TYPE", type);
2401 code_ += " int KeyCompareWithValue({{KEY_TYPE}} val) const {";
2402 code_ += " const auto key = {{FIELD_NAME}}();";
2403 code_ += " return static_cast<int>(key > val) - static_cast<int>(key < val);";
2404 code_ += " }";
2407 code_.SetValue("NATIVE_NAME", Name(struct_def));
2409 code_ += "};";
2411 code_.SetValue("STRUCT_BYTE_SIZE", NumToString(struct_def.bytesize));
2412 code_ += "STRUCT_END({{STRUCT_NAME}}, {{STRUCT_BYTE_SIZE}});";
2413 code_ += "";
2443 code_ += "} // namespace " + cur_name_space_->components[j - 1];
2446 code_ += "";
2452 code_ += "namespace " + ns->components[j] + " {";
2455 code_ += "";
