1 // automatically generated by the FlatBuffers compiler, do not modify
2 
3 
4 #ifndef FLATBUFFERS_GENERATED_EXPRESSION_LIBTEXTCLASSIFIER3_GRAMMAR_H_
5 #define FLATBUFFERS_GENERATED_EXPRESSION_LIBTEXTCLASSIFIER3_GRAMMAR_H_
6 
7 #include "flatbuffers/flatbuffers.h"
8 
9 // Ensure the included flatbuffers.h is the same version as when this file was
10 // generated, otherwise it may not be compatible.
11 static_assert(FLATBUFFERS_VERSION_MAJOR == 2 &&
12               FLATBUFFERS_VERSION_MINOR == 0 &&
13               FLATBUFFERS_VERSION_REVISION == 7,
14              "Non-compatible flatbuffers version included");
15 
16 #include "utils/flatbuffers/flatbuffers_generated.h"
17 
18 namespace libtextclassifier3 {
19 namespace grammar {
20 
21 struct SemanticExpression;
22 struct SemanticExpressionBuilder;
23 struct SemanticExpressionT;
24 
25 struct ConstValueExpression;
26 struct ConstValueExpressionBuilder;
27 struct ConstValueExpressionT;
28 
29 struct ConstituentExpression;
30 struct ConstituentExpressionBuilder;
31 struct ConstituentExpressionT;
32 
33 namespace ComposeExpression_ {
34 
35 struct Field;
36 struct FieldBuilder;
37 struct FieldT;
38 
39 }  // namespace ComposeExpression_
40 
41 struct ComposeExpression;
42 struct ComposeExpressionBuilder;
43 struct ComposeExpressionT;
44 
45 struct SpanAsStringExpression;
46 struct SpanAsStringExpressionBuilder;
47 struct SpanAsStringExpressionT;
48 
49 struct ParseNumberExpression;
50 struct ParseNumberExpressionBuilder;
51 struct ParseNumberExpressionT;
52 
53 struct MergeValueExpression;
54 struct MergeValueExpressionBuilder;
55 struct MergeValueExpressionT;
56 
57 struct ArithmeticExpression;
58 struct ArithmeticExpressionBuilder;
59 struct ArithmeticExpressionT;
60 
61 namespace SemanticExpression_ {
62 
63 enum Expression : uint8_t {
64   Expression_NONE = 0,
65   Expression_ConstValueExpression = 1,
66   Expression_ConstituentExpression = 2,
67   Expression_ComposeExpression = 3,
68   Expression_SpanAsStringExpression = 4,
69   Expression_ParseNumberExpression = 5,
70   Expression_MergeValueExpression = 6,
71   Expression_ArithmeticExpression = 7,
72   Expression_MIN = Expression_NONE,
73   Expression_MAX = Expression_ArithmeticExpression
74 };
75 
EnumValuesExpression()76 inline const Expression (&EnumValuesExpression())[8] {
77   static const Expression values[] = {
78     Expression_NONE,
79     Expression_ConstValueExpression,
80     Expression_ConstituentExpression,
81     Expression_ComposeExpression,
82     Expression_SpanAsStringExpression,
83     Expression_ParseNumberExpression,
84     Expression_MergeValueExpression,
85     Expression_ArithmeticExpression
86   };
87   return values;
88 }
89 
EnumNamesExpression()90 inline const char * const *EnumNamesExpression() {
91   static const char * const names[9] = {
92     "NONE",
93     "ConstValueExpression",
94     "ConstituentExpression",
95     "ComposeExpression",
96     "SpanAsStringExpression",
97     "ParseNumberExpression",
98     "MergeValueExpression",
99     "ArithmeticExpression",
100     nullptr
101   };
102   return names;
103 }
104 
EnumNameExpression(Expression e)105 inline const char *EnumNameExpression(Expression e) {
106   if (flatbuffers::IsOutRange(e, Expression_NONE, Expression_ArithmeticExpression)) return "";
107   const size_t index = static_cast<size_t>(e);
108   return EnumNamesExpression()[index];
109 }
110 
111 template<typename T> struct ExpressionTraits {
112   static const Expression enum_value = Expression_NONE;
113 };
114 
115 template<> struct ExpressionTraits<libtextclassifier3::grammar::ConstValueExpression> {
116   static const Expression enum_value = Expression_ConstValueExpression;
117 };
118 
119 template<> struct ExpressionTraits<libtextclassifier3::grammar::ConstituentExpression> {
120   static const Expression enum_value = Expression_ConstituentExpression;
121 };
122 
123 template<> struct ExpressionTraits<libtextclassifier3::grammar::ComposeExpression> {
124   static const Expression enum_value = Expression_ComposeExpression;
125 };
126 
127 template<> struct ExpressionTraits<libtextclassifier3::grammar::SpanAsStringExpression> {
128   static const Expression enum_value = Expression_SpanAsStringExpression;
129 };
130 
131 template<> struct ExpressionTraits<libtextclassifier3::grammar::ParseNumberExpression> {
132   static const Expression enum_value = Expression_ParseNumberExpression;
133 };
134 
135 template<> struct ExpressionTraits<libtextclassifier3::grammar::MergeValueExpression> {
136   static const Expression enum_value = Expression_MergeValueExpression;
137 };
138 
139 template<> struct ExpressionTraits<libtextclassifier3::grammar::ArithmeticExpression> {
140   static const Expression enum_value = Expression_ArithmeticExpression;
141 };
142 
143 template<typename T> struct ExpressionUnionTraits {
144   static const Expression enum_value = Expression_NONE;
145 };
146 
147 template<> struct ExpressionUnionTraits<libtextclassifier3::grammar::ConstValueExpressionT> {
148   static const Expression enum_value = Expression_ConstValueExpression;
149 };
150 
151 template<> struct ExpressionUnionTraits<libtextclassifier3::grammar::ConstituentExpressionT> {
152   static const Expression enum_value = Expression_ConstituentExpression;
153 };
154 
155 template<> struct ExpressionUnionTraits<libtextclassifier3::grammar::ComposeExpressionT> {
156   static const Expression enum_value = Expression_ComposeExpression;
157 };
158 
159 template<> struct ExpressionUnionTraits<libtextclassifier3::grammar::SpanAsStringExpressionT> {
160   static const Expression enum_value = Expression_SpanAsStringExpression;
161 };
162 
163 template<> struct ExpressionUnionTraits<libtextclassifier3::grammar::ParseNumberExpressionT> {
164   static const Expression enum_value = Expression_ParseNumberExpression;
165 };
166 
167 template<> struct ExpressionUnionTraits<libtextclassifier3::grammar::MergeValueExpressionT> {
168   static const Expression enum_value = Expression_MergeValueExpression;
169 };
170 
171 template<> struct ExpressionUnionTraits<libtextclassifier3::grammar::ArithmeticExpressionT> {
172   static const Expression enum_value = Expression_ArithmeticExpression;
173 };
174 
175 struct ExpressionUnion {
176   Expression type;
177   void *value;
178 
179   ExpressionUnion() : type(Expression_NONE), value(nullptr) {}
180   ExpressionUnion(ExpressionUnion&& u) FLATBUFFERS_NOEXCEPT :
181     type(Expression_NONE), value(nullptr)
182     { std::swap(type, u.type); std::swap(value, u.value); }
183   ExpressionUnion(const ExpressionUnion &);
184   ExpressionUnion &operator=(const ExpressionUnion &u)
185     { ExpressionUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
186   ExpressionUnion &operator=(ExpressionUnion &&u) FLATBUFFERS_NOEXCEPT
187     { std::swap(type, u.type); std::swap(value, u.value); return *this; }
188   ~ExpressionUnion() { Reset(); }
189 
190   void Reset();
191 
192   template <typename T>
193   void Set(T&& val) {
194     typedef typename std::remove_reference<T>::type RT;
195     Reset();
196     type = ExpressionUnionTraits<RT>::enum_value;
197     if (type != Expression_NONE) {
198       value = new RT(std::forward<T>(val));
199     }
200   }
201 
202   static void *UnPack(const void *obj, Expression type, const flatbuffers::resolver_function_t *resolver);
203   flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
204 
205   libtextclassifier3::grammar::ConstValueExpressionT *AsConstValueExpression() {
206     return type == Expression_ConstValueExpression ?
207       reinterpret_cast<libtextclassifier3::grammar::ConstValueExpressionT *>(value) : nullptr;
208   }
209   const libtextclassifier3::grammar::ConstValueExpressionT *AsConstValueExpression() const {
210     return type == Expression_ConstValueExpression ?
211       reinterpret_cast<const libtextclassifier3::grammar::ConstValueExpressionT *>(value) : nullptr;
212   }
213   libtextclassifier3::grammar::ConstituentExpressionT *AsConstituentExpression() {
214     return type == Expression_ConstituentExpression ?
215       reinterpret_cast<libtextclassifier3::grammar::ConstituentExpressionT *>(value) : nullptr;
216   }
217   const libtextclassifier3::grammar::ConstituentExpressionT *AsConstituentExpression() const {
218     return type == Expression_ConstituentExpression ?
219       reinterpret_cast<const libtextclassifier3::grammar::ConstituentExpressionT *>(value) : nullptr;
220   }
221   libtextclassifier3::grammar::ComposeExpressionT *AsComposeExpression() {
222     return type == Expression_ComposeExpression ?
223       reinterpret_cast<libtextclassifier3::grammar::ComposeExpressionT *>(value) : nullptr;
224   }
225   const libtextclassifier3::grammar::ComposeExpressionT *AsComposeExpression() const {
226     return type == Expression_ComposeExpression ?
227       reinterpret_cast<const libtextclassifier3::grammar::ComposeExpressionT *>(value) : nullptr;
228   }
229   libtextclassifier3::grammar::SpanAsStringExpressionT *AsSpanAsStringExpression() {
230     return type == Expression_SpanAsStringExpression ?
231       reinterpret_cast<libtextclassifier3::grammar::SpanAsStringExpressionT *>(value) : nullptr;
232   }
233   const libtextclassifier3::grammar::SpanAsStringExpressionT *AsSpanAsStringExpression() const {
234     return type == Expression_SpanAsStringExpression ?
235       reinterpret_cast<const libtextclassifier3::grammar::SpanAsStringExpressionT *>(value) : nullptr;
236   }
237   libtextclassifier3::grammar::ParseNumberExpressionT *AsParseNumberExpression() {
238     return type == Expression_ParseNumberExpression ?
239       reinterpret_cast<libtextclassifier3::grammar::ParseNumberExpressionT *>(value) : nullptr;
240   }
241   const libtextclassifier3::grammar::ParseNumberExpressionT *AsParseNumberExpression() const {
242     return type == Expression_ParseNumberExpression ?
243       reinterpret_cast<const libtextclassifier3::grammar::ParseNumberExpressionT *>(value) : nullptr;
244   }
245   libtextclassifier3::grammar::MergeValueExpressionT *AsMergeValueExpression() {
246     return type == Expression_MergeValueExpression ?
247       reinterpret_cast<libtextclassifier3::grammar::MergeValueExpressionT *>(value) : nullptr;
248   }
249   const libtextclassifier3::grammar::MergeValueExpressionT *AsMergeValueExpression() const {
250     return type == Expression_MergeValueExpression ?
251       reinterpret_cast<const libtextclassifier3::grammar::MergeValueExpressionT *>(value) : nullptr;
252   }
253   libtextclassifier3::grammar::ArithmeticExpressionT *AsArithmeticExpression() {
254     return type == Expression_ArithmeticExpression ?
255       reinterpret_cast<libtextclassifier3::grammar::ArithmeticExpressionT *>(value) : nullptr;
256   }
257   const libtextclassifier3::grammar::ArithmeticExpressionT *AsArithmeticExpression() const {
258     return type == Expression_ArithmeticExpression ?
259       reinterpret_cast<const libtextclassifier3::grammar::ArithmeticExpressionT *>(value) : nullptr;
260   }
261 };
262 
263 bool VerifyExpression(flatbuffers::Verifier &verifier, const void *obj, Expression type);
264 bool VerifyExpressionVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
265 
266 }  // namespace SemanticExpression_
267 
268 namespace ArithmeticExpression_ {
269 
270 enum Operator : int32_t {
271   Operator_NO_OP = 0,
272   Operator_OP_ADD = 1,
273   Operator_OP_MUL = 2,
274   Operator_OP_MAX = 3,
275   Operator_OP_MIN = 4,
276   Operator_MIN = Operator_NO_OP,
277   Operator_MAX = Operator_OP_MIN
278 };
279 
280 inline const Operator (&EnumValuesOperator())[5] {
281   static const Operator values[] = {
282     Operator_NO_OP,
283     Operator_OP_ADD,
284     Operator_OP_MUL,
285     Operator_OP_MAX,
286     Operator_OP_MIN
287   };
288   return values;
289 }
290 
291 inline const char * const *EnumNamesOperator() {
292   static const char * const names[6] = {
293     "NO_OP",
294     "OP_ADD",
295     "OP_MUL",
296     "OP_MAX",
297     "OP_MIN",
298     nullptr
299   };
300   return names;
301 }
302 
303 inline const char *EnumNameOperator(Operator e) {
304   if (flatbuffers::IsOutRange(e, Operator_NO_OP, Operator_OP_MIN)) return "";
305   const size_t index = static_cast<size_t>(e);
306   return EnumNamesOperator()[index];
307 }
308 
309 }  // namespace ArithmeticExpression_
310 
311 struct SemanticExpressionT : public flatbuffers::NativeTable {
312   typedef SemanticExpression TableType;
313   libtextclassifier3::grammar::SemanticExpression_::ExpressionUnion expression{};
314 };
315 
316 struct SemanticExpression FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
317   typedef SemanticExpressionT NativeTableType;
318   typedef SemanticExpressionBuilder Builder;
319   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
320     VT_EXPRESSION_TYPE = 4,
321     VT_EXPRESSION = 6
322   };
323   libtextclassifier3::grammar::SemanticExpression_::Expression expression_type() const {
324     return static_cast<libtextclassifier3::grammar::SemanticExpression_::Expression>(GetField<uint8_t>(VT_EXPRESSION_TYPE, 0));
325   }
326   const void *expression() const {
327     return GetPointer<const void *>(VT_EXPRESSION);
328   }
329   template<typename T> const T *expression_as() const;
330   const libtextclassifier3::grammar::ConstValueExpression *expression_as_ConstValueExpression() const {
331     return expression_type() == libtextclassifier3::grammar::SemanticExpression_::Expression_ConstValueExpression ? static_cast<const libtextclassifier3::grammar::ConstValueExpression *>(expression()) : nullptr;
332   }
333   const libtextclassifier3::grammar::ConstituentExpression *expression_as_ConstituentExpression() const {
334     return expression_type() == libtextclassifier3::grammar::SemanticExpression_::Expression_ConstituentExpression ? static_cast<const libtextclassifier3::grammar::ConstituentExpression *>(expression()) : nullptr;
335   }
336   const libtextclassifier3::grammar::ComposeExpression *expression_as_ComposeExpression() const {
337     return expression_type() == libtextclassifier3::grammar::SemanticExpression_::Expression_ComposeExpression ? static_cast<const libtextclassifier3::grammar::ComposeExpression *>(expression()) : nullptr;
338   }
339   const libtextclassifier3::grammar::SpanAsStringExpression *expression_as_SpanAsStringExpression() const {
340     return expression_type() == libtextclassifier3::grammar::SemanticExpression_::Expression_SpanAsStringExpression ? static_cast<const libtextclassifier3::grammar::SpanAsStringExpression *>(expression()) : nullptr;
341   }
342   const libtextclassifier3::grammar::ParseNumberExpression *expression_as_ParseNumberExpression() const {
343     return expression_type() == libtextclassifier3::grammar::SemanticExpression_::Expression_ParseNumberExpression ? static_cast<const libtextclassifier3::grammar::ParseNumberExpression *>(expression()) : nullptr;
344   }
345   const libtextclassifier3::grammar::MergeValueExpression *expression_as_MergeValueExpression() const {
346     return expression_type() == libtextclassifier3::grammar::SemanticExpression_::Expression_MergeValueExpression ? static_cast<const libtextclassifier3::grammar::MergeValueExpression *>(expression()) : nullptr;
347   }
348   const libtextclassifier3::grammar::ArithmeticExpression *expression_as_ArithmeticExpression() const {
349     return expression_type() == libtextclassifier3::grammar::SemanticExpression_::Expression_ArithmeticExpression ? static_cast<const libtextclassifier3::grammar::ArithmeticExpression *>(expression()) : nullptr;
350   }
351   bool Verify(flatbuffers::Verifier &verifier) const {
352     return VerifyTableStart(verifier) &&
353            VerifyField<uint8_t>(verifier, VT_EXPRESSION_TYPE, 1) &&
354            VerifyOffset(verifier, VT_EXPRESSION) &&
355            VerifyExpression(verifier, expression(), expression_type()) &&
356            verifier.EndTable();
357   }
358   SemanticExpressionT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
359   void UnPackTo(SemanticExpressionT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
360   static flatbuffers::Offset<SemanticExpression> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SemanticExpressionT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
361 };
362 
363 template<> inline const libtextclassifier3::grammar::ConstValueExpression *SemanticExpression::expression_as<libtextclassifier3::grammar::ConstValueExpression>() const {
364   return expression_as_ConstValueExpression();
365 }
366 
367 template<> inline const libtextclassifier3::grammar::ConstituentExpression *SemanticExpression::expression_as<libtextclassifier3::grammar::ConstituentExpression>() const {
368   return expression_as_ConstituentExpression();
369 }
370 
371 template<> inline const libtextclassifier3::grammar::ComposeExpression *SemanticExpression::expression_as<libtextclassifier3::grammar::ComposeExpression>() const {
372   return expression_as_ComposeExpression();
373 }
374 
375 template<> inline const libtextclassifier3::grammar::SpanAsStringExpression *SemanticExpression::expression_as<libtextclassifier3::grammar::SpanAsStringExpression>() const {
376   return expression_as_SpanAsStringExpression();
377 }
378 
379 template<> inline const libtextclassifier3::grammar::ParseNumberExpression *SemanticExpression::expression_as<libtextclassifier3::grammar::ParseNumberExpression>() const {
380   return expression_as_ParseNumberExpression();
381 }
382 
383 template<> inline const libtextclassifier3::grammar::MergeValueExpression *SemanticExpression::expression_as<libtextclassifier3::grammar::MergeValueExpression>() const {
384   return expression_as_MergeValueExpression();
385 }
386 
387 template<> inline const libtextclassifier3::grammar::ArithmeticExpression *SemanticExpression::expression_as<libtextclassifier3::grammar::ArithmeticExpression>() const {
388   return expression_as_ArithmeticExpression();
389 }
390 
391 struct SemanticExpressionBuilder {
392   typedef SemanticExpression Table;
393   flatbuffers::FlatBufferBuilder &fbb_;
394   flatbuffers::uoffset_t start_;
395   void add_expression_type(libtextclassifier3::grammar::SemanticExpression_::Expression expression_type) {
396     fbb_.AddElement<uint8_t>(SemanticExpression::VT_EXPRESSION_TYPE, static_cast<uint8_t>(expression_type), 0);
397   }
398   void add_expression(flatbuffers::Offset<void> expression) {
399     fbb_.AddOffset(SemanticExpression::VT_EXPRESSION, expression);
400   }
401   explicit SemanticExpressionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
402         : fbb_(_fbb) {
403     start_ = fbb_.StartTable();
404   }
405   flatbuffers::Offset<SemanticExpression> Finish() {
406     const auto end = fbb_.EndTable(start_);
407     auto o = flatbuffers::Offset<SemanticExpression>(end);
408     return o;
409   }
410 };
411 
412 inline flatbuffers::Offset<SemanticExpression> CreateSemanticExpression(
413     flatbuffers::FlatBufferBuilder &_fbb,
414     libtextclassifier3::grammar::SemanticExpression_::Expression expression_type = libtextclassifier3::grammar::SemanticExpression_::Expression_NONE,
415     flatbuffers::Offset<void> expression = 0) {
416   SemanticExpressionBuilder builder_(_fbb);
417   builder_.add_expression(expression);
418   builder_.add_expression_type(expression_type);
419   return builder_.Finish();
420 }
421 
422 flatbuffers::Offset<SemanticExpression> CreateSemanticExpression(flatbuffers::FlatBufferBuilder &_fbb, const SemanticExpressionT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
423 
424 struct ConstValueExpressionT : public flatbuffers::NativeTable {
425   typedef ConstValueExpression TableType;
426   int32_t base_type = 0;
427   int32_t type = 0;
428   std::vector<uint8_t> value{};
429 };
430 
431 struct ConstValueExpression FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
432   typedef ConstValueExpressionT NativeTableType;
433   typedef ConstValueExpressionBuilder Builder;
434   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
435     VT_BASE_TYPE = 4,
436     VT_TYPE = 6,
437     VT_VALUE = 8
438   };
439   int32_t base_type() const {
440     return GetField<int32_t>(VT_BASE_TYPE, 0);
441   }
442   int32_t type() const {
443     return GetField<int32_t>(VT_TYPE, 0);
444   }
445   const flatbuffers::Vector<uint8_t> *value() const {
446     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_VALUE);
447   }
448   bool Verify(flatbuffers::Verifier &verifier) const {
449     return VerifyTableStart(verifier) &&
450            VerifyField<int32_t>(verifier, VT_BASE_TYPE, 4) &&
451            VerifyField<int32_t>(verifier, VT_TYPE, 4) &&
452            VerifyOffset(verifier, VT_VALUE) &&
453            verifier.VerifyVector(value()) &&
454            verifier.EndTable();
455   }
456   ConstValueExpressionT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
457   void UnPackTo(ConstValueExpressionT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
458   static flatbuffers::Offset<ConstValueExpression> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConstValueExpressionT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
459 };
460 
461 struct ConstValueExpressionBuilder {
462   typedef ConstValueExpression Table;
463   flatbuffers::FlatBufferBuilder &fbb_;
464   flatbuffers::uoffset_t start_;
465   void add_base_type(int32_t base_type) {
466     fbb_.AddElement<int32_t>(ConstValueExpression::VT_BASE_TYPE, base_type, 0);
467   }
468   void add_type(int32_t type) {
469     fbb_.AddElement<int32_t>(ConstValueExpression::VT_TYPE, type, 0);
470   }
471   void add_value(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> value) {
472     fbb_.AddOffset(ConstValueExpression::VT_VALUE, value);
473   }
474   explicit ConstValueExpressionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
475         : fbb_(_fbb) {
476     start_ = fbb_.StartTable();
477   }
478   flatbuffers::Offset<ConstValueExpression> Finish() {
479     const auto end = fbb_.EndTable(start_);
480     auto o = flatbuffers::Offset<ConstValueExpression>(end);
481     return o;
482   }
483 };
484 
485 inline flatbuffers::Offset<ConstValueExpression> CreateConstValueExpression(
486     flatbuffers::FlatBufferBuilder &_fbb,
487     int32_t base_type = 0,
488     int32_t type = 0,
489     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> value = 0) {
490   ConstValueExpressionBuilder builder_(_fbb);
491   builder_.add_value(value);
492   builder_.add_type(type);
493   builder_.add_base_type(base_type);
494   return builder_.Finish();
495 }
496 
497 inline flatbuffers::Offset<ConstValueExpression> CreateConstValueExpressionDirect(
498     flatbuffers::FlatBufferBuilder &_fbb,
499     int32_t base_type = 0,
500     int32_t type = 0,
501     const std::vector<uint8_t> *value = nullptr) {
502   auto value__ = value ? _fbb.CreateVector<uint8_t>(*value) : 0;
503   return libtextclassifier3::grammar::CreateConstValueExpression(
504       _fbb,
505       base_type,
506       type,
507       value__);
508 }
509 
510 flatbuffers::Offset<ConstValueExpression> CreateConstValueExpression(flatbuffers::FlatBufferBuilder &_fbb, const ConstValueExpressionT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
511 
512 struct ConstituentExpressionT : public flatbuffers::NativeTable {
513   typedef ConstituentExpression TableType;
514   uint16_t id = 0;
515 };
516 
517 struct ConstituentExpression FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
518   typedef ConstituentExpressionT NativeTableType;
519   typedef ConstituentExpressionBuilder Builder;
520   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
521     VT_ID = 4
522   };
523   uint16_t id() const {
524     return GetField<uint16_t>(VT_ID, 0);
525   }
526   bool Verify(flatbuffers::Verifier &verifier) const {
527     return VerifyTableStart(verifier) &&
528            VerifyField<uint16_t>(verifier, VT_ID, 2) &&
529            verifier.EndTable();
530   }
531   ConstituentExpressionT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
532   void UnPackTo(ConstituentExpressionT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
533   static flatbuffers::Offset<ConstituentExpression> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConstituentExpressionT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
534 };
535 
536 struct ConstituentExpressionBuilder {
537   typedef ConstituentExpression Table;
538   flatbuffers::FlatBufferBuilder &fbb_;
539   flatbuffers::uoffset_t start_;
540   void add_id(uint16_t id) {
541     fbb_.AddElement<uint16_t>(ConstituentExpression::VT_ID, id, 0);
542   }
543   explicit ConstituentExpressionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
544         : fbb_(_fbb) {
545     start_ = fbb_.StartTable();
546   }
547   flatbuffers::Offset<ConstituentExpression> Finish() {
548     const auto end = fbb_.EndTable(start_);
549     auto o = flatbuffers::Offset<ConstituentExpression>(end);
550     return o;
551   }
552 };
553 
554 inline flatbuffers::Offset<ConstituentExpression> CreateConstituentExpression(
555     flatbuffers::FlatBufferBuilder &_fbb,
556     uint16_t id = 0) {
557   ConstituentExpressionBuilder builder_(_fbb);
558   builder_.add_id(id);
559   return builder_.Finish();
560 }
561 
562 flatbuffers::Offset<ConstituentExpression> CreateConstituentExpression(flatbuffers::FlatBufferBuilder &_fbb, const ConstituentExpressionT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
563 
564 namespace ComposeExpression_ {
565 
566 struct FieldT : public flatbuffers::NativeTable {
567   typedef Field TableType;
568   std::unique_ptr<libtextclassifier3::FlatbufferFieldPathT> path{};
569   std::unique_ptr<libtextclassifier3::grammar::SemanticExpressionT> value{};
570   FieldT() = default;
571   FieldT(const FieldT &o);
572   FieldT(FieldT&&) FLATBUFFERS_NOEXCEPT = default;
573   FieldT &operator=(FieldT o) FLATBUFFERS_NOEXCEPT;
574 };
575 
576 struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
577   typedef FieldT NativeTableType;
578   typedef FieldBuilder Builder;
579   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
580     VT_PATH = 4,
581     VT_VALUE = 6
582   };
583   const libtextclassifier3::FlatbufferFieldPath *path() const {
584     return GetPointer<const libtextclassifier3::FlatbufferFieldPath *>(VT_PATH);
585   }
586   const libtextclassifier3::grammar::SemanticExpression *value() const {
587     return GetPointer<const libtextclassifier3::grammar::SemanticExpression *>(VT_VALUE);
588   }
589   bool Verify(flatbuffers::Verifier &verifier) const {
590     return VerifyTableStart(verifier) &&
591            VerifyOffset(verifier, VT_PATH) &&
592            verifier.VerifyTable(path()) &&
593            VerifyOffset(verifier, VT_VALUE) &&
594            verifier.VerifyTable(value()) &&
595            verifier.EndTable();
596   }
597   FieldT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
598   void UnPackTo(FieldT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
599   static flatbuffers::Offset<Field> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FieldT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
600 };
601 
602 struct FieldBuilder {
603   typedef Field Table;
604   flatbuffers::FlatBufferBuilder &fbb_;
605   flatbuffers::uoffset_t start_;
606   void add_path(flatbuffers::Offset<libtextclassifier3::FlatbufferFieldPath> path) {
607     fbb_.AddOffset(Field::VT_PATH, path);
608   }
609   void add_value(flatbuffers::Offset<libtextclassifier3::grammar::SemanticExpression> value) {
610     fbb_.AddOffset(Field::VT_VALUE, value);
611   }
612   explicit FieldBuilder(flatbuffers::FlatBufferBuilder &_fbb)
613         : fbb_(_fbb) {
614     start_ = fbb_.StartTable();
615   }
616   flatbuffers::Offset<Field> Finish() {
617     const auto end = fbb_.EndTable(start_);
618     auto o = flatbuffers::Offset<Field>(end);
619     return o;
620   }
621 };
622 
623 inline flatbuffers::Offset<Field> CreateField(
624     flatbuffers::FlatBufferBuilder &_fbb,
625     flatbuffers::Offset<libtextclassifier3::FlatbufferFieldPath> path = 0,
626     flatbuffers::Offset<libtextclassifier3::grammar::SemanticExpression> value = 0) {
627   FieldBuilder builder_(_fbb);
628   builder_.add_value(value);
629   builder_.add_path(path);
630   return builder_.Finish();
631 }
632 
633 flatbuffers::Offset<Field> CreateField(flatbuffers::FlatBufferBuilder &_fbb, const FieldT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
634 
635 }  // namespace ComposeExpression_
636 
637 struct ComposeExpressionT : public flatbuffers::NativeTable {
638   typedef ComposeExpression TableType;
639   int32_t type = 0;
640   std::vector<std::unique_ptr<libtextclassifier3::grammar::ComposeExpression_::FieldT>> fields{};
641   ComposeExpressionT() = default;
642   ComposeExpressionT(const ComposeExpressionT &o);
643   ComposeExpressionT(ComposeExpressionT&&) FLATBUFFERS_NOEXCEPT = default;
644   ComposeExpressionT &operator=(ComposeExpressionT o) FLATBUFFERS_NOEXCEPT;
645 };
646 
647 struct ComposeExpression FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
648   typedef ComposeExpressionT NativeTableType;
649   typedef ComposeExpressionBuilder Builder;
650   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
651     VT_TYPE = 4,
652     VT_FIELDS = 6
653   };
654   int32_t type() const {
655     return GetField<int32_t>(VT_TYPE, 0);
656   }
657   const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::grammar::ComposeExpression_::Field>> *fields() const {
658     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::grammar::ComposeExpression_::Field>> *>(VT_FIELDS);
659   }
660   bool Verify(flatbuffers::Verifier &verifier) const {
661     return VerifyTableStart(verifier) &&
662            VerifyField<int32_t>(verifier, VT_TYPE, 4) &&
663            VerifyOffset(verifier, VT_FIELDS) &&
664            verifier.VerifyVector(fields()) &&
665            verifier.VerifyVectorOfTables(fields()) &&
666            verifier.EndTable();
667   }
668   ComposeExpressionT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
669   void UnPackTo(ComposeExpressionT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
670   static flatbuffers::Offset<ComposeExpression> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ComposeExpressionT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
671 };
672 
673 struct ComposeExpressionBuilder {
674   typedef ComposeExpression Table;
675   flatbuffers::FlatBufferBuilder &fbb_;
676   flatbuffers::uoffset_t start_;
677   void add_type(int32_t type) {
678     fbb_.AddElement<int32_t>(ComposeExpression::VT_TYPE, type, 0);
679   }
680   void add_fields(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::grammar::ComposeExpression_::Field>>> fields) {
681     fbb_.AddOffset(ComposeExpression::VT_FIELDS, fields);
682   }
683   explicit ComposeExpressionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
684         : fbb_(_fbb) {
685     start_ = fbb_.StartTable();
686   }
687   flatbuffers::Offset<ComposeExpression> Finish() {
688     const auto end = fbb_.EndTable(start_);
689     auto o = flatbuffers::Offset<ComposeExpression>(end);
690     return o;
691   }
692 };
693 
694 inline flatbuffers::Offset<ComposeExpression> CreateComposeExpression(
695     flatbuffers::FlatBufferBuilder &_fbb,
696     int32_t type = 0,
697     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::grammar::ComposeExpression_::Field>>> fields = 0) {
698   ComposeExpressionBuilder builder_(_fbb);
699   builder_.add_fields(fields);
700   builder_.add_type(type);
701   return builder_.Finish();
702 }
703 
704 inline flatbuffers::Offset<ComposeExpression> CreateComposeExpressionDirect(
705     flatbuffers::FlatBufferBuilder &_fbb,
706     int32_t type = 0,
707     const std::vector<flatbuffers::Offset<libtextclassifier3::grammar::ComposeExpression_::Field>> *fields = nullptr) {
708   auto fields__ = fields ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier3::grammar::ComposeExpression_::Field>>(*fields) : 0;
709   return libtextclassifier3::grammar::CreateComposeExpression(
710       _fbb,
711       type,
712       fields__);
713 }
714 
715 flatbuffers::Offset<ComposeExpression> CreateComposeExpression(flatbuffers::FlatBufferBuilder &_fbb, const ComposeExpressionT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
716 
717 struct SpanAsStringExpressionT : public flatbuffers::NativeTable {
718   typedef SpanAsStringExpression TableType;
719 };
720 
721 struct SpanAsStringExpression FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
722   typedef SpanAsStringExpressionT NativeTableType;
723   typedef SpanAsStringExpressionBuilder Builder;
724   bool Verify(flatbuffers::Verifier &verifier) const {
725     return VerifyTableStart(verifier) &&
726            verifier.EndTable();
727   }
728   SpanAsStringExpressionT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
729   void UnPackTo(SpanAsStringExpressionT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
730   static flatbuffers::Offset<SpanAsStringExpression> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpanAsStringExpressionT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
731 };
732 
733 struct SpanAsStringExpressionBuilder {
734   typedef SpanAsStringExpression Table;
735   flatbuffers::FlatBufferBuilder &fbb_;
736   flatbuffers::uoffset_t start_;
737   explicit SpanAsStringExpressionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
738         : fbb_(_fbb) {
739     start_ = fbb_.StartTable();
740   }
741   flatbuffers::Offset<SpanAsStringExpression> Finish() {
742     const auto end = fbb_.EndTable(start_);
743     auto o = flatbuffers::Offset<SpanAsStringExpression>(end);
744     return o;
745   }
746 };
747 
748 inline flatbuffers::Offset<SpanAsStringExpression> CreateSpanAsStringExpression(
749     flatbuffers::FlatBufferBuilder &_fbb) {
750   SpanAsStringExpressionBuilder builder_(_fbb);
751   return builder_.Finish();
752 }
753 
754 flatbuffers::Offset<SpanAsStringExpression> CreateSpanAsStringExpression(flatbuffers::FlatBufferBuilder &_fbb, const SpanAsStringExpressionT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
755 
756 struct ParseNumberExpressionT : public flatbuffers::NativeTable {
757   typedef ParseNumberExpression TableType;
758   int32_t base_type = 0;
759   std::unique_ptr<libtextclassifier3::grammar::SemanticExpressionT> value{};
760   ParseNumberExpressionT() = default;
761   ParseNumberExpressionT(const ParseNumberExpressionT &o);
762   ParseNumberExpressionT(ParseNumberExpressionT&&) FLATBUFFERS_NOEXCEPT = default;
763   ParseNumberExpressionT &operator=(ParseNumberExpressionT o) FLATBUFFERS_NOEXCEPT;
764 };
765 
766 struct ParseNumberExpression FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
767   typedef ParseNumberExpressionT NativeTableType;
768   typedef ParseNumberExpressionBuilder Builder;
769   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
770     VT_BASE_TYPE = 4,
771     VT_VALUE = 6
772   };
773   int32_t base_type() const {
774     return GetField<int32_t>(VT_BASE_TYPE, 0);
775   }
776   const libtextclassifier3::grammar::SemanticExpression *value() const {
777     return GetPointer<const libtextclassifier3::grammar::SemanticExpression *>(VT_VALUE);
778   }
779   bool Verify(flatbuffers::Verifier &verifier) const {
780     return VerifyTableStart(verifier) &&
781            VerifyField<int32_t>(verifier, VT_BASE_TYPE, 4) &&
782            VerifyOffset(verifier, VT_VALUE) &&
783            verifier.VerifyTable(value()) &&
784            verifier.EndTable();
785   }
786   ParseNumberExpressionT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
787   void UnPackTo(ParseNumberExpressionT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
788   static flatbuffers::Offset<ParseNumberExpression> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ParseNumberExpressionT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
789 };
790 
791 struct ParseNumberExpressionBuilder {
792   typedef ParseNumberExpression Table;
793   flatbuffers::FlatBufferBuilder &fbb_;
794   flatbuffers::uoffset_t start_;
795   void add_base_type(int32_t base_type) {
796     fbb_.AddElement<int32_t>(ParseNumberExpression::VT_BASE_TYPE, base_type, 0);
797   }
798   void add_value(flatbuffers::Offset<libtextclassifier3::grammar::SemanticExpression> value) {
799     fbb_.AddOffset(ParseNumberExpression::VT_VALUE, value);
800   }
801   explicit ParseNumberExpressionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
802         : fbb_(_fbb) {
803     start_ = fbb_.StartTable();
804   }
805   flatbuffers::Offset<ParseNumberExpression> Finish() {
806     const auto end = fbb_.EndTable(start_);
807     auto o = flatbuffers::Offset<ParseNumberExpression>(end);
808     return o;
809   }
810 };
811 
812 inline flatbuffers::Offset<ParseNumberExpression> CreateParseNumberExpression(
813     flatbuffers::FlatBufferBuilder &_fbb,
814     int32_t base_type = 0,
815     flatbuffers::Offset<libtextclassifier3::grammar::SemanticExpression> value = 0) {
816   ParseNumberExpressionBuilder builder_(_fbb);
817   builder_.add_value(value);
818   builder_.add_base_type(base_type);
819   return builder_.Finish();
820 }
821 
822 flatbuffers::Offset<ParseNumberExpression> CreateParseNumberExpression(flatbuffers::FlatBufferBuilder &_fbb, const ParseNumberExpressionT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
823 
824 struct MergeValueExpressionT : public flatbuffers::NativeTable {
825   typedef MergeValueExpression TableType;
826   int32_t type = 0;
827   std::vector<std::unique_ptr<libtextclassifier3::grammar::SemanticExpressionT>> values{};
828   MergeValueExpressionT() = default;
829   MergeValueExpressionT(const MergeValueExpressionT &o);
830   MergeValueExpressionT(MergeValueExpressionT&&) FLATBUFFERS_NOEXCEPT = default;
831   MergeValueExpressionT &operator=(MergeValueExpressionT o) FLATBUFFERS_NOEXCEPT;
832 };
833 
834 struct MergeValueExpression FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
835   typedef MergeValueExpressionT NativeTableType;
836   typedef MergeValueExpressionBuilder Builder;
837   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
838     VT_TYPE = 4,
839     VT_VALUES = 6
840   };
841   int32_t type() const {
842     return GetField<int32_t>(VT_TYPE, 0);
843   }
844   const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::grammar::SemanticExpression>> *values() const {
845     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::grammar::SemanticExpression>> *>(VT_VALUES);
846   }
847   bool Verify(flatbuffers::Verifier &verifier) const {
848     return VerifyTableStart(verifier) &&
849            VerifyField<int32_t>(verifier, VT_TYPE, 4) &&
850            VerifyOffset(verifier, VT_VALUES) &&
851            verifier.VerifyVector(values()) &&
852            verifier.VerifyVectorOfTables(values()) &&
853            verifier.EndTable();
854   }
855   MergeValueExpressionT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
856   void UnPackTo(MergeValueExpressionT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
857   static flatbuffers::Offset<MergeValueExpression> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MergeValueExpressionT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
858 };
859 
860 struct MergeValueExpressionBuilder {
861   typedef MergeValueExpression Table;
862   flatbuffers::FlatBufferBuilder &fbb_;
863   flatbuffers::uoffset_t start_;
864   void add_type(int32_t type) {
865     fbb_.AddElement<int32_t>(MergeValueExpression::VT_TYPE, type, 0);
866   }
867   void add_values(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::grammar::SemanticExpression>>> values) {
868     fbb_.AddOffset(MergeValueExpression::VT_VALUES, values);
869   }
870   explicit MergeValueExpressionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
871         : fbb_(_fbb) {
872     start_ = fbb_.StartTable();
873   }
874   flatbuffers::Offset<MergeValueExpression> Finish() {
875     const auto end = fbb_.EndTable(start_);
876     auto o = flatbuffers::Offset<MergeValueExpression>(end);
877     return o;
878   }
879 };
880 
881 inline flatbuffers::Offset<MergeValueExpression> CreateMergeValueExpression(
882     flatbuffers::FlatBufferBuilder &_fbb,
883     int32_t type = 0,
884     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::grammar::SemanticExpression>>> values = 0) {
885   MergeValueExpressionBuilder builder_(_fbb);
886   builder_.add_values(values);
887   builder_.add_type(type);
888   return builder_.Finish();
889 }
890 
891 inline flatbuffers::Offset<MergeValueExpression> CreateMergeValueExpressionDirect(
892     flatbuffers::FlatBufferBuilder &_fbb,
893     int32_t type = 0,
894     const std::vector<flatbuffers::Offset<libtextclassifier3::grammar::SemanticExpression>> *values = nullptr) {
895   auto values__ = values ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier3::grammar::SemanticExpression>>(*values) : 0;
896   return libtextclassifier3::grammar::CreateMergeValueExpression(
897       _fbb,
898       type,
899       values__);
900 }
901 
902 flatbuffers::Offset<MergeValueExpression> CreateMergeValueExpression(flatbuffers::FlatBufferBuilder &_fbb, const MergeValueExpressionT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
903 
904 struct ArithmeticExpressionT : public flatbuffers::NativeTable {
905   typedef ArithmeticExpression TableType;
906   int32_t base_type = 0;
907   libtextclassifier3::grammar::ArithmeticExpression_::Operator op = libtextclassifier3::grammar::ArithmeticExpression_::Operator_NO_OP;
908   std::vector<std::unique_ptr<libtextclassifier3::grammar::SemanticExpressionT>> values{};
909   ArithmeticExpressionT() = default;
910   ArithmeticExpressionT(const ArithmeticExpressionT &o);
911   ArithmeticExpressionT(ArithmeticExpressionT&&) FLATBUFFERS_NOEXCEPT = default;
912   ArithmeticExpressionT &operator=(ArithmeticExpressionT o) FLATBUFFERS_NOEXCEPT;
913 };
914 
915 struct ArithmeticExpression FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
916   typedef ArithmeticExpressionT NativeTableType;
917   typedef ArithmeticExpressionBuilder Builder;
918   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
919     VT_BASE_TYPE = 4,
920     VT_OP = 6,
921     VT_VALUES = 8
922   };
923   int32_t base_type() const {
924     return GetField<int32_t>(VT_BASE_TYPE, 0);
925   }
926   libtextclassifier3::grammar::ArithmeticExpression_::Operator op() const {
927     return static_cast<libtextclassifier3::grammar::ArithmeticExpression_::Operator>(GetField<int32_t>(VT_OP, 0));
928   }
929   const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::grammar::SemanticExpression>> *values() const {
930     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::grammar::SemanticExpression>> *>(VT_VALUES);
931   }
932   bool Verify(flatbuffers::Verifier &verifier) const {
933     return VerifyTableStart(verifier) &&
934            VerifyField<int32_t>(verifier, VT_BASE_TYPE, 4) &&
935            VerifyField<int32_t>(verifier, VT_OP, 4) &&
936            VerifyOffset(verifier, VT_VALUES) &&
937            verifier.VerifyVector(values()) &&
938            verifier.VerifyVectorOfTables(values()) &&
939            verifier.EndTable();
940   }
941   ArithmeticExpressionT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
942   void UnPackTo(ArithmeticExpressionT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
943   static flatbuffers::Offset<ArithmeticExpression> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArithmeticExpressionT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
944 };
945 
946 struct ArithmeticExpressionBuilder {
947   typedef ArithmeticExpression Table;
948   flatbuffers::FlatBufferBuilder &fbb_;
949   flatbuffers::uoffset_t start_;
950   void add_base_type(int32_t base_type) {
951     fbb_.AddElement<int32_t>(ArithmeticExpression::VT_BASE_TYPE, base_type, 0);
952   }
953   void add_op(libtextclassifier3::grammar::ArithmeticExpression_::Operator op) {
954     fbb_.AddElement<int32_t>(ArithmeticExpression::VT_OP, static_cast<int32_t>(op), 0);
955   }
956   void add_values(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::grammar::SemanticExpression>>> values) {
957     fbb_.AddOffset(ArithmeticExpression::VT_VALUES, values);
958   }
959   explicit ArithmeticExpressionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
960         : fbb_(_fbb) {
961     start_ = fbb_.StartTable();
962   }
963   flatbuffers::Offset<ArithmeticExpression> Finish() {
964     const auto end = fbb_.EndTable(start_);
965     auto o = flatbuffers::Offset<ArithmeticExpression>(end);
966     return o;
967   }
968 };
969 
970 inline flatbuffers::Offset<ArithmeticExpression> CreateArithmeticExpression(
971     flatbuffers::FlatBufferBuilder &_fbb,
972     int32_t base_type = 0,
973     libtextclassifier3::grammar::ArithmeticExpression_::Operator op = libtextclassifier3::grammar::ArithmeticExpression_::Operator_NO_OP,
974     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::grammar::SemanticExpression>>> values = 0) {
975   ArithmeticExpressionBuilder builder_(_fbb);
976   builder_.add_values(values);
977   builder_.add_op(op);
978   builder_.add_base_type(base_type);
979   return builder_.Finish();
980 }
981 
982 inline flatbuffers::Offset<ArithmeticExpression> CreateArithmeticExpressionDirect(
983     flatbuffers::FlatBufferBuilder &_fbb,
984     int32_t base_type = 0,
985     libtextclassifier3::grammar::ArithmeticExpression_::Operator op = libtextclassifier3::grammar::ArithmeticExpression_::Operator_NO_OP,
986     const std::vector<flatbuffers::Offset<libtextclassifier3::grammar::SemanticExpression>> *values = nullptr) {
987   auto values__ = values ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier3::grammar::SemanticExpression>>(*values) : 0;
988   return libtextclassifier3::grammar::CreateArithmeticExpression(
989       _fbb,
990       base_type,
991       op,
992       values__);
993 }
994 
995 flatbuffers::Offset<ArithmeticExpression> CreateArithmeticExpression(flatbuffers::FlatBufferBuilder &_fbb, const ArithmeticExpressionT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
996 
997 inline SemanticExpressionT *SemanticExpression::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
998   auto _o = std::unique_ptr<SemanticExpressionT>(new SemanticExpressionT());
999   UnPackTo(_o.get(), _resolver);
1000   return _o.release();
1001 }
1002 
1003 inline void SemanticExpression::UnPackTo(SemanticExpressionT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1004   (void)_o;
1005   (void)_resolver;
1006   { auto _e = expression_type(); _o->expression.type = _e; }
1007   { auto _e = expression(); if (_e) _o->expression.value = libtextclassifier3::grammar::SemanticExpression_::ExpressionUnion::UnPack(_e, expression_type(), _resolver); }
1008 }
1009 
1010 inline flatbuffers::Offset<SemanticExpression> SemanticExpression::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SemanticExpressionT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1011   return CreateSemanticExpression(_fbb, _o, _rehasher);
1012 }
1013 
1014 inline flatbuffers::Offset<SemanticExpression> CreateSemanticExpression(flatbuffers::FlatBufferBuilder &_fbb, const SemanticExpressionT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1015   (void)_rehasher;
1016   (void)_o;
1017   struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SemanticExpressionT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
1018   auto _expression_type = _o->expression.type;
1019   auto _expression = _o->expression.Pack(_fbb);
1020   return libtextclassifier3::grammar::CreateSemanticExpression(
1021       _fbb,
1022       _expression_type,
1023       _expression);
1024 }
1025 
1026 inline ConstValueExpressionT *ConstValueExpression::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1027   auto _o = std::unique_ptr<ConstValueExpressionT>(new ConstValueExpressionT());
1028   UnPackTo(_o.get(), _resolver);
1029   return _o.release();
1030 }
1031 
1032 inline void ConstValueExpression::UnPackTo(ConstValueExpressionT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1033   (void)_o;
1034   (void)_resolver;
1035   { auto _e = base_type(); _o->base_type = _e; }
1036   { auto _e = type(); _o->type = _e; }
1037   { auto _e = value(); if (_e) { _o->value.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->value.begin()); } }
1038 }
1039 
1040 inline flatbuffers::Offset<ConstValueExpression> ConstValueExpression::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConstValueExpressionT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1041   return CreateConstValueExpression(_fbb, _o, _rehasher);
1042 }
1043 
1044 inline flatbuffers::Offset<ConstValueExpression> CreateConstValueExpression(flatbuffers::FlatBufferBuilder &_fbb, const ConstValueExpressionT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1045   (void)_rehasher;
1046   (void)_o;
1047   struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ConstValueExpressionT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
1048   auto _base_type = _o->base_type;
1049   auto _type = _o->type;
1050   auto _value = _o->value.size() ? _fbb.CreateVector(_o->value) : 0;
1051   return libtextclassifier3::grammar::CreateConstValueExpression(
1052       _fbb,
1053       _base_type,
1054       _type,
1055       _value);
1056 }
1057 
1058 inline ConstituentExpressionT *ConstituentExpression::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1059   auto _o = std::unique_ptr<ConstituentExpressionT>(new ConstituentExpressionT());
1060   UnPackTo(_o.get(), _resolver);
1061   return _o.release();
1062 }
1063 
1064 inline void ConstituentExpression::UnPackTo(ConstituentExpressionT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1065   (void)_o;
1066   (void)_resolver;
1067   { auto _e = id(); _o->id = _e; }
1068 }
1069 
1070 inline flatbuffers::Offset<ConstituentExpression> ConstituentExpression::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConstituentExpressionT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1071   return CreateConstituentExpression(_fbb, _o, _rehasher);
1072 }
1073 
1074 inline flatbuffers::Offset<ConstituentExpression> CreateConstituentExpression(flatbuffers::FlatBufferBuilder &_fbb, const ConstituentExpressionT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1075   (void)_rehasher;
1076   (void)_o;
1077   struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ConstituentExpressionT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
1078   auto _id = _o->id;
1079   return libtextclassifier3::grammar::CreateConstituentExpression(
1080       _fbb,
1081       _id);
1082 }
1083 
1084 namespace ComposeExpression_ {
1085 
1086 inline FieldT::FieldT(const FieldT &o)
1087       : path((o.path) ? new libtextclassifier3::FlatbufferFieldPathT(*o.path) : nullptr),
1088         value((o.value) ? new libtextclassifier3::grammar::SemanticExpressionT(*o.value) : nullptr) {
1089 }
1090 
1091 inline FieldT &FieldT::operator=(FieldT o) FLATBUFFERS_NOEXCEPT {
1092   std::swap(path, o.path);
1093   std::swap(value, o.value);
1094   return *this;
1095 }
1096 
1097 inline FieldT *Field::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1098   auto _o = std::unique_ptr<FieldT>(new FieldT());
1099   UnPackTo(_o.get(), _resolver);
1100   return _o.release();
1101 }
1102 
1103 inline void Field::UnPackTo(FieldT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1104   (void)_o;
1105   (void)_resolver;
1106   { auto _e = path(); if (_e) _o->path = std::unique_ptr<libtextclassifier3::FlatbufferFieldPathT>(_e->UnPack(_resolver)); }
1107   { auto _e = value(); if (_e) _o->value = std::unique_ptr<libtextclassifier3::grammar::SemanticExpressionT>(_e->UnPack(_resolver)); }
1108 }
1109 
1110 inline flatbuffers::Offset<Field> Field::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FieldT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1111   return CreateField(_fbb, _o, _rehasher);
1112 }
1113 
1114 inline flatbuffers::Offset<Field> CreateField(flatbuffers::FlatBufferBuilder &_fbb, const FieldT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1115   (void)_rehasher;
1116   (void)_o;
1117   struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FieldT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
1118   auto _path = _o->path ? CreateFlatbufferFieldPath(_fbb, _o->path.get(), _rehasher) : 0;
1119   auto _value = _o->value ? CreateSemanticExpression(_fbb, _o->value.get(), _rehasher) : 0;
1120   return libtextclassifier3::grammar::ComposeExpression_::CreateField(
1121       _fbb,
1122       _path,
1123       _value);
1124 }
1125 
1126 }  // namespace ComposeExpression_
1127 
1128 inline ComposeExpressionT::ComposeExpressionT(const ComposeExpressionT &o)
1129       : type(o.type) {
1130   fields.reserve(o.fields.size());
1131   for (const auto &fields_ : o.fields) { fields.emplace_back((fields_) ? new libtextclassifier3::grammar::ComposeExpression_::FieldT(*fields_) : nullptr); }
1132 }
1133 
1134 inline ComposeExpressionT &ComposeExpressionT::operator=(ComposeExpressionT o) FLATBUFFERS_NOEXCEPT {
1135   std::swap(type, o.type);
1136   std::swap(fields, o.fields);
1137   return *this;
1138 }
1139 
1140 inline ComposeExpressionT *ComposeExpression::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1141   auto _o = std::unique_ptr<ComposeExpressionT>(new ComposeExpressionT());
1142   UnPackTo(_o.get(), _resolver);
1143   return _o.release();
1144 }
1145 
1146 inline void ComposeExpression::UnPackTo(ComposeExpressionT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1147   (void)_o;
1148   (void)_resolver;
1149   { auto _e = type(); _o->type = _e; }
1150   { auto _e = fields(); if (_e) { _o->fields.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->fields[_i] = std::unique_ptr<libtextclassifier3::grammar::ComposeExpression_::FieldT>(_e->Get(_i)->UnPack(_resolver)); } } }
1151 }
1152 
1153 inline flatbuffers::Offset<ComposeExpression> ComposeExpression::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ComposeExpressionT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1154   return CreateComposeExpression(_fbb, _o, _rehasher);
1155 }
1156 
1157 inline flatbuffers::Offset<ComposeExpression> CreateComposeExpression(flatbuffers::FlatBufferBuilder &_fbb, const ComposeExpressionT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1158   (void)_rehasher;
1159   (void)_o;
1160   struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ComposeExpressionT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
1161   auto _type = _o->type;
1162   auto _fields = _o->fields.size() ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier3::grammar::ComposeExpression_::Field>> (_o->fields.size(), [](size_t i, _VectorArgs *__va) { return CreateField(*__va->__fbb, __va->__o->fields[i].get(), __va->__rehasher); }, &_va ) : 0;
1163   return libtextclassifier3::grammar::CreateComposeExpression(
1164       _fbb,
1165       _type,
1166       _fields);
1167 }
1168 
1169 inline SpanAsStringExpressionT *SpanAsStringExpression::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1170   auto _o = std::unique_ptr<SpanAsStringExpressionT>(new SpanAsStringExpressionT());
1171   UnPackTo(_o.get(), _resolver);
1172   return _o.release();
1173 }
1174 
1175 inline void SpanAsStringExpression::UnPackTo(SpanAsStringExpressionT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1176   (void)_o;
1177   (void)_resolver;
1178 }
1179 
1180 inline flatbuffers::Offset<SpanAsStringExpression> SpanAsStringExpression::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpanAsStringExpressionT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1181   return CreateSpanAsStringExpression(_fbb, _o, _rehasher);
1182 }
1183 
1184 inline flatbuffers::Offset<SpanAsStringExpression> CreateSpanAsStringExpression(flatbuffers::FlatBufferBuilder &_fbb, const SpanAsStringExpressionT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1185   (void)_rehasher;
1186   (void)_o;
1187   struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SpanAsStringExpressionT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
1188   return libtextclassifier3::grammar::CreateSpanAsStringExpression(
1189       _fbb);
1190 }
1191 
1192 inline ParseNumberExpressionT::ParseNumberExpressionT(const ParseNumberExpressionT &o)
1193       : base_type(o.base_type),
1194         value((o.value) ? new libtextclassifier3::grammar::SemanticExpressionT(*o.value) : nullptr) {
1195 }
1196 
1197 inline ParseNumberExpressionT &ParseNumberExpressionT::operator=(ParseNumberExpressionT o) FLATBUFFERS_NOEXCEPT {
1198   std::swap(base_type, o.base_type);
1199   std::swap(value, o.value);
1200   return *this;
1201 }
1202 
1203 inline ParseNumberExpressionT *ParseNumberExpression::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1204   auto _o = std::unique_ptr<ParseNumberExpressionT>(new ParseNumberExpressionT());
1205   UnPackTo(_o.get(), _resolver);
1206   return _o.release();
1207 }
1208 
1209 inline void ParseNumberExpression::UnPackTo(ParseNumberExpressionT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1210   (void)_o;
1211   (void)_resolver;
1212   { auto _e = base_type(); _o->base_type = _e; }
1213   { auto _e = value(); if (_e) _o->value = std::unique_ptr<libtextclassifier3::grammar::SemanticExpressionT>(_e->UnPack(_resolver)); }
1214 }
1215 
1216 inline flatbuffers::Offset<ParseNumberExpression> ParseNumberExpression::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ParseNumberExpressionT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1217   return CreateParseNumberExpression(_fbb, _o, _rehasher);
1218 }
1219 
1220 inline flatbuffers::Offset<ParseNumberExpression> CreateParseNumberExpression(flatbuffers::FlatBufferBuilder &_fbb, const ParseNumberExpressionT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1221   (void)_rehasher;
1222   (void)_o;
1223   struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ParseNumberExpressionT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
1224   auto _base_type = _o->base_type;
1225   auto _value = _o->value ? CreateSemanticExpression(_fbb, _o->value.get(), _rehasher) : 0;
1226   return libtextclassifier3::grammar::CreateParseNumberExpression(
1227       _fbb,
1228       _base_type,
1229       _value);
1230 }
1231 
1232 inline MergeValueExpressionT::MergeValueExpressionT(const MergeValueExpressionT &o)
1233       : type(o.type) {
1234   values.reserve(o.values.size());
1235   for (const auto &values_ : o.values) { values.emplace_back((values_) ? new libtextclassifier3::grammar::SemanticExpressionT(*values_) : nullptr); }
1236 }
1237 
1238 inline MergeValueExpressionT &MergeValueExpressionT::operator=(MergeValueExpressionT o) FLATBUFFERS_NOEXCEPT {
1239   std::swap(type, o.type);
1240   std::swap(values, o.values);
1241   return *this;
1242 }
1243 
1244 inline MergeValueExpressionT *MergeValueExpression::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1245   auto _o = std::unique_ptr<MergeValueExpressionT>(new MergeValueExpressionT());
1246   UnPackTo(_o.get(), _resolver);
1247   return _o.release();
1248 }
1249 
1250 inline void MergeValueExpression::UnPackTo(MergeValueExpressionT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1251   (void)_o;
1252   (void)_resolver;
1253   { auto _e = type(); _o->type = _e; }
1254   { auto _e = values(); if (_e) { _o->values.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->values[_i] = std::unique_ptr<libtextclassifier3::grammar::SemanticExpressionT>(_e->Get(_i)->UnPack(_resolver)); } } }
1255 }
1256 
1257 inline flatbuffers::Offset<MergeValueExpression> MergeValueExpression::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MergeValueExpressionT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1258   return CreateMergeValueExpression(_fbb, _o, _rehasher);
1259 }
1260 
1261 inline flatbuffers::Offset<MergeValueExpression> CreateMergeValueExpression(flatbuffers::FlatBufferBuilder &_fbb, const MergeValueExpressionT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1262   (void)_rehasher;
1263   (void)_o;
1264   struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MergeValueExpressionT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
1265   auto _type = _o->type;
1266   auto _values = _o->values.size() ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier3::grammar::SemanticExpression>> (_o->values.size(), [](size_t i, _VectorArgs *__va) { return CreateSemanticExpression(*__va->__fbb, __va->__o->values[i].get(), __va->__rehasher); }, &_va ) : 0;
1267   return libtextclassifier3::grammar::CreateMergeValueExpression(
1268       _fbb,
1269       _type,
1270       _values);
1271 }
1272 
1273 inline ArithmeticExpressionT::ArithmeticExpressionT(const ArithmeticExpressionT &o)
1274       : base_type(o.base_type),
1275         op(o.op) {
1276   values.reserve(o.values.size());
1277   for (const auto &values_ : o.values) { values.emplace_back((values_) ? new libtextclassifier3::grammar::SemanticExpressionT(*values_) : nullptr); }
1278 }
1279 
1280 inline ArithmeticExpressionT &ArithmeticExpressionT::operator=(ArithmeticExpressionT o) FLATBUFFERS_NOEXCEPT {
1281   std::swap(base_type, o.base_type);
1282   std::swap(op, o.op);
1283   std::swap(values, o.values);
1284   return *this;
1285 }
1286 
1287 inline ArithmeticExpressionT *ArithmeticExpression::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1288   auto _o = std::unique_ptr<ArithmeticExpressionT>(new ArithmeticExpressionT());
1289   UnPackTo(_o.get(), _resolver);
1290   return _o.release();
1291 }
1292 
1293 inline void ArithmeticExpression::UnPackTo(ArithmeticExpressionT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1294   (void)_o;
1295   (void)_resolver;
1296   { auto _e = base_type(); _o->base_type = _e; }
1297   { auto _e = op(); _o->op = _e; }
1298   { auto _e = values(); if (_e) { _o->values.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->values[_i] = std::unique_ptr<libtextclassifier3::grammar::SemanticExpressionT>(_e->Get(_i)->UnPack(_resolver)); } } }
1299 }
1300 
1301 inline flatbuffers::Offset<ArithmeticExpression> ArithmeticExpression::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArithmeticExpressionT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1302   return CreateArithmeticExpression(_fbb, _o, _rehasher);
1303 }
1304 
1305 inline flatbuffers::Offset<ArithmeticExpression> CreateArithmeticExpression(flatbuffers::FlatBufferBuilder &_fbb, const ArithmeticExpressionT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1306   (void)_rehasher;
1307   (void)_o;
1308   struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ArithmeticExpressionT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
1309   auto _base_type = _o->base_type;
1310   auto _op = _o->op;
1311   auto _values = _o->values.size() ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier3::grammar::SemanticExpression>> (_o->values.size(), [](size_t i, _VectorArgs *__va) { return CreateSemanticExpression(*__va->__fbb, __va->__o->values[i].get(), __va->__rehasher); }, &_va ) : 0;
1312   return libtextclassifier3::grammar::CreateArithmeticExpression(
1313       _fbb,
1314       _base_type,
1315       _op,
1316       _values);
1317 }
1318 
1319 namespace SemanticExpression_ {
1320 
1321 inline bool VerifyExpression(flatbuffers::Verifier &verifier, const void *obj, Expression type) {
1322   switch (type) {
1323     case Expression_NONE: {
1324       return true;
1325     }
1326     case Expression_ConstValueExpression: {
1327       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::ConstValueExpression *>(obj);
1328       return verifier.VerifyTable(ptr);
1329     }
1330     case Expression_ConstituentExpression: {
1331       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::ConstituentExpression *>(obj);
1332       return verifier.VerifyTable(ptr);
1333     }
1334     case Expression_ComposeExpression: {
1335       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::ComposeExpression *>(obj);
1336       return verifier.VerifyTable(ptr);
1337     }
1338     case Expression_SpanAsStringExpression: {
1339       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::SpanAsStringExpression *>(obj);
1340       return verifier.VerifyTable(ptr);
1341     }
1342     case Expression_ParseNumberExpression: {
1343       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::ParseNumberExpression *>(obj);
1344       return verifier.VerifyTable(ptr);
1345     }
1346     case Expression_MergeValueExpression: {
1347       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::MergeValueExpression *>(obj);
1348       return verifier.VerifyTable(ptr);
1349     }
1350     case Expression_ArithmeticExpression: {
1351       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::ArithmeticExpression *>(obj);
1352       return verifier.VerifyTable(ptr);
1353     }
1354     default: return true;
1355   }
1356 }
1357 
1358 inline bool VerifyExpressionVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
1359   if (!values || !types) return !values && !types;
1360   if (values->size() != types->size()) return false;
1361   for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
1362     if (!VerifyExpression(
1363         verifier,  values->Get(i), types->GetEnum<Expression>(i))) {
1364       return false;
1365     }
1366   }
1367   return true;
1368 }
1369 
1370 inline void *ExpressionUnion::UnPack(const void *obj, Expression type, const flatbuffers::resolver_function_t *resolver) {
1371   (void)resolver;
1372   switch (type) {
1373     case Expression_ConstValueExpression: {
1374       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::ConstValueExpression *>(obj);
1375       return ptr->UnPack(resolver);
1376     }
1377     case Expression_ConstituentExpression: {
1378       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::ConstituentExpression *>(obj);
1379       return ptr->UnPack(resolver);
1380     }
1381     case Expression_ComposeExpression: {
1382       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::ComposeExpression *>(obj);
1383       return ptr->UnPack(resolver);
1384     }
1385     case Expression_SpanAsStringExpression: {
1386       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::SpanAsStringExpression *>(obj);
1387       return ptr->UnPack(resolver);
1388     }
1389     case Expression_ParseNumberExpression: {
1390       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::ParseNumberExpression *>(obj);
1391       return ptr->UnPack(resolver);
1392     }
1393     case Expression_MergeValueExpression: {
1394       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::MergeValueExpression *>(obj);
1395       return ptr->UnPack(resolver);
1396     }
1397     case Expression_ArithmeticExpression: {
1398       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::ArithmeticExpression *>(obj);
1399       return ptr->UnPack(resolver);
1400     }
1401     default: return nullptr;
1402   }
1403 }
1404 
1405 inline flatbuffers::Offset<void> ExpressionUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
1406   (void)_rehasher;
1407   switch (type) {
1408     case Expression_ConstValueExpression: {
1409       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::ConstValueExpressionT *>(value);
1410       return CreateConstValueExpression(_fbb, ptr, _rehasher).Union();
1411     }
1412     case Expression_ConstituentExpression: {
1413       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::ConstituentExpressionT *>(value);
1414       return CreateConstituentExpression(_fbb, ptr, _rehasher).Union();
1415     }
1416     case Expression_ComposeExpression: {
1417       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::ComposeExpressionT *>(value);
1418       return CreateComposeExpression(_fbb, ptr, _rehasher).Union();
1419     }
1420     case Expression_SpanAsStringExpression: {
1421       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::SpanAsStringExpressionT *>(value);
1422       return CreateSpanAsStringExpression(_fbb, ptr, _rehasher).Union();
1423     }
1424     case Expression_ParseNumberExpression: {
1425       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::ParseNumberExpressionT *>(value);
1426       return CreateParseNumberExpression(_fbb, ptr, _rehasher).Union();
1427     }
1428     case Expression_MergeValueExpression: {
1429       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::MergeValueExpressionT *>(value);
1430       return CreateMergeValueExpression(_fbb, ptr, _rehasher).Union();
1431     }
1432     case Expression_ArithmeticExpression: {
1433       auto ptr = reinterpret_cast<const libtextclassifier3::grammar::ArithmeticExpressionT *>(value);
1434       return CreateArithmeticExpression(_fbb, ptr, _rehasher).Union();
1435     }
1436     default: return 0;
1437   }
1438 }
1439 
1440 inline ExpressionUnion::ExpressionUnion(const ExpressionUnion &u) : type(u.type), value(nullptr) {
1441   switch (type) {
1442     case Expression_ConstValueExpression: {
1443       value = new libtextclassifier3::grammar::ConstValueExpressionT(*reinterpret_cast<libtextclassifier3::grammar::ConstValueExpressionT *>(u.value));
1444       break;
1445     }
1446     case Expression_ConstituentExpression: {
1447       value = new libtextclassifier3::grammar::ConstituentExpressionT(*reinterpret_cast<libtextclassifier3::grammar::ConstituentExpressionT *>(u.value));
1448       break;
1449     }
1450     case Expression_ComposeExpression: {
1451       value = new libtextclassifier3::grammar::ComposeExpressionT(*reinterpret_cast<libtextclassifier3::grammar::ComposeExpressionT *>(u.value));
1452       break;
1453     }
1454     case Expression_SpanAsStringExpression: {
1455       value = new libtextclassifier3::grammar::SpanAsStringExpressionT(*reinterpret_cast<libtextclassifier3::grammar::SpanAsStringExpressionT *>(u.value));
1456       break;
1457     }
1458     case Expression_ParseNumberExpression: {
1459       value = new libtextclassifier3::grammar::ParseNumberExpressionT(*reinterpret_cast<libtextclassifier3::grammar::ParseNumberExpressionT *>(u.value));
1460       break;
1461     }
1462     case Expression_MergeValueExpression: {
1463       value = new libtextclassifier3::grammar::MergeValueExpressionT(*reinterpret_cast<libtextclassifier3::grammar::MergeValueExpressionT *>(u.value));
1464       break;
1465     }
1466     case Expression_ArithmeticExpression: {
1467       value = new libtextclassifier3::grammar::ArithmeticExpressionT(*reinterpret_cast<libtextclassifier3::grammar::ArithmeticExpressionT *>(u.value));
1468       break;
1469     }
1470     default:
1471       break;
1472   }
1473 }
1474 
1475 inline void ExpressionUnion::Reset() {
1476   switch (type) {
1477     case Expression_ConstValueExpression: {
1478       auto ptr = reinterpret_cast<libtextclassifier3::grammar::ConstValueExpressionT *>(value);
1479       delete ptr;
1480       break;
1481     }
1482     case Expression_ConstituentExpression: {
1483       auto ptr = reinterpret_cast<libtextclassifier3::grammar::ConstituentExpressionT *>(value);
1484       delete ptr;
1485       break;
1486     }
1487     case Expression_ComposeExpression: {
1488       auto ptr = reinterpret_cast<libtextclassifier3::grammar::ComposeExpressionT *>(value);
1489       delete ptr;
1490       break;
1491     }
1492     case Expression_SpanAsStringExpression: {
1493       auto ptr = reinterpret_cast<libtextclassifier3::grammar::SpanAsStringExpressionT *>(value);
1494       delete ptr;
1495       break;
1496     }
1497     case Expression_ParseNumberExpression: {
1498       auto ptr = reinterpret_cast<libtextclassifier3::grammar::ParseNumberExpressionT *>(value);
1499       delete ptr;
1500       break;
1501     }
1502     case Expression_MergeValueExpression: {
1503       auto ptr = reinterpret_cast<libtextclassifier3::grammar::MergeValueExpressionT *>(value);
1504       delete ptr;
1505       break;
1506     }
1507     case Expression_ArithmeticExpression: {
1508       auto ptr = reinterpret_cast<libtextclassifier3::grammar::ArithmeticExpressionT *>(value);
1509       delete ptr;
1510       break;
1511     }
1512     default: break;
1513   }
1514   value = nullptr;
1515   type = Expression_NONE;
1516 }
1517 
1518 }  // namespace SemanticExpression_
1519 }  // namespace grammar
1520 }  // namespace libtextclassifier3
1521 
1522 #endif  // FLATBUFFERS_GENERATED_EXPRESSION_LIBTEXTCLASSIFIER3_GRAMMAR_H_
1523