Add tests for native_type on tables.

Author: cosmith-nvidia

tests/native_type_test.fbs

@@ -14,11 +14,19 @@ struct Vector3DAlt (native_type:"Native::Vector3D", native_type_pack_name:"Vecto
   c:float;
 }
 
+table Matrix (native_type:"Native::Matrix") {
+  rows:int32;
+  columns:int32;
+  values:[float];
+}
+
 table ApplicationData {
   vectors:[Vector3D];
   vectors_alt:[Vector3DAlt];
   position:Vector3D;
   position_inline:Vector3D (native_inline);
+  matrix:Matrix;
+  matrices:[Matrix];
 }
 
 root_type ApplicationData;

tests/native_type_test_generated.h

@@ -21,6 +21,9 @@ struct Vector3D;
 
 struct Vector3DAlt;
 
+struct Matrix;
+struct MatrixBuilder;
+
 struct ApplicationData;
 struct ApplicationDataBuilder;
 struct ApplicationDataT;
@@ -32,6 +35,8 @@ inline const ::flatbuffers::TypeTable *Vector3DTypeTable();
 
 inline const ::flatbuffers::TypeTable *Vector3DAltTypeTable();
 
+inline const ::flatbuffers::TypeTable *MatrixTypeTable();
+
 inline const ::flatbuffers::TypeTable *ApplicationDataTypeTable();
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3D FLATBUFFERS_FINAL_CLASS {
@@ -116,12 +121,107 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3DAlt FLATBUFFERS_FINAL_CLASS {
 };
 FLATBUFFERS_STRUCT_END(Vector3DAlt, 12);
 
+struct Matrix FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef Native::Matrix NativeTableType;
+  typedef MatrixBuilder Builder;
+  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
+    return MatrixTypeTable();
+  }
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_ROWS = 4,
+    VT_COLUMNS = 6,
+    VT_VALUES = 8
+  };
+  int32_t rows() const {
+    return GetField<int32_t>(VT_ROWS, 0);
+  }
+  bool mutate_rows(int32_t _rows = 0) {
+    return SetField<int32_t>(VT_ROWS, _rows, 0);
+  }
+  int32_t columns() const {
+    return GetField<int32_t>(VT_COLUMNS, 0);
+  }
+  bool mutate_columns(int32_t _columns = 0) {
+    return SetField<int32_t>(VT_COLUMNS, _columns, 0);
+  }
+  const ::flatbuffers::Vector<float> *values() const {
+    return GetPointer<const ::flatbuffers::Vector<float> *>(VT_VALUES);
+  }
+  ::flatbuffers::Vector<float> *mutable_values() {
+    return GetPointer<::flatbuffers::Vector<float> *>(VT_VALUES);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int32_t>(verifier, VT_ROWS, 4) &&
+           VerifyField<int32_t>(verifier, VT_COLUMNS, 4) &&
+           VerifyOffset(verifier, VT_VALUES) &&
+           verifier.VerifyVector(values()) &&
+           verifier.EndTable();
+  }
+  Native::Matrix *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(Native::Matrix *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static ::flatbuffers::Offset<Matrix> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Native::Matrix* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct MatrixBuilder {
+  typedef Matrix Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_rows(int32_t rows) {
+    fbb_.AddElement<int32_t>(Matrix::VT_ROWS, rows, 0);
+  }
+  void add_columns(int32_t columns) {
+    fbb_.AddElement<int32_t>(Matrix::VT_COLUMNS, columns, 0);
+  }
+  void add_values(::flatbuffers::Offset<::flatbuffers::Vector<float>> values) {
+    fbb_.AddOffset(Matrix::VT_VALUES, values);
+  }
+  explicit MatrixBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<Matrix> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<Matrix>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<Matrix> CreateMatrix(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    int32_t rows = 0,
+    int32_t columns = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<float>> values = 0) {
+  MatrixBuilder builder_(_fbb);
+  builder_.add_values(values);
+  builder_.add_columns(columns);
+  builder_.add_rows(rows);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<Matrix> CreateMatrixDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    int32_t rows = 0,
+    int32_t columns = 0,
+    const std::vector<float> *values = nullptr) {
+  auto values__ = values ? _fbb.CreateVector<float>(*values) : 0;
+  return Geometry::CreateMatrix(
+      _fbb,
+      rows,
+      columns,
+      values__);
+}
+
+::flatbuffers::Offset<Matrix> CreateMatrix(::flatbuffers::FlatBufferBuilder &_fbb, const Native::Matrix *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
 struct ApplicationDataT : public ::flatbuffers::NativeTable {
   typedef ApplicationData TableType;
   std::vector<Native::Vector3D> vectors{};
   std::vector<Native::Vector3D> vectors_alt{};
   std::unique_ptr<Native::Vector3D> position{};
   Native::Vector3D position_inline{};
+  std::unique_ptr<Native::Matrix> matrix{};
+  std::vector<std::unique_ptr<Native::Matrix>> matrices{};
   ApplicationDataT() = default;
   ApplicationDataT(const ApplicationDataT &o);
   ApplicationDataT(ApplicationDataT&&) FLATBUFFERS_NOEXCEPT = default;
@@ -138,7 +238,9 @@ struct ApplicationData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     VT_VECTORS = 4,
     VT_VECTORS_ALT = 6,
     VT_POSITION = 8,
-    VT_POSITION_INLINE = 10
+    VT_POSITION_INLINE = 10,
+    VT_MATRIX = 12,
+    VT_MATRICES = 14
   };
   const ::flatbuffers::Vector<const Geometry::Vector3D *> *vectors() const {
     return GetPointer<const ::flatbuffers::Vector<const Geometry::Vector3D *> *>(VT_VECTORS);
@@ -164,6 +266,18 @@ struct ApplicationData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   Geometry::Vector3D *mutable_position_inline() {
     return GetStruct<Geometry::Vector3D *>(VT_POSITION_INLINE);
   }
+  const Geometry::Matrix *matrix() const {
+    return GetPointer<const Geometry::Matrix *>(VT_MATRIX);
+  }
+  Geometry::Matrix *mutable_matrix() {
+    return GetPointer<Geometry::Matrix *>(VT_MATRIX);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<Geometry::Matrix>> *matrices() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Geometry::Matrix>> *>(VT_MATRICES);
+  }
+  ::flatbuffers::Vector<::flatbuffers::Offset<Geometry::Matrix>> *mutable_matrices() {
+    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<Geometry::Matrix>> *>(VT_MATRICES);
+  }
   bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_VECTORS) &&
@@ -172,6 +286,11 @@ struct ApplicationData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
            verifier.VerifyVector(vectors_alt()) &&
            VerifyField<Geometry::Vector3D>(verifier, VT_POSITION, 4) &&
            VerifyField<Geometry::Vector3D>(verifier, VT_POSITION_INLINE, 4) &&
+           VerifyOffset(verifier, VT_MATRIX) &&
+           verifier.VerifyTable(matrix()) &&
+           VerifyOffset(verifier, VT_MATRICES) &&
+           verifier.VerifyVector(matrices()) &&
+           verifier.VerifyVectorOfTables(matrices()) &&
            verifier.EndTable();
   }
   ApplicationDataT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -195,6 +314,12 @@ struct ApplicationDataBuilder {
   void add_position_inline(const Geometry::Vector3D *position_inline) {
     fbb_.AddStruct(ApplicationData::VT_POSITION_INLINE, position_inline);
   }
+  void add_matrix(::flatbuffers::Offset<Geometry::Matrix> matrix) {
+    fbb_.AddOffset(ApplicationData::VT_MATRIX, matrix);
+  }
+  void add_matrices(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Geometry::Matrix>>> matrices) {
+    fbb_.AddOffset(ApplicationData::VT_MATRICES, matrices);
+  }
   explicit ApplicationDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -211,8 +336,12 @@ inline ::flatbuffers::Offset<ApplicationData> CreateApplicationData(
     ::flatbuffers::Offset<::flatbuffers::Vector<const Geometry::Vector3D *>> vectors = 0,
     ::flatbuffers::Offset<::flatbuffers::Vector<const Geometry::Vector3DAlt *>> vectors_alt = 0,
     const Geometry::Vector3D *position = nullptr,
-    const Geometry::Vector3D *position_inline = nullptr) {
+    const Geometry::Vector3D *position_inline = nullptr,
+    ::flatbuffers::Offset<Geometry::Matrix> matrix = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Geometry::Matrix>>> matrices = 0) {
   ApplicationDataBuilder builder_(_fbb);
+  builder_.add_matrices(matrices);
+  builder_.add_matrix(matrix);
   builder_.add_position_inline(position_inline);
   builder_.add_position(position);
   builder_.add_vectors_alt(vectors_alt);
@@ -225,26 +354,43 @@ inline ::flatbuffers::Offset<ApplicationData> CreateApplicationDataDirect(
     const std::vector<Geometry::Vector3D> *vectors = nullptr,
     const std::vector<Geometry::Vector3DAlt> *vectors_alt = nullptr,
     const Geometry::Vector3D *position = nullptr,
-    const Geometry::Vector3D *position_inline = nullptr) {
+    const Geometry::Vector3D *position_inline = nullptr,
+    ::flatbuffers::Offset<Geometry::Matrix> matrix = 0,
+    const std::vector<::flatbuffers::Offset<Geometry::Matrix>> *matrices = nullptr) {
   auto vectors__ = vectors ? _fbb.CreateVectorOfStructs<Geometry::Vector3D>(*vectors) : 0;
   auto vectors_alt__ = vectors_alt ? _fbb.CreateVectorOfStructs<Geometry::Vector3DAlt>(*vectors_alt) : 0;
+  auto matrices__ = matrices ? _fbb.CreateVector<::flatbuffers::Offset<Geometry::Matrix>>(*matrices) : 0;
   return Geometry::CreateApplicationData(
       _fbb,
       vectors__,
       vectors_alt__,
       position,
-      position_inline);
+      position_inline,
+      matrix,
+      matrices__);
 }
 
 ::flatbuffers::Offset<ApplicationData> CreateApplicationData(::flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
 
+inline Native::Matrix *Matrix::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = std::unique_ptr<Native::Matrix>(new Native::Matrix());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline ::flatbuffers::Offset<Matrix> Matrix::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const Native::Matrix* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateMatrix(_fbb, _o, _rehasher);
+}
+
 
 inline bool operator==(const ApplicationDataT &lhs, const ApplicationDataT &rhs) {
   return
       (lhs.vectors == rhs.vectors) &&
       (lhs.vectors_alt == rhs.vectors_alt) &&
       ((lhs.position == rhs.position) || (lhs.position && rhs.position && *lhs.position == *rhs.position)) &&
-      (lhs.position_inline == rhs.position_inline);
+      (lhs.position_inline == rhs.position_inline) &&
+      ((lhs.matrix == rhs.matrix) || (lhs.matrix && rhs.matrix && *lhs.matrix == *rhs.matrix)) &&
+      (lhs.matrices.size() == rhs.matrices.size() && std::equal(lhs.matrices.cbegin(), lhs.matrices.cend(), rhs.matrices.cbegin(), [](std::unique_ptr<Native::Matrix> const &a, std::unique_ptr<Native::Matrix> const &b) { return (a == b) || (a && b && *a == *b); }));
 }
 
 inline bool operator!=(const ApplicationDataT &lhs, const ApplicationDataT &rhs) {
@@ -256,14 +402,19 @@ inline ApplicationDataT::ApplicationDataT(const ApplicationDataT &o)
       : vectors(o.vectors),
         vectors_alt(o.vectors_alt),
         position((o.position) ? new Native::Vector3D(*o.position) : nullptr),
-        position_inline(o.position_inline) {
+        position_inline(o.position_inline),
+        matrix((o.matrix) ? new Native::Matrix(*o.matrix) : nullptr) {
+  matrices.reserve(o.matrices.size());
+  for (const auto &matrices_ : o.matrices) { matrices.emplace_back((matrices_) ? new Native::Matrix(*matrices_) : nullptr); }
 }
 
 inline ApplicationDataT &ApplicationDataT::operator=(ApplicationDataT o) FLATBUFFERS_NOEXCEPT {
   std::swap(vectors, o.vectors);
   std::swap(vectors_alt, o.vectors_alt);
   std::swap(position, o.position);
   std::swap(position_inline, o.position_inline);
+  std::swap(matrix, o.matrix);
+  std::swap(matrices, o.matrices);
   return *this;
 }
 
@@ -280,6 +431,8 @@ inline void ApplicationData::UnPackTo(ApplicationDataT *_o, const ::flatbuffers:
   { auto _e = vectors_alt(); if (_e) { _o->vectors_alt.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vectors_alt[_i] = ::flatbuffers::UnPackVector3DAlt(*_e->Get(_i)); } } else { _o->vectors_alt.resize(0); } }
   { auto _e = position(); if (_e) _o->position = std::unique_ptr<Native::Vector3D>(new Native::Vector3D(::flatbuffers::UnPack(*_e))); }
   { auto _e = position_inline(); if (_e) _o->position_inline = ::flatbuffers::UnPack(*_e); }
+  { auto _e = matrix(); if (_e) { if(_o->matrix) { _e->UnPackTo(_o->matrix.get(), _resolver); } else { _o->matrix = std::unique_ptr<Native::Matrix>(_e->UnPack(_resolver)); } } else if (_o->matrix) { _o->matrix.reset(); } }
+  { auto _e = matrices(); if (_e) { _o->matrices.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->matrices[_i]) { _e->Get(_i)->UnPackTo(_o->matrices[_i].get(), _resolver); } else { _o->matrices[_i] = std::unique_ptr<Native::Matrix>(_e->Get(_i)->UnPack(_resolver)); } } } else { _o->matrices.resize(0); } }
 }
 
 inline ::flatbuffers::Offset<ApplicationData> ApplicationData::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
@@ -294,12 +447,16 @@ inline ::flatbuffers::Offset<ApplicationData> CreateApplicationData(::flatbuffer
   auto _vectors_alt = _o->vectors_alt.size() ? _fbb.CreateVectorOfNativeStructs<Geometry::Vector3DAlt, Native::Vector3D>(_o->vectors_alt, ::flatbuffers::PackVector3DAlt) : 0;
   auto _position = Geometry::Vector3D{}; if (_o->position) _position = ::flatbuffers::Pack(*_o->position);
   auto _position_inline = ::flatbuffers::Pack(_o->position_inline);
+  auto _matrix = _o->matrix ? CreateMatrix(_fbb, _o->matrix.get(), _rehasher) : 0;
+  auto _matrices = _o->matrices.size() ? _fbb.CreateVector<::flatbuffers::Offset<Geometry::Matrix>> (_o->matrices.size(), [](size_t i, _VectorArgs *__va) { return CreateMatrix(*__va->__fbb, __va->__o->matrices[i].get(), __va->__rehasher); }, &_va ) : 0;
   return Geometry::CreateApplicationData(
       _fbb,
       _vectors,
       _vectors_alt,
       _o->position ? &_position : nullptr,
-      &_position_inline);
+      &_position_inline,
+      _matrix,
+      _matrices);
 }
 
 inline const ::flatbuffers::TypeTable *Vector3DTypeTable() {
@@ -338,25 +495,47 @@ inline const ::flatbuffers::TypeTable *Vector3DAltTypeTable() {
   return &tt;
 }
 
+inline const ::flatbuffers::TypeTable *MatrixTypeTable() {
+  static const ::flatbuffers::TypeCode type_codes[] = {
+    { ::flatbuffers::ET_INT, 0, -1 },
+    { ::flatbuffers::ET_INT, 0, -1 },
+    { ::flatbuffers::ET_FLOAT, 1, -1 }
+  };
+  static const char * const names[] = {
+    "rows",
+    "columns",
+    "values"
+  };
+  static const ::flatbuffers::TypeTable tt = {
+    ::flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names
+  };
+  return &tt;
+}
+
 inline const ::flatbuffers::TypeTable *ApplicationDataTypeTable() {
   static const ::flatbuffers::TypeCode type_codes[] = {
     { ::flatbuffers::ET_SEQUENCE, 1, 0 },
     { ::flatbuffers::ET_SEQUENCE, 1, 1 },
     { ::flatbuffers::ET_SEQUENCE, 0, 0 },
-    { ::flatbuffers::ET_SEQUENCE, 0, 0 }
+    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
+    { ::flatbuffers::ET_SEQUENCE, 0, 2 },
+    { ::flatbuffers::ET_SEQUENCE, 1, 2 }
   };
   static const ::flatbuffers::TypeFunction type_refs[] = {
     Geometry::Vector3DTypeTable,
-    Geometry::Vector3DAltTypeTable
+    Geometry::Vector3DAltTypeTable,
+    Geometry::MatrixTypeTable
   };
   static const char * const names[] = {
     "vectors",
     "vectors_alt",
     "position",
-    "position_inline"
+    "position_inline",
+    "matrix",
+    "matrices"
   };
   static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names
+    ::flatbuffers::ST_TABLE, 6, type_codes, type_refs, nullptr, nullptr, names
   };
   return &tt;
 }

tests/native_type_test_impl.cpp

@@ -19,3 +19,34 @@ const Native::Vector3D UnPackVector3DAlt(const Geometry::Vector3DAlt& obj) {
   return Native::Vector3D(obj.a(), obj.b(), obj.c());
 }
 }  // namespace flatbuffers
+
+namespace Geometry {
+void Matrix::UnPackTo(
+    Native::Matrix *_o,
+    const ::flatbuffers::resolver_function_t *_resolver) const {
+  (void)_resolver;
+
+  auto _rows = rows();
+  if (_rows) { _o->rows = _rows; }
+
+  auto _columns = columns();
+  if (_columns) { _o->columns = _columns; }
+
+  auto _values = values();
+  if (_values) {
+    _o->values.resize(_values->size());
+    for (::flatbuffers::uoffset_t i = 0; i < _values->size(); i++) {
+      _o->values[i] = _values->Get(i);
+    }
+  }
+}
+
+::flatbuffers::Offset<Matrix> CreateMatrix(
+    ::flatbuffers::FlatBufferBuilder &_fbb, const Native::Matrix *_o,
+    const ::flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+
+  return CreateMatrix(_fbb, _o->rows, _o->columns,
+                      _fbb.CreateVector<float>(_o->values));
+}
+}  // namespace Geometry