ONE - On-device Neural Engine
Loading...
Searching...
No Matches
idl.h File Reference
#include <map>
#include <memory>
#include <stack>
#include "flatbuffers/base.h"
#include "flatbuffers/flatbuffers.h"
#include "flatbuffers/flexbuffers.h"
#include "flatbuffers/hash.h"
#include "flatbuffers/reflection.h"
#include <functional>

Go to the source code of this file.

Data Structures

struct  flatbuffers::Type
 
struct  flatbuffers::Value
 
class  flatbuffers::SymbolTable< T >
 
struct  flatbuffers::Namespace
 
struct  flatbuffers::Definition
 
struct  flatbuffers::FieldDef
 
struct  flatbuffers::StructDef
 
struct  flatbuffers::EnumVal
 
struct  flatbuffers::EnumDef
 
struct  flatbuffers::RPCCall
 
struct  flatbuffers::ServiceDef
 
struct  flatbuffers::IDLOptions
 
struct  flatbuffers::ParserState
 
class  flatbuffers::CheckedError
 
class  flatbuffers::Parser
 

Namespaces

namespace  flatbuffers
 

Macros

#define FLATBUFFERS_MAX_PARSING_DEPTH   64
 
#define FLATBUFFERS_GEN_TYPES_SCALAR(TD)
 
#define FLATBUFFERS_GEN_TYPES_POINTER(TD)
 
#define FLATBUFFERS_GEN_TYPE_ARRAY(TD)    TD(ARRAY, "", int, int, int, int, int, unused, Int, Offset<UOffset>)
 
#define FLATBUFFERS_GEN_TYPES(TD)
 
#define FLATBUFFERS_TD(ENUM, ...)    BASE_TYPE_ ## ENUM,
 
#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...)
 
#define FLATBUFFERS_CHECKED_ERROR   CheckedError
 

Enumerations

enum  flatbuffers::BaseType
 

Functions

bool flatbuffers::IsScalar (BaseType t)
 
bool flatbuffers::IsInteger (BaseType t)
 
bool flatbuffers::IsFloat (BaseType t)
 
bool flatbuffers::IsLong (BaseType t)
 
bool flatbuffers::IsBool (BaseType t)
 
bool flatbuffers::IsOneByte (BaseType t)
 
bool flatbuffers::IsUnsigned (BaseType t)
 
size_t flatbuffers::SizeOf (BaseType t)
 
bool flatbuffers::operator< (const Namespace &a, const Namespace &b)
 
bool flatbuffers::IsString (const Type &type)
 
bool flatbuffers::IsStruct (const Type &type)
 
bool flatbuffers::IsUnion (const Type &type)
 
bool flatbuffers::IsVector (const Type &type)
 
bool flatbuffers::IsArray (const Type &type)
 
bool flatbuffers::IsSeries (const Type &type)
 
bool flatbuffers::IsEnum (const Type &type)
 
size_t flatbuffers::InlineSize (const Type &type)
 
size_t flatbuffers::InlineAlignment (const Type &type)
 
bool flatbuffers::operator== (const EnumVal &lhs, const EnumVal &rhs)
 
bool flatbuffers::operator!= (const EnumVal &lhs, const EnumVal &rhs)
 
bool flatbuffers::EqualByName (const Type &a, const Type &b)
 
std::string flatbuffers::MakeCamel (const std::string &in, bool first=true)
 
std::string flatbuffers::MakeScreamingCamel (const std::string &in)
 
bool flatbuffers::GenerateTextFromTable (const Parser &parser, const void *table, const std::string &tablename, std::string *text)
 
bool flatbuffers::GenerateText (const Parser &parser, const void *flatbuffer, std::string *text)
 
bool flatbuffers::GenerateTextFile (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GenerateJsonSchema (const Parser &parser, std::string *json)
 
bool flatbuffers::GenerateBinary (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GenerateCPP (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GenerateCSharp (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GenerateDart (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GenerateJava (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GenerateTS (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GenerateGo (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GeneratePhp (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GeneratePython (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GenerateLobster (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GenerateLua (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GenerateRust (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GenerateJsonSchema (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GenerateKotlin (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GenerateSwift (const Parser &parser, const std::string &path, const std::string &file_name)
 
std::string flatbuffers::GenerateFBS (const Parser &parser, const std::string &file_name)
 
bool flatbuffers::GenerateFBS (const Parser &parser, const std::string &path, const std::string &file_name)
 
std::string flatbuffers::TSMakeRule (const Parser &parser, const std::string &path, const std::string &file_name)
 
std::string flatbuffers::CPPMakeRule (const Parser &parser, const std::string &path, const std::string &file_name)
 
std::string flatbuffers::DartMakeRule (const Parser &parser, const std::string &path, const std::string &file_name)
 
std::string flatbuffers::RustMakeRule (const Parser &parser, const std::string &path, const std::string &file_name)
 
std::string flatbuffers::JavaCSharpMakeRule (const Parser &parser, const std::string &path, const std::string &file_name)
 
std::string flatbuffers::TextMakeRule (const Parser &parser, const std::string &path, const std::string &file_names)
 
std::string flatbuffers::BinaryMakeRule (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GenerateCppGRPC (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GenerateGoGRPC (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GenerateJavaGRPC (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GeneratePythonGRPC (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GenerateSwiftGRPC (const Parser &parser, const std::string &path, const std::string &file_name)
 
bool flatbuffers::GenerateTSGRPC (const Parser &parser, const std::string &path, const std::string &file_name)
 

Variables

const char *const flatbuffers::kTypeNames []
 
const char flatbuffers::kTypeSizes []
 

Macro Definition Documentation

◆ FLATBUFFERS_CHECKED_ERROR

#define FLATBUFFERS_CHECKED_ERROR   CheckedError

Definition at line 746 of file idl.h.

◆ FLATBUFFERS_GEN_TYPE_ARRAY

#define FLATBUFFERS_GEN_TYPE_ARRAY (   TD)     TD(ARRAY, "", int, int, int, int, int, unused, Int, Offset<UOffset>)

Definition at line 70 of file idl.h.

72 :
73// - enum
74// - FlatBuffers schema type.
75// - C++ type.
76// - Java type.
77// - Go type.
78// - C# / .Net type.
79// - Python type.
80// - Rust type.
81// - Kotlin type.
82
83// using these macros, we can now write code dealing with types just once, e.g.
84
85/*
86switch (type) {
87 #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, \
88 RTYPE, KTYPE) \
89 case BASE_TYPE_ ## ENUM: \
90 // do something specific to CTYPE here
91 FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
92 #undef FLATBUFFERS_TD
93}
94*/
95
96// If not all FLATBUFFERS_GEN_() arguments are necessary for implementation
97// of FLATBUFFERS_TD, you can use a variadic macro (with __VA_ARGS__ if needed).
98// In the above example, only CTYPE is used to generate the code, it can be rewritten:
99
100/*
101switch (type) {
102 #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \
103 case BASE_TYPE_ ## ENUM: \
104 // do something specific to CTYPE here
105 FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
106 #undef FLATBUFFERS_TD
107}
108*/
109
110#define FLATBUFFERS_GEN_TYPES(TD) \
111 FLATBUFFERS_GEN_TYPES_SCALAR(TD) \
112 FLATBUFFERS_GEN_TYPES_POINTER(TD) \
113 FLATBUFFERS_GEN_TYPE_ARRAY(TD)
114
115// Create an enum for all the types above.
116#ifdef __GNUC__
117__extension__ // Stop GCC complaining about trailing comma with -Wpendantic.
118#endif
119enum BaseType {
120 #define FLATBUFFERS_TD(ENUM, ...) \
121 BASE_TYPE_ ## ENUM,
123 #undef FLATBUFFERS_TD
124};
125
126#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, ...) \
127 static_assert(sizeof(CTYPE) <= sizeof(largest_scalar_t), \
128 "define largest_scalar_t as " #CTYPE);
130#undef FLATBUFFERS_TD
131
132inline bool IsScalar (BaseType t) { return t >= BASE_TYPE_UTYPE &&
133 t <= BASE_TYPE_DOUBLE; }
134inline bool IsInteger(BaseType t) { return t >= BASE_TYPE_UTYPE &&
135 t <= BASE_TYPE_ULONG; }
136inline bool IsFloat (BaseType t) { return t == BASE_TYPE_FLOAT ||
137 t == BASE_TYPE_DOUBLE; }
138inline bool IsLong (BaseType t) { return t == BASE_TYPE_LONG ||
139 t == BASE_TYPE_ULONG; }
140inline bool IsBool (BaseType t) { return t == BASE_TYPE_BOOL; }
141inline bool IsOneByte(BaseType t) { return t >= BASE_TYPE_UTYPE &&
142 t <= BASE_TYPE_UCHAR; }
143
144inline bool IsUnsigned(BaseType t) {
145 return (t == BASE_TYPE_UTYPE) || (t == BASE_TYPE_UCHAR) ||
146 (t == BASE_TYPE_USHORT) || (t == BASE_TYPE_UINT) ||
147 (t == BASE_TYPE_ULONG);
148}
149
150// clang-format on
151
152extern const char *const kTypeNames[];
153extern const char kTypeSizes[];
154
155inline size_t SizeOf(BaseType t) { return kTypeSizes[t]; }
156
157struct StructDef;
158struct EnumDef;
159class Parser;
160
161// Represents any type in the IDL, which is a combination of the BaseType
162// and additional information for vectors/structs_.
163struct Type
164{
165 explicit Type(BaseType _base_type = BASE_TYPE_NONE, StructDef *_sd = nullptr,
166 EnumDef *_ed = nullptr, uint16_t _fixed_length = 0)
167 : base_type(_base_type), element(BASE_TYPE_NONE), struct_def(_sd), enum_def(_ed),
168 fixed_length(_fixed_length)
169 {
170 }
171
172 bool operator==(const Type &o)
173 {
174 return base_type == o.base_type && element == o.element && struct_def == o.struct_def &&
175 enum_def == o.enum_def;
176 }
177
178 Type VectorType() const { return Type(element, struct_def, enum_def, fixed_length); }
179
180 Offset<reflection::Type> Serialize(FlatBufferBuilder *builder) const;
181
182 bool Deserialize(const Parser &parser, const reflection::Type *type);
183
184 BaseType base_type;
185 BaseType element; // only set if t == BASE_TYPE_VECTOR
186 StructDef *struct_def; // only set if t or element == BASE_TYPE_STRUCT
187 EnumDef *enum_def; // set if t == BASE_TYPE_UNION / BASE_TYPE_UTYPE,
188 // or for an integral type derived from an enum.
189 uint16_t fixed_length; // only set if t == BASE_TYPE_ARRAY
190};
191
192// Represents a parsed scalar value, it's type, and field offset.
193struct Value
194{
195 Value() : constant("0"), offset(static_cast<voffset_t>(~(static_cast<voffset_t>(0U)))) {}
196 Type type;
197 std::string constant;
198 voffset_t offset;
199};
200
201// Helper class that retains the original order of a set of identifiers and
202// also provides quick lookup.
203template <typename T> class SymbolTable
204{
205public:
206 ~SymbolTable()
207 {
208 for (auto it = vec.begin(); it != vec.end(); ++it)
209 {
210 delete *it;
211 }
212 }
213
214 bool Add(const std::string &name, T *e)
215 {
216 vector_emplace_back(&vec, e);
217 auto it = dict.find(name);
218 if (it != dict.end())
219 return true;
220 dict[name] = e;
221 return false;
222 }
223
224 void Move(const std::string &oldname, const std::string &newname)
225 {
226 auto it = dict.find(oldname);
227 if (it != dict.end())
228 {
229 auto obj = it->second;
230 dict.erase(it);
231 dict[newname] = obj;
232 }
233 else
234 {
235 FLATBUFFERS_ASSERT(false);
236 }
237 }
238
239 T *Lookup(const std::string &name) const
240 {
241 auto it = dict.find(name);
242 return it == dict.end() ? nullptr : it->second;
243 }
244
245public:
246 std::map<std::string, T *> dict; // quick lookup
247 std::vector<T *> vec; // Used to iterate in order of insertion
248};
249
250// A name space, as set in the schema.
251struct Namespace
252{
253 Namespace() : from_table(0) {}
254
255 // Given a (potentially unqualified) name, return the "fully qualified" name
256 // which has a full namespaced descriptor.
257 // With max_components you can request less than the number of components
258 // the current namespace has.
259 std::string GetFullyQualifiedName(const std::string &name, size_t max_components = 1000) const;
260
261 std::vector<std::string> components;
262 size_t from_table; // Part of the namespace corresponds to a message/table.
263};
264
265inline bool operator<(const Namespace &a, const Namespace &b)
266{
267 size_t min_size = std::min(a.components.size(), b.components.size());
268 for (size_t i = 0; i < min_size; ++i)
269 {
270 if (a.components[i] != b.components[i])
271 return a.components[i] < b.components[i];
272 }
273 return a.components.size() < b.components.size();
274}
275
276// Base class for all definition types (fields, structs_, enums_).
277struct Definition
278{
279 Definition()
280 : generated(false), defined_namespace(nullptr), serialized_location(0), index(-1), refcount(1)
281 {
282 }
283
285 SerializeAttributes(FlatBufferBuilder *builder, const Parser &parser) const;
286
287 bool DeserializeAttributes(Parser &parser, const Vector<Offset<reflection::KeyValue>> *attrs);
288
289 std::string name;
290 std::string file;
291 std::vector<std::string> doc_comment;
292 SymbolTable<Value> attributes;
293 bool generated; // did we already output code for this definition?
294 Namespace *defined_namespace; // Where it was defined.
295
296 // For use with Serialize()
297 uoffset_t serialized_location;
298 int index; // Inside the vector it is stored.
299 int refcount;
300};
301
302struct FieldDef : public Definition
303{
304 FieldDef()
305 : deprecated(false), key(false), shared(false), native_inline(false), flexbuffer(false),
306 presence(kDefault), nested_flatbuffer(NULL), padding(0)
307 {
308 }
309
310 Offset<reflection::Field> Serialize(FlatBufferBuilder *builder, uint16_t id,
311 const Parser &parser) const;
312
313 bool Deserialize(Parser &parser, const reflection::Field *field);
314
315 bool IsScalarOptional() const { return IsScalar(value.type.base_type) && IsOptional(); }
316 bool IsOptional() const { return presence == kOptional; }
317 bool IsRequired() const { return presence == kRequired; }
318 bool IsDefault() const { return presence == kDefault; }
319
320 Value value;
321 bool deprecated; // Field is allowed to be present in old data, but can't be.
322 // written in new data nor accessed in new code.
323 bool key; // Field functions as a key for creating sorted vectors.
324 bool shared; // Field will be using string pooling (i.e. CreateSharedString)
325 // as default serialization behavior if field is a string.
326 bool native_inline; // Field will be defined inline (instead of as a pointer)
327 // for native tables if field is a struct.
328 bool flexbuffer; // This field contains FlexBuffer data.
329
330 enum Presence
331 {
332 // Field must always be present.
333 kRequired,
334 // Non-presence should be signalled to and controlled by users.
335 kOptional,
336 // Non-presence is hidden from users.
337 // Implementations may omit writing default values.
338 kDefault,
339 };
340 Presence static MakeFieldPresence(bool optional, bool required)
341 {
342 FLATBUFFERS_ASSERT(!(required && optional));
343 // clang-format off
344 return required ? FieldDef::kRequired
345 : optional ? FieldDef::kOptional
346 : FieldDef::kDefault;
347 // clang-format on
348 }
349 Presence presence;
350
351 StructDef *nested_flatbuffer; // This field contains nested FlatBuffer data.
352 size_t padding; // Bytes to always pad after this field.
353};
354
355struct StructDef : public Definition
356{
357 StructDef()
358 : fixed(false), predecl(true), sortbysize(true), has_key(false), minalign(1), bytesize(0)
359 {
360 }
361
362 void PadLastField(size_t min_align)
363 {
364 auto padding = PaddingBytes(bytesize, min_align);
365 bytesize += padding;
366 if (fields.vec.size())
367 fields.vec.back()->padding = padding;
368 }
369
370 Offset<reflection::Object> Serialize(FlatBufferBuilder *builder, const Parser &parser) const;
371
372 bool Deserialize(Parser &parser, const reflection::Object *object);
373
374 SymbolTable<FieldDef> fields;
375
376 bool fixed; // If it's struct, not a table.
377 bool predecl; // If it's used before it was defined.
378 bool sortbysize; // Whether fields come in the declaration or size order.
379 bool has_key; // It has a key field.
380 size_t minalign; // What the whole object needs to be aligned to.
381 size_t bytesize; // Size if fixed.
382
383 flatbuffers::unique_ptr<std::string> original_location;
384};
385
386struct EnumDef;
387struct EnumValBuilder;
388
389struct EnumVal
390{
391 Offset<reflection::EnumVal> Serialize(FlatBufferBuilder *builder, const Parser &parser) const;
392
393 bool Deserialize(const Parser &parser, const reflection::EnumVal *val);
394
395 uint64_t GetAsUInt64() const { return static_cast<uint64_t>(value); }
396 int64_t GetAsInt64() const { return value; }
397 bool IsZero() const { return 0 == value; }
398 bool IsNonZero() const { return !IsZero(); }
399
400 std::string name;
401 std::vector<std::string> doc_comment;
402 Type union_type;
403
404private:
405 friend EnumDef;
406 friend EnumValBuilder;
407 friend bool operator==(const EnumVal &lhs, const EnumVal &rhs);
408
409 EnumVal(const std::string &_name, int64_t _val) : name(_name), value(_val) {}
410 EnumVal() : value(0) {}
411
412 int64_t value;
413};
414
415struct EnumDef : public Definition
416{
417 EnumDef() : is_union(false), uses_multiple_type_instances(false) {}
418
419 Offset<reflection::Enum> Serialize(FlatBufferBuilder *builder, const Parser &parser) const;
420
421 bool Deserialize(Parser &parser, const reflection::Enum *values);
422
423 template <typename T> void ChangeEnumValue(EnumVal *ev, T new_val);
424 void SortByValue();
425 void RemoveDuplicates();
426
427 std::string AllFlags() const;
428 const EnumVal *MinValue() const;
429 const EnumVal *MaxValue() const;
430 // Returns the number of integer steps from v1 to v2.
431 uint64_t Distance(const EnumVal *v1, const EnumVal *v2) const;
432 // Returns the number of integer steps from Min to Max.
433 uint64_t Distance() const { return Distance(MinValue(), MaxValue()); }
434
435 EnumVal *ReverseLookup(int64_t enum_idx, bool skip_union_default = false) const;
436 EnumVal *FindByValue(const std::string &constant) const;
437
438 std::string ToString(const EnumVal &ev) const
439 {
440 return IsUInt64() ? NumToString(ev.GetAsUInt64()) : NumToString(ev.GetAsInt64());
441 }
442
443 size_t size() const { return vals.vec.size(); }
444
445 const std::vector<EnumVal *> &Vals() const { return vals.vec; }
446
447 const EnumVal *Lookup(const std::string &enum_name) const { return vals.Lookup(enum_name); }
448
449 bool is_union;
450 // Type is a union which uses type aliases where at least one type is
451 // available under two different names.
452 bool uses_multiple_type_instances;
453 Type underlying_type;
454
455private:
456 bool IsUInt64() const { return (BASE_TYPE_ULONG == underlying_type.base_type); }
457
458 friend EnumValBuilder;
459 SymbolTable<EnumVal> vals;
460};
461
462inline bool IsString(const Type &type) { return type.base_type == BASE_TYPE_STRING; }
463
464inline bool IsStruct(const Type &type)
465{
466 return type.base_type == BASE_TYPE_STRUCT && type.struct_def->fixed;
467}
468
469inline bool IsUnion(const Type &type)
470{
471 return type.enum_def != nullptr && type.enum_def->is_union;
472}
473
474inline bool IsVector(const Type &type) { return type.base_type == BASE_TYPE_VECTOR; }
475
476inline bool IsArray(const Type &type) { return type.base_type == BASE_TYPE_ARRAY; }
477
478inline bool IsSeries(const Type &type) { return IsVector(type) || IsArray(type); }
479
480inline bool IsEnum(const Type &type)
481{
482 return type.enum_def != nullptr && IsInteger(type.base_type);
483}
484
485inline size_t InlineSize(const Type &type)
486{
487 return IsStruct(type) ? type.struct_def->bytesize
488 : (IsArray(type) ? InlineSize(type.VectorType()) * type.fixed_length
489 : SizeOf(type.base_type));
490}
491
492inline size_t InlineAlignment(const Type &type)
493{
494 if (IsStruct(type))
495 {
496 return type.struct_def->minalign;
497 }
498 else if (IsArray(type))
499 {
500 return IsStruct(type.VectorType()) ? type.struct_def->minalign : SizeOf(type.element);
501 }
502 else
503 {
504 return SizeOf(type.base_type);
505 }
506}
507inline bool operator==(const EnumVal &lhs, const EnumVal &rhs) { return lhs.value == rhs.value; }
508inline bool operator!=(const EnumVal &lhs, const EnumVal &rhs) { return !(lhs == rhs); }
509
510inline bool EqualByName(const Type &a, const Type &b)
511{
512 return a.base_type == b.base_type && a.element == b.element &&
513 (a.struct_def == b.struct_def || a.struct_def->name == b.struct_def->name) &&
514 (a.enum_def == b.enum_def || a.enum_def->name == b.enum_def->name);
515}
516
517struct RPCCall : public Definition
518{
519 Offset<reflection::RPCCall> Serialize(FlatBufferBuilder *builder, const Parser &parser) const;
520
521 bool Deserialize(Parser &parser, const reflection::RPCCall *call);
522
523 StructDef *request, *response;
524};
525
526struct ServiceDef : public Definition
527{
528 Offset<reflection::Service> Serialize(FlatBufferBuilder *builder, const Parser &parser) const;
529 bool Deserialize(Parser &parser, const reflection::Service *service);
530
531 SymbolTable<RPCCall> calls;
532};
533
534// Container of options that may apply to any of the source/text generators.
535struct IDLOptions
536{
537 bool gen_jvmstatic;
538 // Use flexbuffers instead for binary and text generation
539 bool use_flexbuffers;
540 bool strict_json;
541 bool output_default_scalars_in_json;
542 int indent_step;
543 bool output_enum_identifiers;
544 bool prefixed_enums;
545 bool scoped_enums;
546 bool include_dependence_headers;
547 bool mutable_buffer;
548 bool one_file;
549 bool proto_mode;
550 bool proto_oneof_union;
551 bool generate_all;
552 bool skip_unexpected_fields_in_json;
553 bool generate_name_strings;
554 bool generate_object_based_api;
555 bool gen_compare;
556 std::string cpp_object_api_pointer_type;
557 std::string cpp_object_api_string_type;
558 bool cpp_object_api_string_flexible_constructor;
559 bool cpp_direct_copy;
560 bool gen_nullable;
561 bool java_checkerframework;
562 bool gen_generated;
563 std::string object_prefix;
564 std::string object_suffix;
565 bool union_value_namespacing;
566 bool allow_non_utf8;
567 bool natural_utf8;
568 std::string include_prefix;
569 bool keep_include_path;
570 bool binary_schema_comments;
571 bool binary_schema_builtins;
572 bool binary_schema_gen_embed;
573 std::string go_import;
574 std::string go_namespace;
575 bool protobuf_ascii_alike;
576 bool size_prefixed;
577 std::string root_type;
578 bool force_defaults;
579 bool java_primitive_has_method;
580 bool cs_gen_json_serializer;
581 std::vector<std::string> cpp_includes;
582 std::string cpp_std;
583 bool cpp_static_reflection;
584 std::string proto_namespace_suffix;
585 std::string filename_suffix;
586 std::string filename_extension;
587 bool no_warnings;
588
589 // Possible options for the more general generator below.
590 enum Language
591 {
592 kJava = 1 << 0,
593 kCSharp = 1 << 1,
594 kGo = 1 << 2,
595 kCpp = 1 << 3,
596 kPython = 1 << 5,
597 kPhp = 1 << 6,
598 kJson = 1 << 7,
599 kBinary = 1 << 8,
600 kTs = 1 << 9,
601 kJsonSchema = 1 << 10,
602 kDart = 1 << 11,
603 kLua = 1 << 12,
604 kLobster = 1 << 13,
605 kRust = 1 << 14,
606 kKotlin = 1 << 15,
607 kSwift = 1 << 16,
608 kMAX
609 };
610
611 Language lang;
612
613 enum MiniReflect
614 {
615 kNone,
616 kTypes,
617 kTypesAndNames
618 };
619
620 MiniReflect mini_reflect;
621
622 // If set, require all fields in a table to be explicitly numbered.
623 bool require_explicit_ids;
624
625 // The corresponding language bit will be set if a language is included
626 // for code generation.
627 unsigned long lang_to_generate;
628
629 // If set (default behavior), empty string fields will be set to nullptr to
630 // make the flatbuffer more compact.
631 bool set_empty_strings_to_null;
632
633 // If set (default behavior), empty vector fields will be set to nullptr to
634 // make the flatbuffer more compact.
635 bool set_empty_vectors_to_null;
636
637 IDLOptions()
638 : gen_jvmstatic(false), use_flexbuffers(false), strict_json(false),
639 output_default_scalars_in_json(false), indent_step(2), output_enum_identifiers(true),
640 prefixed_enums(true), scoped_enums(false), include_dependence_headers(true),
641 mutable_buffer(false), one_file(false), proto_mode(false), proto_oneof_union(false),
642 generate_all(false), skip_unexpected_fields_in_json(false), generate_name_strings(false),
643 generate_object_based_api(false), gen_compare(false),
644 cpp_object_api_pointer_type("std::unique_ptr"),
645 cpp_object_api_string_flexible_constructor(false), cpp_direct_copy(true), gen_nullable(false),
646 java_checkerframework(false), gen_generated(false), object_suffix("T"),
647 union_value_namespacing(true), allow_non_utf8(false), natural_utf8(false),
648 keep_include_path(false), binary_schema_comments(false), binary_schema_builtins(false),
649 binary_schema_gen_embed(false), protobuf_ascii_alike(false), size_prefixed(false),
650 force_defaults(false), java_primitive_has_method(false), cs_gen_json_serializer(false),
651 cpp_static_reflection(false), filename_suffix("_generated"), filename_extension(),
652 no_warnings(false), lang(IDLOptions::kJava), mini_reflect(IDLOptions::kNone),
653 require_explicit_ids(false), lang_to_generate(0), set_empty_strings_to_null(true),
654 set_empty_vectors_to_null(true)
655 {
656 }
657};
658
659// This encapsulates where the parser is in the current source file.
660struct ParserState
661{
662 ParserState()
663 : cursor_(nullptr), line_start_(nullptr), line_(0), token_(-1),
664 attr_is_trivial_ascii_string_(true)
665 {
666 }
667
668protected:
669 void ResetState(const char *source)
670 {
671 cursor_ = source;
672 line_ = 0;
673 MarkNewLine();
674 }
675
676 void MarkNewLine()
677 {
678 line_start_ = cursor_;
679 line_ += 1;
680 }
681
682 int64_t CursorPosition() const
683 {
684 FLATBUFFERS_ASSERT(cursor_ && line_start_ && cursor_ >= line_start_);
685 return static_cast<int64_t>(cursor_ - line_start_);
686 }
687
688 const char *cursor_;
689 const char *line_start_;
690 int line_; // the current line being parsed
691 int token_;
692
693 // Flag: text in attribute_ is true ASCII string without escape
694 // sequences. Only printable ASCII (without [\t\r\n]).
695 // Used for number-in-string (and base64 string in future).
696 bool attr_is_trivial_ascii_string_;
697 std::string attribute_;
698 std::vector<std::string> doc_comment_;
699};
700
701// A way to make error propagation less error prone by requiring values to be
702// checked.
703// Once you create a value of this type you must either:
704// - Call Check() on it.
705// - Copy or assign it to another value.
706// Failure to do so leads to an assert.
707// This guarantees that this as return value cannot be ignored.
708class CheckedError
709{
710public:
711 explicit CheckedError(bool error) : is_error_(error), has_been_checked_(false) {}
712
713 CheckedError &operator=(const CheckedError &other)
714 {
715 is_error_ = other.is_error_;
716 has_been_checked_ = false;
717 other.has_been_checked_ = true;
718 return *this;
719 }
720
721 CheckedError(const CheckedError &other)
722 {
723 *this = other; // Use assignment operator.
724 }
725
726 ~CheckedError() { FLATBUFFERS_ASSERT(has_been_checked_); }
727
728 bool Check()
729 {
730 has_been_checked_ = true;
731 return is_error_;
732 }
733
734private:
735 bool is_error_;
736 mutable bool has_been_checked_;
737};
738
739// Additionally, in GCC we can get these errors statically, for additional
740// assurance:
741// clang-format off
742#ifdef __GNUC__
743#define FLATBUFFERS_CHECKED_ERROR CheckedError \
744 __attribute__((warn_unused_result))
745#else
746#define FLATBUFFERS_CHECKED_ERROR CheckedError
747#endif
748// clang-format on
749
750class Parser : public ParserState
751{
752public:
753 explicit Parser(const IDLOptions &options = IDLOptions())
754 : current_namespace_(nullptr), empty_namespace_(nullptr),
755 flex_builder_(256, flexbuffers::BUILDER_FLAG_SHARE_ALL), root_struct_def_(nullptr),
756 opts(options), uses_flexbuffers_(false), advanced_features_(0), source_(nullptr),
757 anonymous_counter_(0), parse_depth_counter_(0)
758 {
759 if (opts.force_defaults)
760 {
761 builder_.ForceDefaults(true);
762 }
763 // Start out with the empty namespace being current.
764 empty_namespace_ = new Namespace();
765 namespaces_.push_back(empty_namespace_);
766 current_namespace_ = empty_namespace_;
767 known_attributes_["deprecated"] = true;
768 known_attributes_["required"] = true;
769 known_attributes_["key"] = true;
770 known_attributes_["shared"] = true;
771 known_attributes_["hash"] = true;
772 known_attributes_["id"] = true;
773 known_attributes_["force_align"] = true;
774 known_attributes_["bit_flags"] = true;
775 known_attributes_["original_order"] = true;
776 known_attributes_["nested_flatbuffer"] = true;
777 known_attributes_["csharp_partial"] = true;
778 known_attributes_["streaming"] = true;
779 known_attributes_["idempotent"] = true;
780 known_attributes_["cpp_type"] = true;
781 known_attributes_["cpp_ptr_type"] = true;
782 known_attributes_["cpp_ptr_type_get"] = true;
783 known_attributes_["cpp_str_type"] = true;
784 known_attributes_["cpp_str_flex_ctor"] = true;
785 known_attributes_["native_inline"] = true;
786 known_attributes_["native_custom_alloc"] = true;
787 known_attributes_["native_type"] = true;
788 known_attributes_["native_type_pack_name"] = true;
789 known_attributes_["native_default"] = true;
790 known_attributes_["flexbuffer"] = true;
791 known_attributes_["private"] = true;
792 }
793
794 ~Parser()
795 {
796 for (auto it = namespaces_.begin(); it != namespaces_.end(); ++it)
797 {
798 delete *it;
799 }
800 }
801
802 // Parse the string containing either schema or JSON data, which will
803 // populate the SymbolTable's or the FlatBufferBuilder above.
804 // include_paths is used to resolve any include statements, and typically
805 // should at least include the project path (where you loaded source_ from).
806 // include_paths must be nullptr terminated if specified.
807 // If include_paths is nullptr, it will attempt to load from the current
808 // directory.
809 // If the source was loaded from a file and isn't an include file,
810 // supply its name in source_filename.
811 // All paths specified in this call must be in posix format, if you accept
812 // paths from user input, please call PosixPath on them first.
813 bool Parse(const char *_source, const char **include_paths = nullptr,
814 const char *source_filename = nullptr);
815
816 bool ParseJson(const char *json, const char *json_filename = nullptr);
817
818 // Set the root type. May override the one set in the schema.
819 bool SetRootType(const char *name);
820
821 // Mark all definitions as already having code generated.
822 void MarkGenerated();
823
824 // Get the files recursively included by the given file. The returned
825 // container will have at least the given file.
826 std::set<std::string> GetIncludedFilesRecursive(const std::string &file_name) const;
827
828 // Fills builder_ with a binary version of the schema parsed.
829 // See reflection/reflection.fbs
830 void Serialize();
831
832 // Deserialize a schema buffer
833 bool Deserialize(const uint8_t *buf, const size_t size);
834
835 // Fills internal structure as if the schema passed had been loaded by parsing
836 // with Parse except that included filenames will not be populated.
837 bool Deserialize(const reflection::Schema *schema);
838
839 Type *DeserializeType(const reflection::Type *type);
840
841 // Checks that the schema represented by this parser is a safe evolution
842 // of the schema provided. Returns non-empty error on any problems.
843 std::string ConformTo(const Parser &base);
844
845 // Similar to Parse(), but now only accepts JSON to be parsed into a
846 // FlexBuffer.
847 bool ParseFlexBuffer(const char *source, const char *source_filename,
848 flexbuffers::Builder *builder);
849
850 StructDef *LookupStruct(const std::string &id) const;
851 StructDef *LookupStructThruParentNamespaces(const std::string &id) const;
852
853 std::string UnqualifiedName(const std::string &fullQualifiedName);
854
855 FLATBUFFERS_CHECKED_ERROR Error(const std::string &msg);
856
857 // @brief Verify that any of 'opts.lang_to_generate' supports Optional scalars
858 // in a schema.
859 // @param opts Options used to parce a schema and generate code.
860 static bool SupportsOptionalScalars(const flatbuffers::IDLOptions &opts);
861
862private:
863 class ParseDepthGuard;
864
865 void Message(const std::string &msg);
866 void Warning(const std::string &msg);
867 FLATBUFFERS_CHECKED_ERROR ParseHexNum(int nibbles, uint64_t *val);
869 FLATBUFFERS_CHECKED_ERROR SkipByteOrderMark();
870 bool Is(int t) const;
871 bool IsIdent(const char *id) const;
872 FLATBUFFERS_CHECKED_ERROR Expect(int t);
873 std::string TokenToStringId(int t) const;
874 EnumDef *LookupEnum(const std::string &id);
875 FLATBUFFERS_CHECKED_ERROR ParseNamespacing(std::string *id, std::string *last);
876 FLATBUFFERS_CHECKED_ERROR ParseTypeIdent(Type &type);
877 FLATBUFFERS_CHECKED_ERROR ParseType(Type &type);
878 FLATBUFFERS_CHECKED_ERROR AddField(StructDef &struct_def, const std::string &name,
879 const Type &type, FieldDef **dest);
880 FLATBUFFERS_CHECKED_ERROR ParseField(StructDef &struct_def);
881 FLATBUFFERS_CHECKED_ERROR ParseString(Value &val, bool use_string_pooling);
882 FLATBUFFERS_CHECKED_ERROR ParseComma();
883 FLATBUFFERS_CHECKED_ERROR ParseAnyValue(Value &val, FieldDef *field, size_t parent_fieldn,
884 const StructDef *parent_struct_def, uoffset_t count,
885 bool inside_vector = false);
886 template <typename F>
887 FLATBUFFERS_CHECKED_ERROR ParseTableDelimiters(size_t &fieldn, const StructDef *struct_def,
888 F body);
889 FLATBUFFERS_CHECKED_ERROR ParseTable(const StructDef &struct_def, std::string *value,
890 uoffset_t *ovalue);
891 void SerializeStruct(const StructDef &struct_def, const Value &val);
892 void SerializeStruct(FlatBufferBuilder &builder, const StructDef &struct_def, const Value &val);
893 template <typename F> FLATBUFFERS_CHECKED_ERROR ParseVectorDelimiters(uoffset_t &count, F body);
894 FLATBUFFERS_CHECKED_ERROR ParseVector(const Type &type, uoffset_t *ovalue, FieldDef *field,
895 size_t fieldn);
896 FLATBUFFERS_CHECKED_ERROR ParseArray(Value &array);
897 FLATBUFFERS_CHECKED_ERROR ParseNestedFlatbuffer(Value &val, FieldDef *field, size_t fieldn,
898 const StructDef *parent_struct_def);
899 FLATBUFFERS_CHECKED_ERROR ParseMetaData(SymbolTable<Value> *attributes);
900 FLATBUFFERS_CHECKED_ERROR TryTypedValue(const std::string *name, int dtoken, bool check, Value &e,
901 BaseType req, bool *destmatch);
902 FLATBUFFERS_CHECKED_ERROR ParseHash(Value &e, FieldDef *field);
903 FLATBUFFERS_CHECKED_ERROR TokenError();
904 FLATBUFFERS_CHECKED_ERROR ParseSingleValue(const std::string *name, Value &e, bool check_now);
905 FLATBUFFERS_CHECKED_ERROR ParseFunction(const std::string *name, Value &e);
906 FLATBUFFERS_CHECKED_ERROR ParseEnumFromString(const Type &type, std::string *result);
907 StructDef *LookupCreateStruct(const std::string &name, bool create_if_new = true,
908 bool definition = false);
909 FLATBUFFERS_CHECKED_ERROR ParseEnum(bool is_union, EnumDef **dest);
910 FLATBUFFERS_CHECKED_ERROR ParseNamespace();
911 FLATBUFFERS_CHECKED_ERROR StartStruct(const std::string &name, StructDef **dest);
912 FLATBUFFERS_CHECKED_ERROR StartEnum(const std::string &name, bool is_union, EnumDef **dest);
913 FLATBUFFERS_CHECKED_ERROR ParseDecl();
914 FLATBUFFERS_CHECKED_ERROR ParseService();
915 FLATBUFFERS_CHECKED_ERROR ParseProtoFields(StructDef *struct_def, bool isextend,
916 bool inside_oneof);
917 FLATBUFFERS_CHECKED_ERROR ParseProtoOption();
918 FLATBUFFERS_CHECKED_ERROR ParseProtoKey();
919 FLATBUFFERS_CHECKED_ERROR ParseProtoDecl();
920 FLATBUFFERS_CHECKED_ERROR ParseProtoCurliesOrIdent();
921 FLATBUFFERS_CHECKED_ERROR ParseTypeFromProtoType(Type *type);
922 FLATBUFFERS_CHECKED_ERROR SkipAnyJsonValue();
923 FLATBUFFERS_CHECKED_ERROR ParseFlexBufferNumericConstant(flexbuffers::Builder *builder);
924 FLATBUFFERS_CHECKED_ERROR ParseFlexBufferValue(flexbuffers::Builder *builder);
925 FLATBUFFERS_CHECKED_ERROR StartParseFile(const char *source, const char *source_filename);
926 FLATBUFFERS_CHECKED_ERROR ParseRoot(const char *_source, const char **include_paths,
927 const char *source_filename);
928 FLATBUFFERS_CHECKED_ERROR DoParse(const char *_source, const char **include_paths,
929 const char *source_filename, const char *include_filename);
930 FLATBUFFERS_CHECKED_ERROR DoParseJson();
931 FLATBUFFERS_CHECKED_ERROR CheckClash(std::vector<FieldDef *> &fields, StructDef *struct_def,
932 const char *suffix, BaseType baseType);
933 FLATBUFFERS_CHECKED_ERROR ParseAlignAttribute(const std::string &align_constant, size_t min_align,
934 size_t *align);
935
936 bool SupportsAdvancedUnionFeatures() const;
937 bool SupportsAdvancedArrayFeatures() const;
938 bool SupportsOptionalScalars() const;
939 bool SupportsDefaultVectorsAndStrings() const;
940 Namespace *UniqueNamespace(Namespace *ns);
941
942 FLATBUFFERS_CHECKED_ERROR RecurseError();
943 template <typename F> CheckedError Recurse(F f);
944
945public:
946 SymbolTable<Type> types_;
947 SymbolTable<StructDef> structs_;
948 SymbolTable<EnumDef> enums_;
949 SymbolTable<ServiceDef> services_;
950 std::vector<Namespace *> namespaces_;
951 Namespace *current_namespace_;
952 Namespace *empty_namespace_;
953 std::string error_; // User readable error_ if Parse() == false
954
955 FlatBufferBuilder builder_; // any data contained in the file
956 flexbuffers::Builder flex_builder_;
957 flexbuffers::Reference flex_root_;
958 StructDef *root_struct_def_;
959 std::string file_identifier_;
960 std::string file_extension_;
961
962 std::map<uint64_t, std::string> included_files_;
963 std::map<std::string, std::set<std::string>> files_included_per_file_;
964 std::vector<std::string> native_included_files_;
965
966 std::map<std::string, bool> known_attributes_;
967
968 IDLOptions opts;
969 bool uses_flexbuffers_;
970
971 uint64_t advanced_features_;
972
973private:
974 const char *source_;
975
976 std::string file_being_parsed_;
977
978 std::vector<std::pair<Value, FieldDef *>> field_stack_;
979
980 int anonymous_counter_;
981 int parse_depth_counter_; // stack-overflow guard
982};
983
984// Utility functions for multiple generators:
985
986extern std::string MakeCamel(const std::string &in, bool first = true);
987
988extern std::string MakeScreamingCamel(const std::string &in);
989
990// Generate text (JSON) from a given FlatBuffer, and a given Parser
991// object that has been populated with the corresponding schema.
992// If ident_step is 0, no indentation will be generated. Additionally,
993// if it is less than 0, no linefeeds will be generated either.
994// See idl_gen_text.cpp.
995// strict_json adds "quotes" around field names if true.
996// If the flatbuffer cannot be encoded in JSON (e.g., it contains non-UTF-8
997// byte arrays in String values), returns false.
998extern bool GenerateTextFromTable(const Parser &parser, const void *table,
999 const std::string &tablename, std::string *text);
1000extern bool GenerateText(const Parser &parser, const void *flatbuffer, std::string *text);
1001extern bool GenerateTextFile(const Parser &parser, const std::string &path,
1002 const std::string &file_name);
1003
1004// Generate Json schema to string
1005// See idl_gen_json_schema.cpp.
1006extern bool GenerateJsonSchema(const Parser &parser, std::string *json);
1007
1008// Generate binary files from a given FlatBuffer, and a given Parser
1009// object that has been populated with the corresponding schema.
1010// See code_generators.cpp.
1011extern bool GenerateBinary(const Parser &parser, const std::string &path,
1012 const std::string &file_name);
1013
1014// Generate a C++ header from the definitions in the Parser object.
1015// See idl_gen_cpp.
1016extern bool GenerateCPP(const Parser &parser, const std::string &path,
1017 const std::string &file_name);
1018
1019// Generate C# files from the definitions in the Parser object.
1020// See idl_gen_csharp.cpp.
1021extern bool GenerateCSharp(const Parser &parser, const std::string &path,
1022 const std::string &file_name);
1023
1024extern bool GenerateDart(const Parser &parser, const std::string &path,
1025 const std::string &file_name);
1026
1027// Generate Java files from the definitions in the Parser object.
1028// See idl_gen_java.cpp.
1029extern bool GenerateJava(const Parser &parser, const std::string &path,
1030 const std::string &file_name);
1031
1032// Generate JavaScript or TypeScript code from the definitions in the Parser
1033// object. See idl_gen_js.
1034extern bool GenerateTS(const Parser &parser, const std::string &path, const std::string &file_name);
1035
1036// Generate Go files from the definitions in the Parser object.
1037// See idl_gen_go.cpp.
1038extern bool GenerateGo(const Parser &parser, const std::string &path, const std::string &file_name);
1039
1040// Generate Php code from the definitions in the Parser object.
1041// See idl_gen_php.
1042extern bool GeneratePhp(const Parser &parser, const std::string &path,
1043 const std::string &file_name);
1044
1045// Generate Python files from the definitions in the Parser object.
1046// See idl_gen_python.cpp.
1047extern bool GeneratePython(const Parser &parser, const std::string &path,
1048 const std::string &file_name);
1049
1050// Generate Lobster files from the definitions in the Parser object.
1051// See idl_gen_lobster.cpp.
1052extern bool GenerateLobster(const Parser &parser, const std::string &path,
1053 const std::string &file_name);
1054
1055// Generate Lua files from the definitions in the Parser object.
1056// See idl_gen_lua.cpp.
1057extern bool GenerateLua(const Parser &parser, const std::string &path,
1058 const std::string &file_name);
1059
1060// Generate Rust files from the definitions in the Parser object.
1061// See idl_gen_rust.cpp.
1062extern bool GenerateRust(const Parser &parser, const std::string &path,
1063 const std::string &file_name);
1064
1065// Generate Json schema file
1066// See idl_gen_json_schema.cpp.
1067extern bool GenerateJsonSchema(const Parser &parser, const std::string &path,
1068 const std::string &file_name);
1069
1070extern bool GenerateKotlin(const Parser &parser, const std::string &path,
1071 const std::string &file_name);
1072
1073// Generate Swift classes.
1074// See idl_gen_swift.cpp
1075extern bool GenerateSwift(const Parser &parser, const std::string &path,
1076 const std::string &file_name);
1077
1078// Generate a schema file from the internal representation, useful after
1079// parsing a .proto schema.
1080extern std::string GenerateFBS(const Parser &parser, const std::string &file_name);
1081extern bool GenerateFBS(const Parser &parser, const std::string &path,
1082 const std::string &file_name);
1083
1084// Generate a make rule for the generated TypeScript code.
1085// See idl_gen_ts.cpp.
1086extern std::string TSMakeRule(const Parser &parser, const std::string &path,
1087 const std::string &file_name);
1088
1089// Generate a make rule for the generated C++ header.
1090// See idl_gen_cpp.cpp.
1091extern std::string CPPMakeRule(const Parser &parser, const std::string &path,
1092 const std::string &file_name);
1093
1094// Generate a make rule for the generated Dart code
1095// see idl_gen_dart.cpp
1096extern std::string DartMakeRule(const Parser &parser, const std::string &path,
1097 const std::string &file_name);
1098
1099// Generate a make rule for the generated Rust code.
1100// See idl_gen_rust.cpp.
1101extern std::string RustMakeRule(const Parser &parser, const std::string &path,
1102 const std::string &file_name);
1103
1104// Generate a make rule for generated Java or C# files.
1105// See code_generators.cpp.
1106extern std::string JavaCSharpMakeRule(const Parser &parser, const std::string &path,
1107 const std::string &file_name);
1108
1109// Generate a make rule for the generated text (JSON) files.
1110// See idl_gen_text.cpp.
1111extern std::string TextMakeRule(const Parser &parser, const std::string &path,
1112 const std::string &file_names);
1113
1114// Generate a make rule for the generated binary files.
1115// See code_generators.cpp.
1116extern std::string BinaryMakeRule(const Parser &parser, const std::string &path,
1117 const std::string &file_name);
1118
1119// Generate GRPC Cpp interfaces.
1120// See idl_gen_grpc.cpp.
1121bool GenerateCppGRPC(const Parser &parser, const std::string &path, const std::string &file_name);
1122
1123// Generate GRPC Go interfaces.
1124// See idl_gen_grpc.cpp.
1125bool GenerateGoGRPC(const Parser &parser, const std::string &path, const std::string &file_name);
1126
1127// Generate GRPC Java classes.
1128// See idl_gen_grpc.cpp
1129bool GenerateJavaGRPC(const Parser &parser, const std::string &path, const std::string &file_name);
1130
1131// Generate GRPC Python interfaces.
1132// See idl_gen_grpc.cpp.
1133bool GeneratePythonGRPC(const Parser &parser, const std::string &path,
1134 const std::string &file_name);
1135
1136// Generate GRPC Swift interfaces.
1137// See idl_gen_grpc.cpp.
1138extern bool GenerateSwiftGRPC(const Parser &parser, const std::string &path,
1139 const std::string &file_name);
1140
1141extern bool GenerateTSGRPC(const Parser &parser, const std::string &path,
1142 const std::string &file_name);
1143} // namespace flatbuffers
1144
1145#endif // FLATBUFFERS_IDL_H_
void Add(const float *input1_data, const Dims< 4 > &input1_dims, const float *input2_data, const Dims< 4 > &input2_dims, float *output_data, const Dims< 4 > &output_dims)
Definition Add.float.cpp:28
const char * kTypeNames[]
#define FLATBUFFERS_ASSERT
Definition base.h:37
__global uchar * offset(const Image *img, int x, int y)
Definition helpers.h:540
#define FLATBUFFERS_CHECKED_ERROR
Definition idl.h:746
#define FLATBUFFERS_TD(ENUM,...)
Definition idl.h:120
#define FLATBUFFERS_GEN_TYPES(TD)
Definition idl.h:110
bool operator<(const ElemID &lhs, const ElemID &rhs)
Definition ElemID.cpp:23
bool GenerateSwiftGRPC(const Parser &parser, const std::string &path, const std::string &file_name)
bool operator!=(const EnumVal &lhs, const EnumVal &rhs)
Definition idl.h:508
bool IsInteger(BaseType t)
Definition idl.h:134
std::string TextMakeRule(const Parser &parser, const std::string &path, const std::string &file_names)
bool IsScalar(BaseType t)
Definition idl.h:132
bool GenerateTextFromTable(const Parser &parser, const void *table, const std::string &tablename, std::string *text)
bool GenerateJava(const Parser &parser, const std::string &path, const std::string &file_name)
bool GenerateCSharp(const Parser &parser, const std::string &path, const std::string &file_name)
std::string RustMakeRule(const Parser &parser, const std::string &path, const std::string &file_name)
bool GenerateTSGRPC(const Parser &parser, const std::string &path, const std::string &file_name)
bool IsUnion(const Type &type)
Definition idl.h:469
bool IsSeries(const Type &type)
Definition idl.h:478
bool IsStruct(const Type &type)
Definition idl.h:464
bool GenerateJavaGRPC(const Parser &parser, const std::string &path, const std::string &file_name)
bool IsUnsigned(BaseType t)
Definition idl.h:144
std::string TSMakeRule(const Parser &parser, const std::string &path, const std::string &file_name)
int64_t LookupEnum(int64_t enum_val, const int64_t *values, size_t num_values)
void vector_emplace_back(std::vector< T > *vector, V &&data)
std::string NumToString(T t)
Definition util.h:139
bool GenerateCppGRPC(const Parser &parser, const std::string &path, const std::string &file_name)
bool IsString(const Type &type)
Definition idl.h:462
bool GenerateRust(const Parser &parser, const std::string &path, const std::string &file_name)
std::string CPPMakeRule(const Parser &parser, const std::string &path, const std::string &file_name)
bool GenerateCPP(const Parser &parser, const std::string &path, const std::string &file_name)
bool GenerateLobster(const Parser &parser, const std::string &path, const std::string &file_name)
bool IsOneByte(BaseType t)
Definition idl.h:141
bool GenerateSwift(const Parser &parser, const std::string &path, const std::string &file_name)
bool GenerateKotlin(const Parser &parser, const std::string &path, const std::string &file_name)
bool GenerateGo(const Parser &parser, const std::string &path, const std::string &file_name)
bool GenerateDart(const Parser &parser, const std::string &path, const std::string &file_name)
bool GenerateGoGRPC(const Parser &parser, const std::string &path, const std::string &file_name)
size_t InlineAlignment(const Type &type)
Definition idl.h:492
std::string MakeCamel(const std::string &in, bool first=true)
bool IsArray(const Type &type)
Definition idl.h:476
std::string GenerateFBS(const Parser &parser, const std::string &file_name)
size_t SizeOf(BaseType t)
Definition idl.h:155
bool GenerateTextFile(const Parser &parser, const std::string &path, const std::string &file_name)
bool IsFloat(BaseType t)
Definition idl.h:136
bool GeneratePython(const Parser &parser, const std::string &path, const std::string &file_name)
std::string BinaryMakeRule(const Parser &parser, const std::string &path, const std::string &file_name)
const char kTypeSizes[]
bool GenerateText(const Parser &parser, const void *flatbuffer, std::string *text)
std::string MakeScreamingCamel(const std::string &in)
bool IsBool(BaseType t)
Definition idl.h:140
size_t InlineSize(const Type &type)
Definition idl.h:485
bool GeneratePythonGRPC(const Parser &parser, const std::string &path, const std::string &file_name)
std::string JavaCSharpMakeRule(const Parser &parser, const std::string &path, const std::string &file_name)
bool GenerateTS(const Parser &parser, const std::string &path, const std::string &file_name)
bool GenerateJsonSchema(const Parser &parser, std::string *json)
bool IsVector(const Type &type)
Definition idl.h:474
bool IsEnum(const Type &type)
Definition idl.h:480
bool GeneratePhp(const Parser &parser, const std::string &path, const std::string &file_name)
bool EqualByName(const Type &a, const Type &b)
Definition idl.h:510
bool IsLong(BaseType t)
Definition idl.h:138
bool GenerateLua(const Parser &parser, const std::string &path, const std::string &file_name)
std::string DartMakeRule(const Parser &parser, const std::string &path, const std::string &file_name)
bool GenerateBinary(const Parser &parser, const std::string &path, const std::string &file_name)
Severity error(void)
Definition Severity.h:76
required
Definition infer.py:18
type
Definition infer.py:18
loco::GraphInputIndex index(const TFPlaceholder *node)
Definition TFNode.cpp:54
bool optional(bool is_optional)
convert option overview for Option constructor
int32_t size[5]
Definition Slice.cpp:35
bool operator==(const std::vector< T > &lhs, const std::vector< T > &rhs)
Compare elements of two vectors.
Definition vector.h:34

◆ FLATBUFFERS_GEN_TYPES

#define FLATBUFFERS_GEN_TYPES (   TD)
Value:
FLATBUFFERS_GEN_TYPES_POINTER(TD) \
FLATBUFFERS_GEN_TYPE_ARRAY(TD)
#define FLATBUFFERS_GEN_TYPES_SCALAR(TD)
Definition idl.h:51

Definition at line 110 of file idl.h.

◆ FLATBUFFERS_GEN_TYPES_POINTER

#define FLATBUFFERS_GEN_TYPES_POINTER (   TD)
Value:
TD(STRING, "string", Offset<void>, int, int, StringOffset, int, unused, Int, Offset<String>) \
TD(VECTOR, "", Offset<void>, int, int, VectorOffset, int, unused, Int, Offset<UOffset>) \
TD(STRUCT, "", Offset<void>, int, int, int, int, unused, Int, Offset<UOffset>) \
TD(UNION, "", Offset<void>, int, int, int, int, unused, Int, Offset<UOffset>)

Definition at line 65 of file idl.h.

◆ FLATBUFFERS_GEN_TYPES_SCALAR

#define FLATBUFFERS_GEN_TYPES_SCALAR (   TD)
Value:
TD(NONE, "", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8) \
TD(UTYPE, "", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8) /* begin scalar/int */ \
TD(BOOL, "bool", uint8_t, boolean,bool, bool, bool, bool, Boolean, Bool) \
TD(CHAR, "byte", int8_t, byte, int8, sbyte, int8, i8, Byte, Int8) \
TD(UCHAR, "ubyte", uint8_t, byte, byte, byte, uint8, u8, UByte, UInt8) \
TD(SHORT, "short", int16_t, short, int16, short, int16, i16, Short, Int16) \
TD(USHORT, "ushort", uint16_t, short, uint16, ushort, uint16, u16, UShort, UInt16) \
TD(INT, "int", int32_t, int, int32, int, int32, i32, Int, Int32) \
TD(UINT, "uint", uint32_t, int, uint32, uint, uint32, u32, UInt, UInt32) \
TD(LONG, "long", int64_t, long, int64, long, int64, i64, Long, Int64) \
TD(ULONG, "ulong", uint64_t, long, uint64, ulong, uint64, u64, ULong, UInt64) /* end int */ \
TD(FLOAT, "float", float, float, float32, float, float32, f32, Float, Float32) /* begin float */ \
TD(DOUBLE, "double", double, double, float64, double, float64, f64, Double, Double) /* end float/scalar */
std::uint8_t uint8
Definition Macro.h:52
std::uint32_t uint32
Definition Macro.h:56
std::int16_t int16
Definition Macro.h:53
std::uint16_t uint16
Definition Macro.h:54
int32_t int32
Definition topk_v2.h:27

Definition at line 51 of file idl.h.

◆ FLATBUFFERS_MAX_PARSING_DEPTH

#define FLATBUFFERS_MAX_PARSING_DEPTH   64

Definition at line 41 of file idl.h.

◆ FLATBUFFERS_TD [1/2]

#define FLATBUFFERS_TD (   ENUM,
  IDLTYPE,
  CTYPE,
  ... 
)
Value:
static_assert(sizeof(CTYPE) <= sizeof(largest_scalar_t), \
"define largest_scalar_t as " #CTYPE);

Definition at line 120 of file idl.h.

◆ FLATBUFFERS_TD [2/2]

#define FLATBUFFERS_TD (   ENUM,
  ... 
)     BASE_TYPE_ ## ENUM,

Definition at line 120 of file idl.h.