1 // automatically generated by the FlatBuffers compiler, do not modify
2
3
4 #ifndef FLATBUFFERS_GENERATED_NAMESPACETEST1_NAMESPACEA_NAMESPACEB_H_
5 #define FLATBUFFERS_GENERATED_NAMESPACETEST1_NAMESPACEA_NAMESPACEB_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 namespace NamespaceB {
18
19 struct TableInNestedNS;
20 struct TableInNestedNSBuilder;
21 struct TableInNestedNST;
22
23 struct StructInNestedNS;
24
25 bool operator==(const TableInNestedNST &lhs, const TableInNestedNST &rhs);
26 bool operator!=(const TableInNestedNST &lhs, const TableInNestedNST &rhs);
27 bool operator==(const StructInNestedNS &lhs, const StructInNestedNS &rhs);
28 bool operator!=(const StructInNestedNS &lhs, const StructInNestedNS &rhs);
29
30 inline const flatbuffers::TypeTable *TableInNestedNSTypeTable();
31
32 inline const flatbuffers::TypeTable *StructInNestedNSTypeTable();
33
34 enum UnionInNestedNS : uint8_t {
35 UnionInNestedNS_NONE = 0,
36 UnionInNestedNS_TableInNestedNS = 1,
37 UnionInNestedNS_MIN = UnionInNestedNS_NONE,
38 UnionInNestedNS_MAX = UnionInNestedNS_TableInNestedNS
39 };
40
EnumValuesUnionInNestedNS()41 inline const UnionInNestedNS (&EnumValuesUnionInNestedNS())[2] {
42 static const UnionInNestedNS values[] = {
43 UnionInNestedNS_NONE,
44 UnionInNestedNS_TableInNestedNS
45 };
46 return values;
47 }
48
EnumNamesUnionInNestedNS()49 inline const char * const *EnumNamesUnionInNestedNS() {
50 static const char * const names[3] = {
51 "NONE",
52 "TableInNestedNS",
53 nullptr
54 };
55 return names;
56 }
57
EnumNameUnionInNestedNS(UnionInNestedNS e)58 inline const char *EnumNameUnionInNestedNS(UnionInNestedNS e) {
59 if (flatbuffers::IsOutRange(e, UnionInNestedNS_NONE, UnionInNestedNS_TableInNestedNS)) return "";
60 const size_t index = static_cast<size_t>(e);
61 return EnumNamesUnionInNestedNS()[index];
62 }
63
64 template<typename T> struct UnionInNestedNSTraits {
65 static const UnionInNestedNS enum_value = UnionInNestedNS_NONE;
66 };
67
68 template<> struct UnionInNestedNSTraits<NamespaceA::NamespaceB::TableInNestedNS> {
69 static const UnionInNestedNS enum_value = UnionInNestedNS_TableInNestedNS;
70 };
71
72 template<typename T> struct UnionInNestedNSUnionTraits {
73 static const UnionInNestedNS enum_value = UnionInNestedNS_NONE;
74 };
75
76 template<> struct UnionInNestedNSUnionTraits<NamespaceA::NamespaceB::TableInNestedNST> {
77 static const UnionInNestedNS enum_value = UnionInNestedNS_TableInNestedNS;
78 };
79
80 struct UnionInNestedNSUnion {
81 UnionInNestedNS type;
82 void *value;
83
84 UnionInNestedNSUnion() : type(UnionInNestedNS_NONE), value(nullptr) {}
85 UnionInNestedNSUnion(UnionInNestedNSUnion&& u) FLATBUFFERS_NOEXCEPT :
86 type(UnionInNestedNS_NONE), value(nullptr)
87 { std::swap(type, u.type); std::swap(value, u.value); }
88 UnionInNestedNSUnion(const UnionInNestedNSUnion &);
89 UnionInNestedNSUnion &operator=(const UnionInNestedNSUnion &u)
90 { UnionInNestedNSUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
91 UnionInNestedNSUnion &operator=(UnionInNestedNSUnion &&u) FLATBUFFERS_NOEXCEPT
92 { std::swap(type, u.type); std::swap(value, u.value); return *this; }
93 ~UnionInNestedNSUnion() { Reset(); }
94
95 void Reset();
96
97 template <typename T>
98 void Set(T&& val) {
99 typedef typename std::remove_reference<T>::type RT;
100 Reset();
101 type = UnionInNestedNSUnionTraits<RT>::enum_value;
102 if (type != UnionInNestedNS_NONE) {
103 value = new RT(std::forward<T>(val));
104 }
105 }
106
107 static void *UnPack(const void *obj, UnionInNestedNS type, const flatbuffers::resolver_function_t *resolver);
108 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
109
110 NamespaceA::NamespaceB::TableInNestedNST *AsTableInNestedNS() {
111 return type == UnionInNestedNS_TableInNestedNS ?
112 reinterpret_cast<NamespaceA::NamespaceB::TableInNestedNST *>(value) : nullptr;
113 }
114 const NamespaceA::NamespaceB::TableInNestedNST *AsTableInNestedNS() const {
115 return type == UnionInNestedNS_TableInNestedNS ?
116 reinterpret_cast<const NamespaceA::NamespaceB::TableInNestedNST *>(value) : nullptr;
117 }
118 };
119
120
121 inline bool operator==(const UnionInNestedNSUnion &lhs, const UnionInNestedNSUnion &rhs) {
122 if (lhs.type != rhs.type) return false;
123 switch (lhs.type) {
124 case UnionInNestedNS_NONE: {
125 return true;
126 }
127 case UnionInNestedNS_TableInNestedNS: {
128 return *(reinterpret_cast<const NamespaceA::NamespaceB::TableInNestedNST *>(lhs.value)) ==
129 *(reinterpret_cast<const NamespaceA::NamespaceB::TableInNestedNST *>(rhs.value));
130 }
131 default: {
132 return false;
133 }
134 }
135 }
136
137 inline bool operator!=(const UnionInNestedNSUnion &lhs, const UnionInNestedNSUnion &rhs) {
138 return !(lhs == rhs);
139 }
140
141 bool VerifyUnionInNestedNS(flatbuffers::Verifier &verifier, const void *obj, UnionInNestedNS type);
142 bool VerifyUnionInNestedNSVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
143
144 enum EnumInNestedNS : int8_t {
145 EnumInNestedNS_A = 0,
146 EnumInNestedNS_B = 1,
147 EnumInNestedNS_C = 2,
148 EnumInNestedNS_MIN = EnumInNestedNS_A,
149 EnumInNestedNS_MAX = EnumInNestedNS_C
150 };
151
152 inline const EnumInNestedNS (&EnumValuesEnumInNestedNS())[3] {
153 static const EnumInNestedNS values[] = {
154 EnumInNestedNS_A,
155 EnumInNestedNS_B,
156 EnumInNestedNS_C
157 };
158 return values;
159 }
160
161 inline const char * const *EnumNamesEnumInNestedNS() {
162 static const char * const names[4] = {
163 "A",
164 "B",
165 "C",
166 nullptr
167 };
168 return names;
169 }
170
171 inline const char *EnumNameEnumInNestedNS(EnumInNestedNS e) {
172 if (flatbuffers::IsOutRange(e, EnumInNestedNS_A, EnumInNestedNS_C)) return "";
173 const size_t index = static_cast<size_t>(e);
174 return EnumNamesEnumInNestedNS()[index];
175 }
176
177 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) StructInNestedNS FLATBUFFERS_FINAL_CLASS {
178 private:
179 int32_t a_;
180 int32_t b_;
181
182 public:
183 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
184 return StructInNestedNSTypeTable();
185 }
186 static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
187 return "NamespaceA.NamespaceB.StructInNestedNS";
188 }
189 StructInNestedNS()
190 : a_(0),
191 b_(0) {
192 }
193 StructInNestedNS(int32_t _a, int32_t _b)
194 : a_(flatbuffers::EndianScalar(_a)),
195 b_(flatbuffers::EndianScalar(_b)) {
196 }
197 int32_t a() const {
198 return flatbuffers::EndianScalar(a_);
199 }
200 void mutate_a(int32_t _a) {
201 flatbuffers::WriteScalar(&a_, _a);
202 }
203 int32_t b() const {
204 return flatbuffers::EndianScalar(b_);
205 }
206 void mutate_b(int32_t _b) {
207 flatbuffers::WriteScalar(&b_, _b);
208 }
209 };
210 FLATBUFFERS_STRUCT_END(StructInNestedNS, 8);
211
212 inline bool operator==(const StructInNestedNS &lhs, const StructInNestedNS &rhs) {
213 return
214 (lhs.a() == rhs.a()) &&
215 (lhs.b() == rhs.b());
216 }
217
218 inline bool operator!=(const StructInNestedNS &lhs, const StructInNestedNS &rhs) {
219 return !(lhs == rhs);
220 }
221
222
223 struct TableInNestedNST : public flatbuffers::NativeTable {
224 typedef TableInNestedNS TableType;
225 static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
226 return "NamespaceA.NamespaceB.TableInNestedNST";
227 }
228 int32_t foo = 0;
229 };
230
231 struct TableInNestedNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
232 typedef TableInNestedNST NativeTableType;
233 typedef TableInNestedNSBuilder Builder;
234 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
235 return TableInNestedNSTypeTable();
236 }
237 static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
238 return "NamespaceA.NamespaceB.TableInNestedNS";
239 }
240 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
241 VT_FOO = 4
242 };
243 int32_t foo() const {
244 return GetField<int32_t>(VT_FOO, 0);
245 }
246 bool mutate_foo(int32_t _foo = 0) {
247 return SetField<int32_t>(VT_FOO, _foo, 0);
248 }
249 bool Verify(flatbuffers::Verifier &verifier) const {
250 return VerifyTableStart(verifier) &&
251 VerifyField<int32_t>(verifier, VT_FOO, 4) &&
252 verifier.EndTable();
253 }
254 TableInNestedNST *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
255 void UnPackTo(TableInNestedNST *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
256 static flatbuffers::Offset<TableInNestedNS> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
257 };
258
259 struct TableInNestedNSBuilder {
260 typedef TableInNestedNS Table;
261 flatbuffers::FlatBufferBuilder &fbb_;
262 flatbuffers::uoffset_t start_;
263 void add_foo(int32_t foo) {
264 fbb_.AddElement<int32_t>(TableInNestedNS::VT_FOO, foo, 0);
265 }
266 explicit TableInNestedNSBuilder(flatbuffers::FlatBufferBuilder &_fbb)
267 : fbb_(_fbb) {
268 start_ = fbb_.StartTable();
269 }
270 flatbuffers::Offset<TableInNestedNS> Finish() {
271 const auto end = fbb_.EndTable(start_);
272 auto o = flatbuffers::Offset<TableInNestedNS>(end);
273 return o;
274 }
275 };
276
277 inline flatbuffers::Offset<TableInNestedNS> CreateTableInNestedNS(
278 flatbuffers::FlatBufferBuilder &_fbb,
279 int32_t foo = 0) {
280 TableInNestedNSBuilder builder_(_fbb);
281 builder_.add_foo(foo);
282 return builder_.Finish();
283 }
284
285 flatbuffers::Offset<TableInNestedNS> CreateTableInNestedNS(flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
286
287
288 inline bool operator==(const TableInNestedNST &lhs, const TableInNestedNST &rhs) {
289 return
290 (lhs.foo == rhs.foo);
291 }
292
293 inline bool operator!=(const TableInNestedNST &lhs, const TableInNestedNST &rhs) {
294 return !(lhs == rhs);
295 }
296
297
298 inline TableInNestedNST *TableInNestedNS::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
299 auto _o = std::unique_ptr<TableInNestedNST>(new TableInNestedNST());
300 UnPackTo(_o.get(), _resolver);
301 return _o.release();
302 }
303
304 inline void TableInNestedNS::UnPackTo(TableInNestedNST *_o, const flatbuffers::resolver_function_t *_resolver) const {
305 (void)_o;
306 (void)_resolver;
307 { auto _e = foo(); _o->foo = _e; }
308 }
309
310 inline flatbuffers::Offset<TableInNestedNS> TableInNestedNS::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST* _o, const flatbuffers::rehasher_function_t *_rehasher) {
311 return CreateTableInNestedNS(_fbb, _o, _rehasher);
312 }
313
314 inline flatbuffers::Offset<TableInNestedNS> CreateTableInNestedNS(flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST *_o, const flatbuffers::rehasher_function_t *_rehasher) {
315 (void)_rehasher;
316 (void)_o;
317 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TableInNestedNST* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
318 auto _foo = _o->foo;
319 return NamespaceA::NamespaceB::CreateTableInNestedNS(
320 _fbb,
321 _foo);
322 }
323
324 inline bool VerifyUnionInNestedNS(flatbuffers::Verifier &verifier, const void *obj, UnionInNestedNS type) {
325 switch (type) {
326 case UnionInNestedNS_NONE: {
327 return true;
328 }
329 case UnionInNestedNS_TableInNestedNS: {
330 auto ptr = reinterpret_cast<const NamespaceA::NamespaceB::TableInNestedNS *>(obj);
331 return verifier.VerifyTable(ptr);
332 }
333 default: return true;
334 }
335 }
336
337 inline bool VerifyUnionInNestedNSVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
338 if (!values || !types) return !values && !types;
339 if (values->size() != types->size()) return false;
340 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
341 if (!VerifyUnionInNestedNS(
342 verifier, values->Get(i), types->GetEnum<UnionInNestedNS>(i))) {
343 return false;
344 }
345 }
346 return true;
347 }
348
349 inline void *UnionInNestedNSUnion::UnPack(const void *obj, UnionInNestedNS type, const flatbuffers::resolver_function_t *resolver) {
350 (void)resolver;
351 switch (type) {
352 case UnionInNestedNS_TableInNestedNS: {
353 auto ptr = reinterpret_cast<const NamespaceA::NamespaceB::TableInNestedNS *>(obj);
354 return ptr->UnPack(resolver);
355 }
356 default: return nullptr;
357 }
358 }
359
360 inline flatbuffers::Offset<void> UnionInNestedNSUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
361 (void)_rehasher;
362 switch (type) {
363 case UnionInNestedNS_TableInNestedNS: {
364 auto ptr = reinterpret_cast<const NamespaceA::NamespaceB::TableInNestedNST *>(value);
365 return CreateTableInNestedNS(_fbb, ptr, _rehasher).Union();
366 }
367 default: return 0;
368 }
369 }
370
371 inline UnionInNestedNSUnion::UnionInNestedNSUnion(const UnionInNestedNSUnion &u) : type(u.type), value(nullptr) {
372 switch (type) {
373 case UnionInNestedNS_TableInNestedNS: {
374 value = new NamespaceA::NamespaceB::TableInNestedNST(*reinterpret_cast<NamespaceA::NamespaceB::TableInNestedNST *>(u.value));
375 break;
376 }
377 default:
378 break;
379 }
380 }
381
382 inline void UnionInNestedNSUnion::Reset() {
383 switch (type) {
384 case UnionInNestedNS_TableInNestedNS: {
385 auto ptr = reinterpret_cast<NamespaceA::NamespaceB::TableInNestedNST *>(value);
386 delete ptr;
387 break;
388 }
389 default: break;
390 }
391 value = nullptr;
392 type = UnionInNestedNS_NONE;
393 }
394
395 inline const flatbuffers::TypeTable *UnionInNestedNSTypeTable() {
396 static const flatbuffers::TypeCode type_codes[] = {
397 { flatbuffers::ET_SEQUENCE, 0, -1 },
398 { flatbuffers::ET_SEQUENCE, 0, 0 }
399 };
400 static const flatbuffers::TypeFunction type_refs[] = {
401 NamespaceA::NamespaceB::TableInNestedNSTypeTable
402 };
403 static const char * const names[] = {
404 "NONE",
405 "TableInNestedNS"
406 };
407 static const flatbuffers::TypeTable tt = {
408 flatbuffers::ST_UNION, 2, type_codes, type_refs, nullptr, nullptr, names
409 };
410 return &tt;
411 }
412
413 inline const flatbuffers::TypeTable *EnumInNestedNSTypeTable() {
414 static const flatbuffers::TypeCode type_codes[] = {
415 { flatbuffers::ET_CHAR, 0, 0 },
416 { flatbuffers::ET_CHAR, 0, 0 },
417 { flatbuffers::ET_CHAR, 0, 0 }
418 };
419 static const flatbuffers::TypeFunction type_refs[] = {
420 NamespaceA::NamespaceB::EnumInNestedNSTypeTable
421 };
422 static const char * const names[] = {
423 "A",
424 "B",
425 "C"
426 };
427 static const flatbuffers::TypeTable tt = {
428 flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
429 };
430 return &tt;
431 }
432
433 inline const flatbuffers::TypeTable *TableInNestedNSTypeTable() {
434 static const flatbuffers::TypeCode type_codes[] = {
435 { flatbuffers::ET_INT, 0, -1 }
436 };
437 static const char * const names[] = {
438 "foo"
439 };
440 static const flatbuffers::TypeTable tt = {
441 flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
442 };
443 return &tt;
444 }
445
446 inline const flatbuffers::TypeTable *StructInNestedNSTypeTable() {
447 static const flatbuffers::TypeCode type_codes[] = {
448 { flatbuffers::ET_INT, 0, -1 },
449 { flatbuffers::ET_INT, 0, -1 }
450 };
451 static const int64_t values[] = { 0, 4, 8 };
452 static const char * const names[] = {
453 "a",
454 "b"
455 };
456 static const flatbuffers::TypeTable tt = {
457 flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names
458 };
459 return &tt;
460 }
461
462 } // namespace NamespaceB
463 } // namespace NamespaceA
464
465 #endif // FLATBUFFERS_GENERATED_NAMESPACETEST1_NAMESPACEA_NAMESPACEB_H_
466