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.
11static_assert(FLATBUFFERS_VERSION_MAJOR == 23 &&
12 FLATBUFFERS_VERSION_MINOR == 5 &&
13 FLATBUFFERS_VERSION_REVISION == 26,
14 "Non-compatible flatbuffers version included");
15
16namespace NamespaceA {
17
18struct TableInFirstNS;
19struct TableInFirstNSBuilder;
20struct TableInFirstNST;
21
22} // namespace NamespaceA
23
24namespace NamespaceC {
25
26struct TableInC;
27struct TableInCBuilder;
28struct TableInCT;
29
30} // namespace NamespaceC
31
32namespace NamespaceA {
33
34struct SecondTableInA;
35struct SecondTableInABuilder;
36struct SecondTableInAT;
37
38bool operator==(const TableInFirstNST &lhs, const TableInFirstNST &rhs);
39bool operator!=(const TableInFirstNST &lhs, const TableInFirstNST &rhs);
40} // namespace NamespaceA
41
42namespace NamespaceC {
43
44bool operator==(const TableInCT &lhs, const TableInCT &rhs);
45bool operator!=(const TableInCT &lhs, const TableInCT &rhs);
46} // namespace NamespaceC
47
48namespace NamespaceA {
49
50bool operator==(const SecondTableInAT &lhs, const SecondTableInAT &rhs);
51bool operator!=(const SecondTableInAT &lhs, const SecondTableInAT &rhs);
52
53inline const ::flatbuffers::TypeTable *TableInFirstNSTypeTable();
54
55} // namespace NamespaceA
56
57namespace NamespaceC {
58
59inline const ::flatbuffers::TypeTable *TableInCTypeTable();
60
61} // namespace NamespaceC
62
63namespace NamespaceA {
64
65inline const ::flatbuffers::TypeTable *SecondTableInATypeTable();
66
67struct TableInFirstNST : public ::flatbuffers::NativeTable {
68 typedef TableInFirstNS TableType;
69 static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
70 return "NamespaceA.TableInFirstNST";
71 }
72 std::unique_ptr<NamespaceA::NamespaceB::TableInNestedNST> foo_table{};
73 NamespaceA::NamespaceB::EnumInNestedNS foo_enum = NamespaceA::NamespaceB::EnumInNestedNS_A;
74 NamespaceA::NamespaceB::UnionInNestedNSUnion foo_union{};
75 std::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
82struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
83 typedef TableInFirstNST NativeTableType;
84 typedef TableInFirstNSBuilder Builder;
85 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
86 return TableInFirstNSTypeTable();
87 }
88 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 };
98 const NamespaceA::NamespaceB::TableInNestedNS *foo_table() const {
99 return GetPointer<const NamespaceA::NamespaceB::TableInNestedNS *>(VT_FOO_TABLE);
100 }
101 NamespaceA::NamespaceB::TableInNestedNS *mutable_foo_table() {
102 return GetPointer<NamespaceA::NamespaceB::TableInNestedNS *>(VT_FOO_TABLE);
103 }
104 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 }
110 NamespaceA::NamespaceB::UnionInNestedNS foo_union_type() const {
111 return static_cast<NamespaceA::NamespaceB::UnionInNestedNS>(GetField<uint8_t>(VT_FOO_UNION_TYPE, 0));
112 }
113 const void *foo_union() const {
114 return GetPointer<const void *>(VT_FOO_UNION);
115 }
116 template<typename T> const T *foo_union_as() const;
117 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 }
120 void *mutable_foo_union() {
121 return GetPointer<void *>(VT_FOO_UNION);
122 }
123 const NamespaceA::NamespaceB::StructInNestedNS *foo_struct() const {
124 return GetStruct<const NamespaceA::NamespaceB::StructInNestedNS *>(VT_FOO_STRUCT);
125 }
126 NamespaceA::NamespaceB::StructInNestedNS *mutable_foo_struct() {
127 return GetStruct<NamespaceA::NamespaceB::StructInNestedNS *>(VT_FOO_STRUCT);
128 }
129 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
145template<> inline const NamespaceA::NamespaceB::TableInNestedNS *TableInFirstNS::foo_union_as<NamespaceA::NamespaceB::TableInNestedNS>() const {
146 return foo_union_as_TableInNestedNS();
147}
148
149struct TableInFirstNSBuilder {
150 typedef TableInFirstNS Table;
151 ::flatbuffers::FlatBufferBuilder &fbb_;
152 ::flatbuffers::uoffset_t start_;
153 void add_foo_table(::flatbuffers::Offset<NamespaceA::NamespaceB::TableInNestedNS> foo_table) {
154 fbb_.AddOffset(TableInFirstNS::VT_FOO_TABLE, foo_table);
155 }
156 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 }
159 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 }
162 void add_foo_union(::flatbuffers::Offset<void> foo_union) {
163 fbb_.AddOffset(TableInFirstNS::VT_FOO_UNION, foo_union);
164 }
165 void add_foo_struct(const NamespaceA::NamespaceB::StructInNestedNS *foo_struct) {
166 fbb_.AddStruct(TableInFirstNS::VT_FOO_STRUCT, foo_struct);
167 }
168 explicit TableInFirstNSBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
169 : fbb_(_fbb) {
170 start_ = fbb_.StartTable();
171 }
172 ::flatbuffers::Offset<TableInFirstNS> Finish() {
173 const auto end = fbb_.EndTable(start_);
174 auto o = ::flatbuffers::Offset<TableInFirstNS>(end);
175 return o;
176 }
177};
178
179inline ::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
199namespace NamespaceC {
200
201struct TableInCT : public ::flatbuffers::NativeTable {
202 typedef TableInC TableType;
203 static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
204 return "NamespaceC.TableInCT";
205 }
206 std::unique_ptr<NamespaceA::TableInFirstNST> refer_to_a1{};
207 std::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
214struct TableInC FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
215 typedef TableInCT NativeTableType;
216 typedef TableInCBuilder Builder;
217 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
218 return TableInCTypeTable();
219 }
220 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 };
227 const NamespaceA::TableInFirstNS *refer_to_a1() const {
228 return GetPointer<const NamespaceA::TableInFirstNS *>(VT_REFER_TO_A1);
229 }
230 NamespaceA::TableInFirstNS *mutable_refer_to_a1() {
231 return GetPointer<NamespaceA::TableInFirstNS *>(VT_REFER_TO_A1);
232 }
233 const NamespaceA::SecondTableInA *refer_to_a2() const {
234 return GetPointer<const NamespaceA::SecondTableInA *>(VT_REFER_TO_A2);
235 }
236 NamespaceA::SecondTableInA *mutable_refer_to_a2() {
237 return GetPointer<NamespaceA::SecondTableInA *>(VT_REFER_TO_A2);
238 }
239 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
252struct TableInCBuilder {
253 typedef TableInC Table;
254 ::flatbuffers::FlatBufferBuilder &fbb_;
255 ::flatbuffers::uoffset_t start_;
256 void add_refer_to_a1(::flatbuffers::Offset<NamespaceA::TableInFirstNS> refer_to_a1) {
257 fbb_.AddOffset(TableInC::VT_REFER_TO_A1, refer_to_a1);
258 }
259 void add_refer_to_a2(::flatbuffers::Offset<NamespaceA::SecondTableInA> refer_to_a2) {
260 fbb_.AddOffset(TableInC::VT_REFER_TO_A2, refer_to_a2);
261 }
262 explicit TableInCBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
263 : fbb_(_fbb) {
264 start_ = fbb_.StartTable();
265 }
266 ::flatbuffers::Offset<TableInC> Finish() {
267 const auto end = fbb_.EndTable(start_);
268 auto o = ::flatbuffers::Offset<TableInC>(end);
269 return o;
270 }
271};
272
273inline ::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
287namespace NamespaceA {
288
289struct SecondTableInAT : public ::flatbuffers::NativeTable {
290 typedef SecondTableInA TableType;
291 static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
292 return "NamespaceA.SecondTableInAT";
293 }
294 std::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
301struct SecondTableInA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
302 typedef SecondTableInAT NativeTableType;
303 typedef SecondTableInABuilder Builder;
304 static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
305 return SecondTableInATypeTable();
306 }
307 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 };
313 const NamespaceC::TableInC *refer_to_c() const {
314 return GetPointer<const NamespaceC::TableInC *>(VT_REFER_TO_C);
315 }
316 NamespaceC::TableInC *mutable_refer_to_c() {
317 return GetPointer<NamespaceC::TableInC *>(VT_REFER_TO_C);
318 }
319 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
330struct SecondTableInABuilder {
331 typedef SecondTableInA Table;
332 ::flatbuffers::FlatBufferBuilder &fbb_;
333 ::flatbuffers::uoffset_t start_;
334 void add_refer_to_c(::flatbuffers::Offset<NamespaceC::TableInC> refer_to_c) {
335 fbb_.AddOffset(SecondTableInA::VT_REFER_TO_C, refer_to_c);
336 }
337 explicit SecondTableInABuilder(::flatbuffers::FlatBufferBuilder &_fbb)
338 : fbb_(_fbb) {
339 start_ = fbb_.StartTable();
340 }
341 ::flatbuffers::Offset<SecondTableInA> Finish() {
342 const auto end = fbb_.EndTable(start_);
343 auto o = ::flatbuffers::Offset<SecondTableInA>(end);
344 return o;
345 }
346};
347
348inline ::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
359inline 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
367inline bool operator!=(const TableInFirstNST &lhs, const TableInFirstNST &rhs) {
368 return !(lhs == rhs);
369}
370
371
372inline 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
379inline 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
387inline 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
393inline 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) { if(_o->foo_table) { _e->UnPackTo(_o->foo_table.get(), _resolver); } else { _o->foo_table = std::unique_ptr<NamespaceA::NamespaceB::TableInNestedNST>(_e->UnPack(_resolver)); } } else if (_o->foo_table) { _o->foo_table.reset(); } }
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 = std::unique_ptr<NamespaceA::NamespaceB::StructInNestedNS>(new NamespaceA::NamespaceB::StructInNestedNS(*_e)); }
401}
402
403inline ::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
407inline ::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
427namespace NamespaceC {
428
429
430inline 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
436inline bool operator!=(const TableInCT &lhs, const TableInCT &rhs) {
437 return !(lhs == rhs);
438}
439
440
441inline 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
446inline 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
452inline 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
458inline 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) { if(_o->refer_to_a1) { _e->UnPackTo(_o->refer_to_a1.get(), _resolver); } else { _o->refer_to_a1 = std::unique_ptr<NamespaceA::TableInFirstNST>(_e->UnPack(_resolver)); } } else if (_o->refer_to_a1) { _o->refer_to_a1.reset(); } }
462 { auto _e = refer_to_a2(); if (_e) { if(_o->refer_to_a2) { _e->UnPackTo(_o->refer_to_a2.get(), _resolver); } else { _o->refer_to_a2 = std::unique_ptr<NamespaceA::SecondTableInAT>(_e->UnPack(_resolver)); } } else if (_o->refer_to_a2) { _o->refer_to_a2.reset(); } }
463}
464
465inline ::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
469inline ::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
483namespace NamespaceA {
484
485
486inline 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
491inline bool operator!=(const SecondTableInAT &lhs, const SecondTableInAT &rhs) {
492 return !(lhs == rhs);
493}
494
495
496inline SecondTableInAT::SecondTableInAT(const SecondTableInAT &o)
497 : refer_to_c((o.refer_to_c) ? new NamespaceC::TableInCT(*o.refer_to_c) : nullptr) {
498}
499
500inline SecondTableInAT &SecondTableInAT::operator=(SecondTableInAT o) FLATBUFFERS_NOEXCEPT {
501 std::swap(refer_to_c, o.refer_to_c);
502 return *this;
503}
504
505inline 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
511inline 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) { if(_o->refer_to_c) { _e->UnPackTo(_o->refer_to_c.get(), _resolver); } else { _o->refer_to_c = std::unique_ptr<NamespaceC::TableInCT>(_e->UnPack(_resolver)); } } else if (_o->refer_to_c) { _o->refer_to_c.reset(); } }
515}
516
517inline ::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
521inline ::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
531inline 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
560namespace NamespaceC {
561
562inline 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
583namespace NamespaceA {
584
585inline 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_
View as plain text