Home | History | Annotate | Download | only in namespace_test 
      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 #include "namespace_test1_generated.h"
     10 
     11 namespace NamespaceA {
     12 
     13 struct TableInFirstNS;
     14 
     15 }  // namespace NamespaceA
     16 
     17 namespace NamespaceC {
     18 
     19 struct TableInC;
     20 
     21 }  // namespace NamespaceC
     22 
     23 namespace NamespaceA {
     24 
     25 struct SecondTableInA;
     26 
     27 inline const flatbuffers::TypeTable *TableInFirstNSTypeTable();
     28 
     29 }  // namespace NamespaceA
     30 
     31 namespace NamespaceC {
     32 
     33 inline const flatbuffers::TypeTable *TableInCTypeTable();
     34 
     35 }  // namespace NamespaceC
     36 
     37 namespace NamespaceA {
     38 
     39 inline const flatbuffers::TypeTable *SecondTableInATypeTable();
     40 
     41 struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     42   static const flatbuffers::TypeTable *MiniReflectTypeTable() {
     43     return TableInFirstNSTypeTable();
     44   }
     45   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     46     VT_FOO_TABLE = 4,
     47     VT_FOO_ENUM = 6,
     48     VT_FOO_STRUCT = 8
     49   };
     50   const NamespaceA::NamespaceB::TableInNestedNS *foo_table() const {
     51     return GetPointer<const NamespaceA::NamespaceB::TableInNestedNS *>(VT_FOO_TABLE);
     52   }
     53   NamespaceA::NamespaceB::TableInNestedNS *mutable_foo_table() {
     54     return GetPointer<NamespaceA::NamespaceB::TableInNestedNS *>(VT_FOO_TABLE);
     55   }
     56   NamespaceA::NamespaceB::EnumInNestedNS foo_enum() const {
     57     return static_cast<NamespaceA::NamespaceB::EnumInNestedNS>(GetField<int8_t>(VT_FOO_ENUM, 0));
     58   }
     59   bool mutate_foo_enum(NamespaceA::NamespaceB::EnumInNestedNS _foo_enum) {
     60     return SetField<int8_t>(VT_FOO_ENUM, static_cast<int8_t>(_foo_enum), 0);
     61   }
     62   const NamespaceA::NamespaceB::StructInNestedNS *foo_struct() const {
     63     return GetStruct<const NamespaceA::NamespaceB::StructInNestedNS *>(VT_FOO_STRUCT);
     64   }
     65   NamespaceA::NamespaceB::StructInNestedNS *mutable_foo_struct() {
     66     return GetStruct<NamespaceA::NamespaceB::StructInNestedNS *>(VT_FOO_STRUCT);
     67   }
     68   bool Verify(flatbuffers::Verifier &verifier) const {
     69     return VerifyTableStart(verifier) &&
     70            VerifyOffset(verifier, VT_FOO_TABLE) &&
     71            verifier.VerifyTable(foo_table()) &&
     72            VerifyField<int8_t>(verifier, VT_FOO_ENUM) &&
     73            VerifyField<NamespaceA::NamespaceB::StructInNestedNS>(verifier, VT_FOO_STRUCT) &&
     74            verifier.EndTable();
     75   }
     76 };
     77 
     78 struct TableInFirstNSBuilder {
     79   flatbuffers::FlatBufferBuilder &fbb_;
     80   flatbuffers::uoffset_t start_;
     81   void add_foo_table(flatbuffers::Offset<NamespaceA::NamespaceB::TableInNestedNS> foo_table) {
     82     fbb_.AddOffset(TableInFirstNS::VT_FOO_TABLE, foo_table);
     83   }
     84   void add_foo_enum(NamespaceA::NamespaceB::EnumInNestedNS foo_enum) {
     85     fbb_.AddElement<int8_t>(TableInFirstNS::VT_FOO_ENUM, static_cast<int8_t>(foo_enum), 0);
     86   }
     87   void add_foo_struct(const NamespaceA::NamespaceB::StructInNestedNS *foo_struct) {
     88     fbb_.AddStruct(TableInFirstNS::VT_FOO_STRUCT, foo_struct);
     89   }
     90   explicit TableInFirstNSBuilder(flatbuffers::FlatBufferBuilder &_fbb)
     91         : fbb_(_fbb) {
     92     start_ = fbb_.StartTable();
     93   }
     94   TableInFirstNSBuilder &operator=(const TableInFirstNSBuilder &);
     95   flatbuffers::Offset<TableInFirstNS> Finish() {
     96     const auto end = fbb_.EndTable(start_);
     97     auto o = flatbuffers::Offset<TableInFirstNS>(end);
     98     return o;
     99   }
    100 };
    101 
    102 inline flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(
    103     flatbuffers::FlatBufferBuilder &_fbb,
    104     flatbuffers::Offset<NamespaceA::NamespaceB::TableInNestedNS> foo_table = 0,
    105     NamespaceA::NamespaceB::EnumInNestedNS foo_enum = NamespaceA::NamespaceB::EnumInNestedNS_A,
    106     const NamespaceA::NamespaceB::StructInNestedNS *foo_struct = 0) {
    107   TableInFirstNSBuilder builder_(_fbb);
    108   builder_.add_foo_struct(foo_struct);
    109   builder_.add_foo_table(foo_table);
    110   builder_.add_foo_enum(foo_enum);
    111   return builder_.Finish();
    112 }
    113 
    114 }  // namespace NamespaceA
    115 
    116 namespace NamespaceC {
    117 
    118 struct TableInC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    119   static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    120     return TableInCTypeTable();
    121   }
    122   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    123     VT_REFER_TO_A1 = 4,
    124     VT_REFER_TO_A2 = 6
    125   };
    126   const NamespaceA::TableInFirstNS *refer_to_a1() const {
    127     return GetPointer<const NamespaceA::TableInFirstNS *>(VT_REFER_TO_A1);
    128   }
    129   NamespaceA::TableInFirstNS *mutable_refer_to_a1() {
    130     return GetPointer<NamespaceA::TableInFirstNS *>(VT_REFER_TO_A1);
    131   }
    132   const NamespaceA::SecondTableInA *refer_to_a2() const {
    133     return GetPointer<const NamespaceA::SecondTableInA *>(VT_REFER_TO_A2);
    134   }
    135   NamespaceA::SecondTableInA *mutable_refer_to_a2() {
    136     return GetPointer<NamespaceA::SecondTableInA *>(VT_REFER_TO_A2);
    137   }
    138   bool Verify(flatbuffers::Verifier &verifier) const {
    139     return VerifyTableStart(verifier) &&
    140            VerifyOffset(verifier, VT_REFER_TO_A1) &&
    141            verifier.VerifyTable(refer_to_a1()) &&
    142            VerifyOffset(verifier, VT_REFER_TO_A2) &&
    143            verifier.VerifyTable(refer_to_a2()) &&
    144            verifier.EndTable();
    145   }
    146 };
    147 
    148 struct TableInCBuilder {
    149   flatbuffers::FlatBufferBuilder &fbb_;
    150   flatbuffers::uoffset_t start_;
    151   void add_refer_to_a1(flatbuffers::Offset<NamespaceA::TableInFirstNS> refer_to_a1) {
    152     fbb_.AddOffset(TableInC::VT_REFER_TO_A1, refer_to_a1);
    153   }
    154   void add_refer_to_a2(flatbuffers::Offset<NamespaceA::SecondTableInA> refer_to_a2) {
    155     fbb_.AddOffset(TableInC::VT_REFER_TO_A2, refer_to_a2);
    156   }
    157   explicit TableInCBuilder(flatbuffers::FlatBufferBuilder &_fbb)
    158         : fbb_(_fbb) {
    159     start_ = fbb_.StartTable();
    160   }
    161   TableInCBuilder &operator=(const TableInCBuilder &);
    162   flatbuffers::Offset<TableInC> Finish() {
    163     const auto end = fbb_.EndTable(start_);
    164     auto o = flatbuffers::Offset<TableInC>(end);
    165     return o;
    166   }
    167 };
    168 
    169 inline flatbuffers::Offset<TableInC> CreateTableInC(
    170     flatbuffers::FlatBufferBuilder &_fbb,
    171     flatbuffers::Offset<NamespaceA::TableInFirstNS> refer_to_a1 = 0,
    172     flatbuffers::Offset<NamespaceA::SecondTableInA> refer_to_a2 = 0) {
    173   TableInCBuilder builder_(_fbb);
    174   builder_.add_refer_to_a2(refer_to_a2);
    175   builder_.add_refer_to_a1(refer_to_a1);
    176   return builder_.Finish();
    177 }
    178 
    179 }  // namespace NamespaceC
    180 
    181 namespace NamespaceA {
    182 
    183 struct SecondTableInA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    184   static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    185     return SecondTableInATypeTable();
    186   }
    187   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    188     VT_REFER_TO_C = 4
    189   };
    190   const NamespaceC::TableInC *refer_to_c() const {
    191     return GetPointer<const NamespaceC::TableInC *>(VT_REFER_TO_C);
    192   }
    193   NamespaceC::TableInC *mutable_refer_to_c() {
    194     return GetPointer<NamespaceC::TableInC *>(VT_REFER_TO_C);
    195   }
    196   bool Verify(flatbuffers::Verifier &verifier) const {
    197     return VerifyTableStart(verifier) &&
    198            VerifyOffset(verifier, VT_REFER_TO_C) &&
    199            verifier.VerifyTable(refer_to_c()) &&
    200            verifier.EndTable();
    201   }
    202 };
    203 
    204 struct SecondTableInABuilder {
    205   flatbuffers::FlatBufferBuilder &fbb_;
    206   flatbuffers::uoffset_t start_;
    207   void add_refer_to_c(flatbuffers::Offset<NamespaceC::TableInC> refer_to_c) {
    208     fbb_.AddOffset(SecondTableInA::VT_REFER_TO_C, refer_to_c);
    209   }
    210   explicit SecondTableInABuilder(flatbuffers::FlatBufferBuilder &_fbb)
    211         : fbb_(_fbb) {
    212     start_ = fbb_.StartTable();
    213   }
    214   SecondTableInABuilder &operator=(const SecondTableInABuilder &);
    215   flatbuffers::Offset<SecondTableInA> Finish() {
    216     const auto end = fbb_.EndTable(start_);
    217     auto o = flatbuffers::Offset<SecondTableInA>(end);
    218     return o;
    219   }
    220 };
    221 
    222 inline flatbuffers::Offset<SecondTableInA> CreateSecondTableInA(
    223     flatbuffers::FlatBufferBuilder &_fbb,
    224     flatbuffers::Offset<NamespaceC::TableInC> refer_to_c = 0) {
    225   SecondTableInABuilder builder_(_fbb);
    226   builder_.add_refer_to_c(refer_to_c);
    227   return builder_.Finish();
    228 }
    229 
    230 }  // namespace NamespaceA
    231 
    232 namespace NamespaceC {
    233 
    234 }  // namespace NamespaceC
    235 
    236 namespace NamespaceA {
    237 
    238 inline const flatbuffers::TypeTable *TableInFirstNSTypeTable() {
    239   static const flatbuffers::TypeCode type_codes[] = {
    240     { flatbuffers::ET_SEQUENCE, 0, 0 },
    241     { flatbuffers::ET_CHAR, 0, 1 },
    242     { flatbuffers::ET_SEQUENCE, 0, 2 }
    243   };
    244   static const flatbuffers::TypeFunction type_refs[] = {
    245     NamespaceA::NamespaceB::TableInNestedNSTypeTable,
    246     NamespaceA::NamespaceB::EnumInNestedNSTypeTable,
    247     NamespaceA::NamespaceB::StructInNestedNSTypeTable
    248   };
    249   static const char * const names[] = {
    250     "foo_table",
    251     "foo_enum",
    252     "foo_struct"
    253   };
    254   static const flatbuffers::TypeTable tt = {
    255     flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, names
    256   };
    257   return &tt;
    258 }
    259 
    260 }  // namespace NamespaceA
    261 
    262 namespace NamespaceC {
    263 
    264 inline const flatbuffers::TypeTable *TableInCTypeTable() {
    265   static const flatbuffers::TypeCode type_codes[] = {
    266     { flatbuffers::ET_SEQUENCE, 0, 0 },
    267     { flatbuffers::ET_SEQUENCE, 0, 1 }
    268   };
    269   static const flatbuffers::TypeFunction type_refs[] = {
    270     NamespaceA::TableInFirstNSTypeTable,
    271     NamespaceA::SecondTableInATypeTable
    272   };
    273   static const char * const names[] = {
    274     "refer_to_a1",
    275     "refer_to_a2"
    276   };
    277   static const flatbuffers::TypeTable tt = {
    278     flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, names
    279   };
    280   return &tt;
    281 }
    282 
    283 }  // namespace NamespaceC
    284 
    285 namespace NamespaceA {
    286 
    287 inline const flatbuffers::TypeTable *SecondTableInATypeTable() {
    288   static const flatbuffers::TypeCode type_codes[] = {
    289     { flatbuffers::ET_SEQUENCE, 0, 0 }
    290   };
    291   static const flatbuffers::TypeFunction type_refs[] = {
    292     NamespaceC::TableInCTypeTable
    293   };
    294   static const char * const names[] = {
    295     "refer_to_c"
    296   };
    297   static const flatbuffers::TypeTable tt = {
    298     flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, names
    299   };
    300   return &tt;
    301 }
    302 
    303 }  // namespace NamespaceA
    304 
    305 #endif  // FLATBUFFERS_GENERATED_NAMESPACETEST2_NAMESPACEA_H_
    306