1 // automatically generated by the FlatBuffers compiler, do not modify
2
3
4 #ifndef FLATBUFFERS_GENERATED_NAMESPACETEST2_NAMESPACEA_H_
5 #define FLATBUFFERS_GENERATED_NAMESPACETEST2_NAMESPACEA_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 namespace NamespaceA {
17
18 struct TableInFirstNS;
19 struct TableInFirstNSBuilder;
20 struct TableInFirstNST;
21
22 } // namespace NamespaceA
23
24 namespace NamespaceC {
25
26 struct TableInC;
27 struct TableInCBuilder;
28 struct TableInCT;
29
30 } // namespace NamespaceC
31
32 namespace NamespaceA {
33
34 struct SecondTableInA;
35 struct SecondTableInABuilder;
36 struct SecondTableInAT;
37
38 bool operator==(const TableInFirstNST &lhs, const TableInFirstNST &rhs);
39 bool operator!=(const TableInFirstNST &lhs, const TableInFirstNST &rhs);
40 } // namespace NamespaceA
41
42 namespace NamespaceC {
43
44 bool operator==(const TableInCT &lhs, const TableInCT &rhs);
45 bool operator!=(const TableInCT &lhs, const TableInCT &rhs);
46 } // namespace NamespaceC
47
48 namespace NamespaceA {
49
50 bool operator==(const SecondTableInAT &lhs, const SecondTableInAT &rhs);
51 bool operator!=(const SecondTableInAT &lhs, const SecondTableInAT &rhs);
52
53 inline const flatbuffers::TypeTable *TableInFirstNSTypeTable();
54
55 } // namespace NamespaceA
56
57 namespace NamespaceC {
58
59 inline const flatbuffers::TypeTable *TableInCTypeTable();
60
61 } // namespace NamespaceC
62
63 namespace NamespaceA {
64
65 inline const flatbuffers::TypeTable *SecondTableInATypeTable();
66
67 struct TableInFirstNST : public flatbuffers::NativeTable {
68 typedef TableInFirstNS TableType;
GetFullyQualifiedNameTableInFirstNST69 static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
70 return "NamespaceA.TableInFirstNST";
71 }
72 flatbuffers::unique_ptr<NamespaceA::NamespaceB::TableInNestedNST> foo_table{};
73 NamespaceA::NamespaceB::EnumInNestedNS foo_enum = NamespaceA::NamespaceB::EnumInNestedNS_A;
74 NamespaceA::NamespaceB::UnionInNestedNSUnion foo_union{};
75 flatbuffers::unique_ptr<NamespaceA::NamespaceB::StructInNestedNS> foo_struct{};
76 TableInFirstNST() = default;
77 TableInFirstNST(const TableInFirstNST &o);
78 TableInFirstNST(TableInFirstNST&&) FLATBUFFERS_NOEXCEPT = default;
79 TableInFirstNST &operator=(TableInFirstNST o) FLATBUFFERS_NOEXCEPT;
80 };
81
82 struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
83 typedef TableInFirstNST NativeTableType;
84 typedef TableInFirstNSBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS85 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
86 return TableInFirstNSTypeTable();
87 }
GetFullyQualifiedNameFLATBUFFERS_FINAL_CLASS88 static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
89 return "NamespaceA.TableInFirstNS";
90 }
91 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
92 VT_FOO_TABLE = 4,
93 VT_FOO_ENUM = 6,
94 VT_FOO_UNION_TYPE = 8,
95 VT_FOO_UNION = 10,
96 VT_FOO_STRUCT = 12
97 };
foo_tableFLATBUFFERS_FINAL_CLASS98 const NamespaceA::NamespaceB::TableInNestedNS *foo_table() const {
99 return GetPointer<const NamespaceA::NamespaceB::TableInNestedNS *>(VT_FOO_TABLE);
100 }
mutable_foo_tableFLATBUFFERS_FINAL_CLASS101 NamespaceA::NamespaceB::TableInNestedNS *mutable_foo_table() {
102 return GetPointer<NamespaceA::NamespaceB::TableInNestedNS *>(VT_FOO_TABLE);
103 }
foo_enumFLATBUFFERS_FINAL_CLASS104 NamespaceA::NamespaceB::EnumInNestedNS foo_enum() const {
105 return static_cast<NamespaceA::NamespaceB::EnumInNestedNS>(GetField<int8_t>(VT_FOO_ENUM, 0));
106 }
107 bool mutate_foo_enum(NamespaceA::NamespaceB::EnumInNestedNS _foo_enum = static_cast<NamespaceA::NamespaceB::EnumInNestedNS>(0)) {
108 return SetField<int8_t>(VT_FOO_ENUM, static_cast<int8_t>(_foo_enum), 0);
109 }
foo_union_typeFLATBUFFERS_FINAL_CLASS110 NamespaceA::NamespaceB::UnionInNestedNS foo_union_type() const {
111 return static_cast<NamespaceA::NamespaceB::UnionInNestedNS>(GetField<uint8_t>(VT_FOO_UNION_TYPE, 0));
112 }
foo_unionFLATBUFFERS_FINAL_CLASS113 const void *foo_union() const {
114 return GetPointer<const void *>(VT_FOO_UNION);
115 }
116 template<typename T> const T *foo_union_as() const;
foo_union_as_TableInNestedNSFLATBUFFERS_FINAL_CLASS117 const NamespaceA::NamespaceB::TableInNestedNS *foo_union_as_TableInNestedNS() const {
118 return foo_union_type() == NamespaceA::NamespaceB::UnionInNestedNS_TableInNestedNS ? static_cast<const NamespaceA::NamespaceB::TableInNestedNS *>(foo_union()) : nullptr;
119 }
mutable_foo_unionFLATBUFFERS_FINAL_CLASS120 void *mutable_foo_union() {
121 return GetPointer<void *>(VT_FOO_UNION);
122 }
foo_structFLATBUFFERS_FINAL_CLASS123 const NamespaceA::NamespaceB::StructInNestedNS *foo_struct() const {
124 return GetStruct<const NamespaceA::NamespaceB::StructInNestedNS *>(VT_FOO_STRUCT);
125 }
mutable_foo_structFLATBUFFERS_FINAL_CLASS126 NamespaceA::NamespaceB::StructInNestedNS *mutable_foo_struct() {
127 return GetStruct<NamespaceA::NamespaceB::StructInNestedNS *>(VT_FOO_STRUCT);
128 }
VerifyFLATBUFFERS_FINAL_CLASS129 bool Verify(flatbuffers::Verifier &verifier) const {
130 return VerifyTableStart(verifier) &&
131 VerifyOffset(verifier, VT_FOO_TABLE) &&
132 verifier.VerifyTable(foo_table()) &&
133 VerifyField<int8_t>(verifier, VT_FOO_ENUM, 1) &&
134 VerifyField<uint8_t>(verifier, VT_FOO_UNION_TYPE, 1) &&
135 VerifyOffset(verifier, VT_FOO_UNION) &&
136 VerifyUnionInNestedNS(verifier, foo_union(), foo_union_type()) &&
137 VerifyField<NamespaceA::NamespaceB::StructInNestedNS>(verifier, VT_FOO_STRUCT, 4) &&
138 verifier.EndTable();
139 }
140 TableInFirstNST *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
141 void UnPackTo(TableInFirstNST *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
142 static flatbuffers::Offset<TableInFirstNS> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
143 };
144
145 template<> inline const NamespaceA::NamespaceB::TableInNestedNS *TableInFirstNS::foo_union_as<NamespaceA::NamespaceB::TableInNestedNS>() const {
146 return foo_union_as_TableInNestedNS();
147 }
148
149 struct TableInFirstNSBuilder {
150 typedef TableInFirstNS Table;
151 flatbuffers::FlatBufferBuilder &fbb_;
152 flatbuffers::uoffset_t start_;
add_foo_tableTableInFirstNSBuilder153 void add_foo_table(flatbuffers::Offset<NamespaceA::NamespaceB::TableInNestedNS> foo_table) {
154 fbb_.AddOffset(TableInFirstNS::VT_FOO_TABLE, foo_table);
155 }
add_foo_enumTableInFirstNSBuilder156 void add_foo_enum(NamespaceA::NamespaceB::EnumInNestedNS foo_enum) {
157 fbb_.AddElement<int8_t>(TableInFirstNS::VT_FOO_ENUM, static_cast<int8_t>(foo_enum), 0);
158 }
add_foo_union_typeTableInFirstNSBuilder159 void add_foo_union_type(NamespaceA::NamespaceB::UnionInNestedNS foo_union_type) {
160 fbb_.AddElement<uint8_t>(TableInFirstNS::VT_FOO_UNION_TYPE, static_cast<uint8_t>(foo_union_type), 0);
161 }
add_foo_unionTableInFirstNSBuilder162 void add_foo_union(flatbuffers::Offset<void> foo_union) {
163 fbb_.AddOffset(TableInFirstNS::VT_FOO_UNION, foo_union);
164 }
add_foo_structTableInFirstNSBuilder165 void add_foo_struct(const NamespaceA::NamespaceB::StructInNestedNS *foo_struct) {
166 fbb_.AddStruct(TableInFirstNS::VT_FOO_STRUCT, foo_struct);
167 }
TableInFirstNSBuilderTableInFirstNSBuilder168 explicit TableInFirstNSBuilder(flatbuffers::FlatBufferBuilder &_fbb)
169 : fbb_(_fbb) {
170 start_ = fbb_.StartTable();
171 }
FinishTableInFirstNSBuilder172 flatbuffers::Offset<TableInFirstNS> Finish() {
173 const auto end = fbb_.EndTable(start_);
174 auto o = flatbuffers::Offset<TableInFirstNS>(end);
175 return o;
176 }
177 };
178
179 inline flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(
180 flatbuffers::FlatBufferBuilder &_fbb,
181 flatbuffers::Offset<NamespaceA::NamespaceB::TableInNestedNS> foo_table = 0,
182 NamespaceA::NamespaceB::EnumInNestedNS foo_enum = NamespaceA::NamespaceB::EnumInNestedNS_A,
183 NamespaceA::NamespaceB::UnionInNestedNS foo_union_type = NamespaceA::NamespaceB::UnionInNestedNS_NONE,
184 flatbuffers::Offset<void> foo_union = 0,
185 const NamespaceA::NamespaceB::StructInNestedNS *foo_struct = nullptr) {
186 TableInFirstNSBuilder builder_(_fbb);
187 builder_.add_foo_struct(foo_struct);
188 builder_.add_foo_union(foo_union);
189 builder_.add_foo_table(foo_table);
190 builder_.add_foo_union_type(foo_union_type);
191 builder_.add_foo_enum(foo_enum);
192 return builder_.Finish();
193 }
194
195 flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
196
197 } // namespace NamespaceA
198
199 namespace NamespaceC {
200
201 struct TableInCT : public flatbuffers::NativeTable {
202 typedef TableInC TableType;
GetFullyQualifiedNameTableInCT203 static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
204 return "NamespaceC.TableInCT";
205 }
206 flatbuffers::unique_ptr<NamespaceA::TableInFirstNST> refer_to_a1{};
207 flatbuffers::unique_ptr<NamespaceA::SecondTableInAT> refer_to_a2{};
208 TableInCT() = default;
209 TableInCT(const TableInCT &o);
210 TableInCT(TableInCT&&) FLATBUFFERS_NOEXCEPT = default;
211 TableInCT &operator=(TableInCT o) FLATBUFFERS_NOEXCEPT;
212 };
213
214 struct TableInC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
215 typedef TableInCT NativeTableType;
216 typedef TableInCBuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS217 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
218 return TableInCTypeTable();
219 }
GetFullyQualifiedNameFLATBUFFERS_FINAL_CLASS220 static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
221 return "NamespaceC.TableInC";
222 }
223 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
224 VT_REFER_TO_A1 = 4,
225 VT_REFER_TO_A2 = 6
226 };
refer_to_a1FLATBUFFERS_FINAL_CLASS227 const NamespaceA::TableInFirstNS *refer_to_a1() const {
228 return GetPointer<const NamespaceA::TableInFirstNS *>(VT_REFER_TO_A1);
229 }
mutable_refer_to_a1FLATBUFFERS_FINAL_CLASS230 NamespaceA::TableInFirstNS *mutable_refer_to_a1() {
231 return GetPointer<NamespaceA::TableInFirstNS *>(VT_REFER_TO_A1);
232 }
refer_to_a2FLATBUFFERS_FINAL_CLASS233 const NamespaceA::SecondTableInA *refer_to_a2() const {
234 return GetPointer<const NamespaceA::SecondTableInA *>(VT_REFER_TO_A2);
235 }
mutable_refer_to_a2FLATBUFFERS_FINAL_CLASS236 NamespaceA::SecondTableInA *mutable_refer_to_a2() {
237 return GetPointer<NamespaceA::SecondTableInA *>(VT_REFER_TO_A2);
238 }
VerifyFLATBUFFERS_FINAL_CLASS239 bool Verify(flatbuffers::Verifier &verifier) const {
240 return VerifyTableStart(verifier) &&
241 VerifyOffset(verifier, VT_REFER_TO_A1) &&
242 verifier.VerifyTable(refer_to_a1()) &&
243 VerifyOffset(verifier, VT_REFER_TO_A2) &&
244 verifier.VerifyTable(refer_to_a2()) &&
245 verifier.EndTable();
246 }
247 TableInCT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
248 void UnPackTo(TableInCT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
249 static flatbuffers::Offset<TableInC> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInCT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
250 };
251
252 struct TableInCBuilder {
253 typedef TableInC Table;
254 flatbuffers::FlatBufferBuilder &fbb_;
255 flatbuffers::uoffset_t start_;
add_refer_to_a1TableInCBuilder256 void add_refer_to_a1(flatbuffers::Offset<NamespaceA::TableInFirstNS> refer_to_a1) {
257 fbb_.AddOffset(TableInC::VT_REFER_TO_A1, refer_to_a1);
258 }
add_refer_to_a2TableInCBuilder259 void add_refer_to_a2(flatbuffers::Offset<NamespaceA::SecondTableInA> refer_to_a2) {
260 fbb_.AddOffset(TableInC::VT_REFER_TO_A2, refer_to_a2);
261 }
TableInCBuilderTableInCBuilder262 explicit TableInCBuilder(flatbuffers::FlatBufferBuilder &_fbb)
263 : fbb_(_fbb) {
264 start_ = fbb_.StartTable();
265 }
FinishTableInCBuilder266 flatbuffers::Offset<TableInC> Finish() {
267 const auto end = fbb_.EndTable(start_);
268 auto o = flatbuffers::Offset<TableInC>(end);
269 return o;
270 }
271 };
272
273 inline flatbuffers::Offset<TableInC> CreateTableInC(
274 flatbuffers::FlatBufferBuilder &_fbb,
275 flatbuffers::Offset<NamespaceA::TableInFirstNS> refer_to_a1 = 0,
276 flatbuffers::Offset<NamespaceA::SecondTableInA> refer_to_a2 = 0) {
277 TableInCBuilder builder_(_fbb);
278 builder_.add_refer_to_a2(refer_to_a2);
279 builder_.add_refer_to_a1(refer_to_a1);
280 return builder_.Finish();
281 }
282
283 flatbuffers::Offset<TableInC> CreateTableInC(flatbuffers::FlatBufferBuilder &_fbb, const TableInCT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
284
285 } // namespace NamespaceC
286
287 namespace NamespaceA {
288
289 struct SecondTableInAT : public flatbuffers::NativeTable {
290 typedef SecondTableInA TableType;
GetFullyQualifiedNameSecondTableInAT291 static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
292 return "NamespaceA.SecondTableInAT";
293 }
294 flatbuffers::unique_ptr<NamespaceC::TableInCT> refer_to_c{};
295 SecondTableInAT() = default;
296 SecondTableInAT(const SecondTableInAT &o);
297 SecondTableInAT(SecondTableInAT&&) FLATBUFFERS_NOEXCEPT = default;
298 SecondTableInAT &operator=(SecondTableInAT o) FLATBUFFERS_NOEXCEPT;
299 };
300
301 struct SecondTableInA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
302 typedef SecondTableInAT NativeTableType;
303 typedef SecondTableInABuilder Builder;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS304 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
305 return SecondTableInATypeTable();
306 }
GetFullyQualifiedNameFLATBUFFERS_FINAL_CLASS307 static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
308 return "NamespaceA.SecondTableInA";
309 }
310 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
311 VT_REFER_TO_C = 4
312 };
refer_to_cFLATBUFFERS_FINAL_CLASS313 const NamespaceC::TableInC *refer_to_c() const {
314 return GetPointer<const NamespaceC::TableInC *>(VT_REFER_TO_C);
315 }
mutable_refer_to_cFLATBUFFERS_FINAL_CLASS316 NamespaceC::TableInC *mutable_refer_to_c() {
317 return GetPointer<NamespaceC::TableInC *>(VT_REFER_TO_C);
318 }
VerifyFLATBUFFERS_FINAL_CLASS319 bool Verify(flatbuffers::Verifier &verifier) const {
320 return VerifyTableStart(verifier) &&
321 VerifyOffset(verifier, VT_REFER_TO_C) &&
322 verifier.VerifyTable(refer_to_c()) &&
323 verifier.EndTable();
324 }
325 SecondTableInAT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
326 void UnPackTo(SecondTableInAT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
327 static flatbuffers::Offset<SecondTableInA> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
328 };
329
330 struct SecondTableInABuilder {
331 typedef SecondTableInA Table;
332 flatbuffers::FlatBufferBuilder &fbb_;
333 flatbuffers::uoffset_t start_;
add_refer_to_cSecondTableInABuilder334 void add_refer_to_c(flatbuffers::Offset<NamespaceC::TableInC> refer_to_c) {
335 fbb_.AddOffset(SecondTableInA::VT_REFER_TO_C, refer_to_c);
336 }
SecondTableInABuilderSecondTableInABuilder337 explicit SecondTableInABuilder(flatbuffers::FlatBufferBuilder &_fbb)
338 : fbb_(_fbb) {
339 start_ = fbb_.StartTable();
340 }
FinishSecondTableInABuilder341 flatbuffers::Offset<SecondTableInA> Finish() {
342 const auto end = fbb_.EndTable(start_);
343 auto o = flatbuffers::Offset<SecondTableInA>(end);
344 return o;
345 }
346 };
347
348 inline flatbuffers::Offset<SecondTableInA> CreateSecondTableInA(
349 flatbuffers::FlatBufferBuilder &_fbb,
350 flatbuffers::Offset<NamespaceC::TableInC> refer_to_c = 0) {
351 SecondTableInABuilder builder_(_fbb);
352 builder_.add_refer_to_c(refer_to_c);
353 return builder_.Finish();
354 }
355
356 flatbuffers::Offset<SecondTableInA> CreateSecondTableInA(flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
357
358
359 inline bool operator==(const TableInFirstNST &lhs, const TableInFirstNST &rhs) {
360 return
361 ((lhs.foo_table == rhs.foo_table) || (lhs.foo_table && rhs.foo_table && *lhs.foo_table == *rhs.foo_table)) &&
362 (lhs.foo_enum == rhs.foo_enum) &&
363 (lhs.foo_union == rhs.foo_union) &&
364 ((lhs.foo_struct == rhs.foo_struct) || (lhs.foo_struct && rhs.foo_struct && *lhs.foo_struct == *rhs.foo_struct));
365 }
366
367 inline bool operator!=(const TableInFirstNST &lhs, const TableInFirstNST &rhs) {
368 return !(lhs == rhs);
369 }
370
371
TableInFirstNST(const TableInFirstNST & o)372 inline TableInFirstNST::TableInFirstNST(const TableInFirstNST &o)
373 : foo_table((o.foo_table) ? new NamespaceA::NamespaceB::TableInNestedNST(*o.foo_table) : nullptr),
374 foo_enum(o.foo_enum),
375 foo_union(o.foo_union),
376 foo_struct((o.foo_struct) ? new NamespaceA::NamespaceB::StructInNestedNS(*o.foo_struct) : nullptr) {
377 }
378
379 inline TableInFirstNST &TableInFirstNST::operator=(TableInFirstNST o) FLATBUFFERS_NOEXCEPT {
380 std::swap(foo_table, o.foo_table);
381 std::swap(foo_enum, o.foo_enum);
382 std::swap(foo_union, o.foo_union);
383 std::swap(foo_struct, o.foo_struct);
384 return *this;
385 }
386
UnPack(const flatbuffers::resolver_function_t * _resolver)387 inline TableInFirstNST *TableInFirstNS::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
388 auto _o = std::unique_ptr<TableInFirstNST>(new TableInFirstNST());
389 UnPackTo(_o.get(), _resolver);
390 return _o.release();
391 }
392
UnPackTo(TableInFirstNST * _o,const flatbuffers::resolver_function_t * _resolver)393 inline void TableInFirstNS::UnPackTo(TableInFirstNST *_o, const flatbuffers::resolver_function_t *_resolver) const {
394 (void)_o;
395 (void)_resolver;
396 { auto _e = foo_table(); if (_e) _o->foo_table = flatbuffers::unique_ptr<NamespaceA::NamespaceB::TableInNestedNST>(_e->UnPack(_resolver)); }
397 { auto _e = foo_enum(); _o->foo_enum = _e; }
398 { auto _e = foo_union_type(); _o->foo_union.type = _e; }
399 { auto _e = foo_union(); if (_e) _o->foo_union.value = NamespaceA::NamespaceB::UnionInNestedNSUnion::UnPack(_e, foo_union_type(), _resolver); }
400 { auto _e = foo_struct(); if (_e) _o->foo_struct = flatbuffers::unique_ptr<NamespaceA::NamespaceB::StructInNestedNS>(new NamespaceA::NamespaceB::StructInNestedNS(*_e)); }
401 }
402
Pack(flatbuffers::FlatBufferBuilder & _fbb,const TableInFirstNST * _o,const flatbuffers::rehasher_function_t * _rehasher)403 inline flatbuffers::Offset<TableInFirstNS> TableInFirstNS::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST* _o, const flatbuffers::rehasher_function_t *_rehasher) {
404 return CreateTableInFirstNS(_fbb, _o, _rehasher);
405 }
406
CreateTableInFirstNS(flatbuffers::FlatBufferBuilder & _fbb,const TableInFirstNST * _o,const flatbuffers::rehasher_function_t * _rehasher)407 inline flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST *_o, const flatbuffers::rehasher_function_t *_rehasher) {
408 (void)_rehasher;
409 (void)_o;
410 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TableInFirstNST* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
411 auto _foo_table = _o->foo_table ? CreateTableInNestedNS(_fbb, _o->foo_table.get(), _rehasher) : 0;
412 auto _foo_enum = _o->foo_enum;
413 auto _foo_union_type = _o->foo_union.type;
414 auto _foo_union = _o->foo_union.Pack(_fbb);
415 auto _foo_struct = _o->foo_struct ? _o->foo_struct.get() : nullptr;
416 return NamespaceA::CreateTableInFirstNS(
417 _fbb,
418 _foo_table,
419 _foo_enum,
420 _foo_union_type,
421 _foo_union,
422 _foo_struct);
423 }
424
425 } // namespace NamespaceA
426
427 namespace NamespaceC {
428
429
430 inline bool operator==(const TableInCT &lhs, const TableInCT &rhs) {
431 return
432 ((lhs.refer_to_a1 == rhs.refer_to_a1) || (lhs.refer_to_a1 && rhs.refer_to_a1 && *lhs.refer_to_a1 == *rhs.refer_to_a1)) &&
433 ((lhs.refer_to_a2 == rhs.refer_to_a2) || (lhs.refer_to_a2 && rhs.refer_to_a2 && *lhs.refer_to_a2 == *rhs.refer_to_a2));
434 }
435
436 inline bool operator!=(const TableInCT &lhs, const TableInCT &rhs) {
437 return !(lhs == rhs);
438 }
439
440
TableInCT(const TableInCT & o)441 inline TableInCT::TableInCT(const TableInCT &o)
442 : refer_to_a1((o.refer_to_a1) ? new NamespaceA::TableInFirstNST(*o.refer_to_a1) : nullptr),
443 refer_to_a2((o.refer_to_a2) ? new NamespaceA::SecondTableInAT(*o.refer_to_a2) : nullptr) {
444 }
445
446 inline TableInCT &TableInCT::operator=(TableInCT o) FLATBUFFERS_NOEXCEPT {
447 std::swap(refer_to_a1, o.refer_to_a1);
448 std::swap(refer_to_a2, o.refer_to_a2);
449 return *this;
450 }
451
UnPack(const flatbuffers::resolver_function_t * _resolver)452 inline TableInCT *TableInC::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
453 auto _o = std::unique_ptr<TableInCT>(new TableInCT());
454 UnPackTo(_o.get(), _resolver);
455 return _o.release();
456 }
457
UnPackTo(TableInCT * _o,const flatbuffers::resolver_function_t * _resolver)458 inline void TableInC::UnPackTo(TableInCT *_o, const flatbuffers::resolver_function_t *_resolver) const {
459 (void)_o;
460 (void)_resolver;
461 { auto _e = refer_to_a1(); if (_e) _o->refer_to_a1 = flatbuffers::unique_ptr<NamespaceA::TableInFirstNST>(_e->UnPack(_resolver)); }
462 { auto _e = refer_to_a2(); if (_e) _o->refer_to_a2 = flatbuffers::unique_ptr<NamespaceA::SecondTableInAT>(_e->UnPack(_resolver)); }
463 }
464
Pack(flatbuffers::FlatBufferBuilder & _fbb,const TableInCT * _o,const flatbuffers::rehasher_function_t * _rehasher)465 inline flatbuffers::Offset<TableInC> TableInC::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInCT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
466 return CreateTableInC(_fbb, _o, _rehasher);
467 }
468
CreateTableInC(flatbuffers::FlatBufferBuilder & _fbb,const TableInCT * _o,const flatbuffers::rehasher_function_t * _rehasher)469 inline flatbuffers::Offset<TableInC> CreateTableInC(flatbuffers::FlatBufferBuilder &_fbb, const TableInCT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
470 (void)_rehasher;
471 (void)_o;
472 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TableInCT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
473 auto _refer_to_a1 = _o->refer_to_a1 ? CreateTableInFirstNS(_fbb, _o->refer_to_a1.get(), _rehasher) : 0;
474 auto _refer_to_a2 = _o->refer_to_a2 ? CreateSecondTableInA(_fbb, _o->refer_to_a2.get(), _rehasher) : 0;
475 return NamespaceC::CreateTableInC(
476 _fbb,
477 _refer_to_a1,
478 _refer_to_a2);
479 }
480
481 } // namespace NamespaceC
482
483 namespace NamespaceA {
484
485
486 inline bool operator==(const SecondTableInAT &lhs, const SecondTableInAT &rhs) {
487 return
488 ((lhs.refer_to_c == rhs.refer_to_c) || (lhs.refer_to_c && rhs.refer_to_c && *lhs.refer_to_c == *rhs.refer_to_c));
489 }
490
491 inline bool operator!=(const SecondTableInAT &lhs, const SecondTableInAT &rhs) {
492 return !(lhs == rhs);
493 }
494
495
SecondTableInAT(const SecondTableInAT & o)496 inline SecondTableInAT::SecondTableInAT(const SecondTableInAT &o)
497 : refer_to_c((o.refer_to_c) ? new NamespaceC::TableInCT(*o.refer_to_c) : nullptr) {
498 }
499
500 inline SecondTableInAT &SecondTableInAT::operator=(SecondTableInAT o) FLATBUFFERS_NOEXCEPT {
501 std::swap(refer_to_c, o.refer_to_c);
502 return *this;
503 }
504
UnPack(const flatbuffers::resolver_function_t * _resolver)505 inline SecondTableInAT *SecondTableInA::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
506 auto _o = std::unique_ptr<SecondTableInAT>(new SecondTableInAT());
507 UnPackTo(_o.get(), _resolver);
508 return _o.release();
509 }
510
UnPackTo(SecondTableInAT * _o,const flatbuffers::resolver_function_t * _resolver)511 inline void SecondTableInA::UnPackTo(SecondTableInAT *_o, const flatbuffers::resolver_function_t *_resolver) const {
512 (void)_o;
513 (void)_resolver;
514 { auto _e = refer_to_c(); if (_e) _o->refer_to_c = flatbuffers::unique_ptr<NamespaceC::TableInCT>(_e->UnPack(_resolver)); }
515 }
516
Pack(flatbuffers::FlatBufferBuilder & _fbb,const SecondTableInAT * _o,const flatbuffers::rehasher_function_t * _rehasher)517 inline flatbuffers::Offset<SecondTableInA> SecondTableInA::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
518 return CreateSecondTableInA(_fbb, _o, _rehasher);
519 }
520
CreateSecondTableInA(flatbuffers::FlatBufferBuilder & _fbb,const SecondTableInAT * _o,const flatbuffers::rehasher_function_t * _rehasher)521 inline flatbuffers::Offset<SecondTableInA> CreateSecondTableInA(flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
522 (void)_rehasher;
523 (void)_o;
524 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SecondTableInAT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
525 auto _refer_to_c = _o->refer_to_c ? CreateTableInC(_fbb, _o->refer_to_c.get(), _rehasher) : 0;
526 return NamespaceA::CreateSecondTableInA(
527 _fbb,
528 _refer_to_c);
529 }
530
TableInFirstNSTypeTable()531 inline const flatbuffers::TypeTable *TableInFirstNSTypeTable() {
532 static const flatbuffers::TypeCode type_codes[] = {
533 { flatbuffers::ET_SEQUENCE, 0, 0 },
534 { flatbuffers::ET_CHAR, 0, 1 },
535 { flatbuffers::ET_UTYPE, 0, 2 },
536 { flatbuffers::ET_SEQUENCE, 0, 2 },
537 { flatbuffers::ET_SEQUENCE, 0, 3 }
538 };
539 static const flatbuffers::TypeFunction type_refs[] = {
540 NamespaceA::NamespaceB::TableInNestedNSTypeTable,
541 NamespaceA::NamespaceB::EnumInNestedNSTypeTable,
542 NamespaceA::NamespaceB::UnionInNestedNSTypeTable,
543 NamespaceA::NamespaceB::StructInNestedNSTypeTable
544 };
545 static const char * const names[] = {
546 "foo_table",
547 "foo_enum",
548 "foo_union_type",
549 "foo_union",
550 "foo_struct"
551 };
552 static const flatbuffers::TypeTable tt = {
553 flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names
554 };
555 return &tt;
556 }
557
558 } // namespace NamespaceA
559
560 namespace NamespaceC {
561
TableInCTypeTable()562 inline const flatbuffers::TypeTable *TableInCTypeTable() {
563 static const flatbuffers::TypeCode type_codes[] = {
564 { flatbuffers::ET_SEQUENCE, 0, 0 },
565 { flatbuffers::ET_SEQUENCE, 0, 1 }
566 };
567 static const flatbuffers::TypeFunction type_refs[] = {
568 NamespaceA::TableInFirstNSTypeTable,
569 NamespaceA::SecondTableInATypeTable
570 };
571 static const char * const names[] = {
572 "refer_to_a1",
573 "refer_to_a2"
574 };
575 static const flatbuffers::TypeTable tt = {
576 flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
577 };
578 return &tt;
579 }
580
581 } // namespace NamespaceC
582
583 namespace NamespaceA {
584
SecondTableInATypeTable()585 inline const flatbuffers::TypeTable *SecondTableInATypeTable() {
586 static const flatbuffers::TypeCode type_codes[] = {
587 { flatbuffers::ET_SEQUENCE, 0, 0 }
588 };
589 static const flatbuffers::TypeFunction type_refs[] = {
590 NamespaceC::TableInCTypeTable
591 };
592 static const char * const names[] = {
593 "refer_to_c"
594 };
595 static const flatbuffers::TypeTable tt = {
596 flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
597 };
598 return &tt;
599 }
600
601 } // namespace NamespaceA
602
603 #endif // FLATBUFFERS_GENERATED_NAMESPACETEST2_NAMESPACEA_H_
604