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