BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-25 00:46:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add flatc '--cpp_std' switch (#5656)

Browse Source 
* Add flatc '--cpp_std' switch and sandbox for C++17 code generator

- Added 'flac --cpp_std legacy' for compatibility with old compilers (VS2010);
- Added experimental switch 'flac --cpp_std c++17' for future development;
- Added C++17 sandbox test_cpp17.cpp;
- C++ code generator generates enums with explicit underlying type to avoid problems with the forward and backward schema compatibility;
- Adjusted CMakeLists.txt, CI and generate code scripts to support of introduced '--cpp_std';

* Fix --cpp_std values: c++0x, c++11, c++17

* Add 'cpp::CppStandard' enum

* Add testing engine into test_cpp17

* Rebase to upstream/master

* Set default '--cpp-std C++0x'

* Fix code generation (--cpp_std C++11) in CMakeLists.txt

- Fix dependency declaration of grpctest target

* Revert --cpp-std for the tests from explicit C++11 to flatc default value (C++0x)
This commit is contained in:
Vladimir Glavnyy
2019-12-24 03:13:48 +07:00
committed by Wouter van Oortmerssen
parent 3e8f15df90
commit 44bf719883
41 changed files with 4363 additions and 254 deletions
Download Patch File Download Diff File Expand all files Collapse all files

183
tests/namespace_test/namespace_test2_generated.h
View File

@@ -6,23 +6,39 @@
#include "flatbuffers/flatbuffers.h"
#include "namespace_test1_generated.h"
namespace NamespaceA {
struct TableInFirstNS;
struct TableInFirstNST;
} // namespace NamespaceA
namespace NamespaceC {
struct TableInC;
struct TableInCT;
} // namespace NamespaceC
namespace NamespaceA {
struct SecondTableInA;
struct SecondTableInAT;
bool operator==(const TableInFirstNST &lhs, const TableInFirstNST &rhs);
bool operator!=(const TableInFirstNST &lhs, const TableInFirstNST &rhs);
} // namespace NamespaceA
namespace NamespaceC {
bool operator==(const TableInCT &lhs, const TableInCT &rhs);
bool operator!=(const TableInCT &lhs, const TableInCT &rhs);
} // namespace NamespaceC
namespace NamespaceA {
bool operator==(const SecondTableInAT &lhs, const SecondTableInAT &rhs);
bool operator!=(const SecondTableInAT &lhs, const SecondTableInAT &rhs);
inline const flatbuffers::TypeTable *TableInFirstNSTypeTable();
@@ -38,7 +54,30 @@ namespace NamespaceA {
inline const flatbuffers::TypeTable *SecondTableInATypeTable();
struct TableInFirstNST : public flatbuffers::NativeTable {
typedef TableInFirstNS TableType;
flatbuffers::unique_ptr<NamespaceA::NamespaceB::TableInNestedNST> foo_table;
NamespaceA::NamespaceB::EnumInNestedNS foo_enum;
flatbuffers::unique_ptr<NamespaceA::NamespaceB::StructInNestedNS> foo_struct;
TableInFirstNST()
: foo_enum(NamespaceA::NamespaceB::EnumInNestedNS_A) {
}
};
inline bool operator==(const TableInFirstNST &lhs, const TableInFirstNST &rhs) {
return
(lhs.foo_table == rhs.foo_table) &&
(lhs.foo_enum == rhs.foo_enum) &&
(lhs.foo_struct == rhs.foo_struct);
}
inline bool operator!=(const TableInFirstNST &lhs, const TableInFirstNST &rhs) {
return !(lhs == rhs);
}
struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef TableInFirstNST NativeTableType;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
return TableInFirstNSTypeTable();
}
@@ -73,6 +112,9 @@ struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<NamespaceA::NamespaceB::StructInNestedNS>(verifier, VT_FOO_STRUCT) &&
verifier.EndTable();
}
TableInFirstNST *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(TableInFirstNST *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<TableInFirstNS> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct TableInFirstNSBuilder {
@@ -111,11 +153,33 @@ inline flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(
return builder_.Finish();
}
flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
} // namespace NamespaceA
namespace NamespaceC {
struct TableInCT : public flatbuffers::NativeTable {
typedef TableInC TableType;
flatbuffers::unique_ptr<NamespaceA::TableInFirstNST> refer_to_a1;
flatbuffers::unique_ptr<NamespaceA::SecondTableInAT> refer_to_a2;
TableInCT() {
}
};
inline bool operator==(const TableInCT &lhs, const TableInCT &rhs) {
return
(lhs.refer_to_a1 == rhs.refer_to_a1) &&
(lhs.refer_to_a2 == rhs.refer_to_a2);
}
inline bool operator!=(const TableInCT &lhs, const TableInCT &rhs) {
return !(lhs == rhs);
}
struct TableInC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef TableInCT NativeTableType;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
return TableInCTypeTable();
}
@@ -143,6 +207,9 @@ struct TableInC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyTable(refer_to_a2()) &&
verifier.EndTable();
}
TableInCT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(TableInCT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<TableInC> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInCT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct TableInCBuilder {
@@ -176,11 +243,31 @@ inline flatbuffers::Offset<TableInC> CreateTableInC(
return builder_.Finish();
}
flatbuffers::Offset<TableInC> CreateTableInC(flatbuffers::FlatBufferBuilder &_fbb, const TableInCT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
} // namespace NamespaceC
namespace NamespaceA {
struct SecondTableInAT : public flatbuffers::NativeTable {
typedef SecondTableInA TableType;
flatbuffers::unique_ptr<NamespaceC::TableInCT> refer_to_c;
SecondTableInAT() {
}
};
inline bool operator==(const SecondTableInAT &lhs, const SecondTableInAT &rhs) {
return
(lhs.refer_to_c == rhs.refer_to_c);
}
inline bool operator!=(const SecondTableInAT &lhs, const SecondTableInAT &rhs) {
return !(lhs == rhs);
}
struct SecondTableInA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef SecondTableInAT NativeTableType;
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
return SecondTableInATypeTable();
}
@@ -199,6 +286,9 @@ struct SecondTableInA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyTable(refer_to_c()) &&
verifier.EndTable();
}
SecondTableInAT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SecondTableInAT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SecondTableInA> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SecondTableInABuilder {
@@ -227,14 +317,103 @@ inline flatbuffers::Offset<SecondTableInA> CreateSecondTableInA(
return builder_.Finish();
}
flatbuffers::Offset<SecondTableInA> CreateSecondTableInA(flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline TableInFirstNST *TableInFirstNS::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new TableInFirstNST();
UnPackTo(_o, _resolver);
return _o;
}
inline void TableInFirstNS::UnPackTo(TableInFirstNST *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = foo_table(); if (_e) _o->foo_table = flatbuffers::unique_ptr<NamespaceA::NamespaceB::TableInNestedNST>(_e->UnPack(_resolver)); }
{ auto _e = foo_enum(); _o->foo_enum = _e; }
{ auto _e = foo_struct(); if (_e) _o->foo_struct = flatbuffers::unique_ptr<NamespaceA::NamespaceB::StructInNestedNS>(new NamespaceA::NamespaceB::StructInNestedNS(*_e)); }
}
inline flatbuffers::Offset<TableInFirstNS> TableInFirstNS::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateTableInFirstNS(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TableInFirstNST* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _foo_table = _o->foo_table ? CreateTableInNestedNS(_fbb, _o->foo_table.get(), _rehasher) : 0;
auto _foo_enum = _o->foo_enum;
auto _foo_struct = _o->foo_struct ? _o->foo_struct.get() : 0;
return NamespaceA::CreateTableInFirstNS(
_fbb,
_foo_table,
_foo_enum,
_foo_struct);
}
} // namespace NamespaceA
namespace NamespaceC {
inline TableInCT *TableInC::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new TableInCT();
UnPackTo(_o, _resolver);
return _o;
}
inline void TableInC::UnPackTo(TableInCT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = refer_to_a1(); if (_e) _o->refer_to_a1 = flatbuffers::unique_ptr<NamespaceA::TableInFirstNST>(_e->UnPack(_resolver)); }
{ auto _e = refer_to_a2(); if (_e) _o->refer_to_a2 = flatbuffers::unique_ptr<NamespaceA::SecondTableInAT>(_e->UnPack(_resolver)); }
}
inline flatbuffers::Offset<TableInC> TableInC::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInCT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateTableInC(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<TableInC> CreateTableInC(flatbuffers::FlatBufferBuilder &_fbb, const TableInCT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TableInCT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _refer_to_a1 = _o->refer_to_a1 ? CreateTableInFirstNS(_fbb, _o->refer_to_a1.get(), _rehasher) : 0;
auto _refer_to_a2 = _o->refer_to_a2 ? CreateSecondTableInA(_fbb, _o->refer_to_a2.get(), _rehasher) : 0;
return NamespaceC::CreateTableInC(
_fbb,
_refer_to_a1,
_refer_to_a2);
}
} // namespace NamespaceC
namespace NamespaceA {
inline SecondTableInAT *SecondTableInA::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new SecondTableInAT();
UnPackTo(_o, _resolver);
return _o;
}
inline void SecondTableInA::UnPackTo(SecondTableInAT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = refer_to_c(); if (_e) _o->refer_to_c = flatbuffers::unique_ptr<NamespaceC::TableInCT>(_e->UnPack(_resolver)); }
}
inline flatbuffers::Offset<SecondTableInA> SecondTableInA::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateSecondTableInA(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<SecondTableInA> CreateSecondTableInA(flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SecondTableInAT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _refer_to_c = _o->refer_to_c ? CreateTableInC(_fbb, _o->refer_to_c.get(), _rehasher) : 0;
return NamespaceA::CreateSecondTableInA(
_fbb,
_refer_to_c);
}
inline const flatbuffers::TypeTable *TableInFirstNSTypeTable() {
static const flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, 0 },