BigfootDev/Bigfoot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

AssetContainer barebones
All checks were successful
Bigfoot / Build & Test Debug with ./ConanProfiles/clang (Unity Build: OFF) (push) Successful in 7m8s
Details
Bigfoot / Build & Test Debug with ./ConanProfiles/clang (Unity Build: ON) (push) Successful in 5m12s
Details
Bigfoot / Build & Test Debug with ./ConanProfiles/clang_asan (Unity Build: OFF) (push) Successful in 5m36s
Details
Bigfoot / Build & Test Debug with ./ConanProfiles/clang_asan (Unity Build: ON) (push) Successful in 5m41s
Details
Bigfoot / Build & Test RelWithDebInfo with ./ConanProfiles/clang (Unity Build: OFF) (push) Successful in 7m1s
Details
Bigfoot / Build & Test RelWithDebInfo with ./ConanProfiles/clang (Unity Build: ON) (push) Successful in 5m54s
Details
Bigfoot / Build & Test RelWithDebInfo with ./ConanProfiles/clang_asan (Unity Build: OFF) (push) Successful in 6m59s
Details
Bigfoot / Build & Test RelWithDebInfo with ./ConanProfiles/clang_asan (Unity Build: ON) (push) Successful in 7m2s
Details
Bigfoot / Build & Test Release with ./ConanProfiles/clang (Unity Build: OFF) (push) Successful in 5m54s
Details
Bigfoot / Build & Test Release with ./ConanProfiles/clang (Unity Build: ON) (push) Successful in 5m54s
Details
Bigfoot / Build & Test Release with ./ConanProfiles/clang_asan (Unity Build: OFF) (push) Successful in 6m42s
Details
Bigfoot / Build & Test Release with ./ConanProfiles/clang_asan (Unity Build: ON) (push) Successful in 6m45s
Details
Bigfoot / Clang Format Checks (push) Successful in 11s
Details

Browse Source
This commit is contained in:
Romain BOULLARD
2026-05-12 21:09:17 +02:00
parent 0d3885a863
commit 4798ed8ab7
14 changed files with 381 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
Bigfoot/Tests/Engine/Asset/Asset.cpp
View File

@@ -106,9 +106,9 @@ TEST_F(AssetFixture, AssetBTests)
AssetB assetB;
assetB.SetName(nameB);
assetB.SetVersion(versionB);
assetB.GetAsset().asset_a_ref = HardRef<AssetA> {assetA.GetHeader().uuid};
assetB.GetAsset().asset_a_refs = {SoftRef<AssetA> {assetA.GetHeader().uuid},
SoftRef<AssetA> {assetAA.GetHeader().uuid}};
assetB.GetAsset().asset_a_ref = HardReference<AssetA> {assetA.GetHeader().uuid};
assetB.GetAsset().asset_a_refs = {SoftReference<AssetA> {assetA.GetHeader().uuid},
SoftReference<AssetA> {assetAA.GetHeader().uuid}};
const eastl::vector<std::byte> test = assetB.Save();
@@ -128,12 +128,12 @@ TEST_F(AssetFixture, AssetBTests)
EXPECT_EQ(assetB.GetHeader().version, versionB);
EXPECT_EQ(assetB.GetHeader().version, assetB_dup.GetHeader().version);
EXPECT_EQ(assetB.GetAsset().asset_a_ref, HardRef<AssetA> {assetA.GetHeader().uuid});
EXPECT_EQ(assetB.GetAsset().asset_a_ref, HardReference<AssetA> {assetA.GetHeader().uuid});
EXPECT_EQ(assetB.GetAsset().asset_a_ref, assetB_dup.GetAsset().asset_a_ref);
EXPECT_EQ(assetB.GetAsset().asset_a_refs,
(eastl::vector<SoftRef<AssetA>> {SoftRef<AssetA> {assetA.GetHeader().uuid},
SoftRef<AssetA> {assetAA.GetHeader().uuid}}));
(eastl::vector<SoftReference<AssetA>> {SoftReference<AssetA> {assetA.GetHeader().uuid},
SoftReference<AssetA> {assetAA.GetHeader().uuid}}));
EXPECT_EQ(assetB.GetAsset().asset_a_refs, assetB_dup.GetAsset().asset_a_refs);
}
@@ -169,9 +169,9 @@ TEST_F(AssetFixture, AssetCTests)
AssetB assetB;
assetB.SetName(nameB);
assetB.SetVersion(versionB);
assetB.GetAsset().asset_a_ref = HardRef<AssetA> {assetA.GetHeader().uuid};
assetB.GetAsset().asset_a_refs = {SoftRef<AssetA> {assetA.GetHeader().uuid},
SoftRef<AssetA> {assetAA.GetHeader().uuid}};
assetB.GetAsset().asset_a_ref = HardReference<AssetA> {assetA.GetHeader().uuid};
assetB.GetAsset().asset_a_refs = {SoftReference<AssetA> {assetA.GetHeader().uuid},
SoftReference<AssetA> {assetAA.GetHeader().uuid}};
constexpr eastl::string_view nameC = "General";
constexpr std::uint32_t versionC = 1;
@@ -179,11 +179,11 @@ TEST_F(AssetFixture, AssetCTests)
AssetC assetC;
assetC.SetName(nameC);
assetC.SetVersion(versionC);
assetC.GetAsset().inner_table->asset_a_ref = HardRef<AssetA> {assetA.GetHeader().uuid};
assetC.GetAsset().inner_table->asset_a_refs = {HardRef<AssetA> {assetA.GetHeader().uuid},
HardRef<AssetA> {assetAA.GetHeader().uuid}};
assetC.GetAsset().asset_b_ref = HardRef<AssetB> {assetB.GetHeader().uuid};
assetC.GetAsset().asset_b_refs = {SoftRef<AssetB> {assetB.GetHeader().uuid}};
assetC.GetAsset().inner_table->asset_a_ref = HardReference<AssetA> {assetA.GetHeader().uuid};
assetC.GetAsset().inner_table->asset_a_refs = {HardReference<AssetA> {assetA.GetHeader().uuid},
HardReference<AssetA> {assetAA.GetHeader().uuid}};
assetC.GetAsset().asset_b_ref = HardReference<AssetB> {assetB.GetHeader().uuid};
assetC.GetAsset().asset_b_refs = {SoftReference<AssetB> {assetB.GetHeader().uuid}};
const eastl::vector<std::byte> test = assetC.Save();
@@ -203,23 +203,21 @@ TEST_F(AssetFixture, AssetCTests)
EXPECT_EQ(assetC.GetHeader().version, versionC);
EXPECT_EQ(assetC.GetHeader().version, assetC_dup.GetHeader().version);
EXPECT_EQ(assetC.GetAsset().asset_b_ref, HardRef<AssetB> {assetB.GetHeader().uuid});
EXPECT_EQ(assetC.GetAsset().asset_b_ref, HardReference<AssetB> {assetB.GetHeader().uuid});
EXPECT_EQ(assetC.GetAsset().asset_b_ref, assetC_dup.GetAsset().asset_b_ref);
EXPECT_EQ(assetC.GetAsset().asset_b_refs,
(eastl::vector<SoftRef<AssetB>> {SoftRef<AssetB> {assetB.GetHeader().uuid}}));
(eastl::vector<SoftReference<AssetB>> {SoftReference<AssetB> {assetB.GetHeader().uuid}}));
EXPECT_EQ(assetC.GetAsset().asset_b_refs, assetC_dup.GetAsset().asset_b_refs);
EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_ref, HardRef<AssetA> {assetA.GetHeader().uuid});
EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_ref, HardReference<AssetA> {assetA.GetHeader().uuid});
EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_ref, assetC_dup.GetAsset().inner_table->asset_a_ref);
EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_refs,
(eastl::vector<HardRef<AssetA>> {HardRef<AssetA> {assetA.GetHeader().uuid},
HardRef<AssetA> {assetAA.GetHeader().uuid}}));
(eastl::vector<HardReference<AssetA>> {HardReference<AssetA> {assetA.GetHeader().uuid},
HardReference<AssetA> {assetAA.GetHeader().uuid}}));
EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_refs, assetC_dup.GetAsset().inner_table->asset_a_refs);
}
TEST_F(AssetFixture, MiniReflect)
{
}
TEST_F(AssetFixture, MiniReflect) { }
} // namespace Bigfoot

0
Bigfoot/Tests/Engine/Asset/AssetContainer.cpp
View File

2
Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetA_fwd.hpp
View File

@@ -6,7 +6,7 @@
*********************************************************************/
#ifndef BIGFOOT_ENGINE_ASSETA_FWD_HPP
#define BIGFOOT_ENGINE_ASSETA_FWD_HPP
#include <Engine/Asset/Reference_generated.hpp>
#include <Engine/Asset/AssetHelper.hpp>
namespace Bigfoot
{

4
Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetB.fbs
View File

@@ -8,8 +8,8 @@ namespace Flat.Bigfoot;
table AssetB
{
asset_a_ref: Flat.Bigfoot.HardRef (native_type: "::Bigfoot::HardRef<::Bigfoot::AssetA>", native_inline, native_type_pack_name: "HardRefAssetA");
asset_a_refs: [Flat.Bigfoot.SoftRef] (native_type: "::Bigfoot::SoftRef<::Bigfoot::AssetA>", native_inline, native_type_pack_name: "SoftRefAssetA");
asset_a_ref: Flat.Bigfoot.HardReference (native_type: "::Bigfoot::HardReference<::Bigfoot::AssetA>", native_inline, native_type_pack_name: "HardReferenceAssetA");
asset_a_refs: [Flat.Bigfoot.SoftReference] (native_type: "::Bigfoot::SoftReference<::Bigfoot::AssetA>", native_inline, native_type_pack_name: "SoftReferenceAssetA");
}
root_type AssetB;

2
Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetB_fwd.hpp
View File

@@ -6,7 +6,7 @@
*********************************************************************/
#ifndef BIGFOOT_ENGINE_ASSETB_FWD_HPP
#define BIGFOOT_ENGINE_ASSETB_FWD_HPP
#include <Engine/Asset/Reference_generated.hpp>
#include <Engine/Asset/AssetHelper.hpp>
namespace Bigfoot
{

34
Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetB_generated.hpp
View File

@@ -39,8 +39,8 @@ struct AssetBT : public ::flatbuffers::NativeTable {
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
return "Flat.Bigfoot.AssetBT";
}
::Bigfoot::HardRef<::Bigfoot::AssetA> asset_a_ref{};
eastl::vector<::Bigfoot::SoftRef<::Bigfoot::AssetA>> asset_a_refs{};
::Bigfoot::HardReference<::Bigfoot::AssetA> asset_a_ref{};
eastl::vector<::Bigfoot::SoftReference<::Bigfoot::AssetA>> asset_a_refs{};
};
struct AssetB FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
@@ -57,16 +57,16 @@ struct AssetB FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
VT_ASSET_A_REF = 4,
VT_ASSET_A_REFS = 6
};
const Flat::Bigfoot::HardRef *asset_a_ref() const {
return GetStruct<const Flat::Bigfoot::HardRef *>(VT_ASSET_A_REF);
const Flat::Bigfoot::HardReference *asset_a_ref() const {
return GetStruct<const Flat::Bigfoot::HardReference *>(VT_ASSET_A_REF);
}
const ::flatbuffers::Vector<const Flat::Bigfoot::SoftRef *> *asset_a_refs() const {
return GetPointer<const ::flatbuffers::Vector<const Flat::Bigfoot::SoftRef *> *>(VT_ASSET_A_REFS);
const ::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *> *asset_a_refs() const {
return GetPointer<const ::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *> *>(VT_ASSET_A_REFS);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<Flat::Bigfoot::HardRef>(verifier, VT_ASSET_A_REF, 1) &&
VerifyField<Flat::Bigfoot::HardReference>(verifier, VT_ASSET_A_REF, 1) &&
VerifyOffset(verifier, VT_ASSET_A_REFS) &&
verifier.VerifyVector(asset_a_refs()) &&
verifier.EndTable();
@@ -80,10 +80,10 @@ struct AssetBBuilder {
typedef AssetB Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_asset_a_ref(const Flat::Bigfoot::HardRef *asset_a_ref) {
void add_asset_a_ref(const Flat::Bigfoot::HardReference *asset_a_ref) {
fbb_.AddStruct(AssetB::VT_ASSET_A_REF, asset_a_ref);
}
void add_asset_a_refs(::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::SoftRef *>> asset_a_refs) {
void add_asset_a_refs(::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *>> asset_a_refs) {
fbb_.AddOffset(AssetB::VT_ASSET_A_REFS, asset_a_refs);
}
explicit AssetBBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
@@ -99,8 +99,8 @@ struct AssetBBuilder {
inline ::flatbuffers::Offset<AssetB> CreateAssetB(
::flatbuffers::FlatBufferBuilder &_fbb,
const Flat::Bigfoot::HardRef *asset_a_ref = nullptr,
::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::SoftRef *>> asset_a_refs = 0) {
const Flat::Bigfoot::HardReference *asset_a_ref = nullptr,
::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *>> asset_a_refs = 0) {
AssetBBuilder builder_(_fbb);
builder_.add_asset_a_refs(asset_a_refs);
builder_.add_asset_a_ref(asset_a_ref);
@@ -123,8 +123,8 @@ inline AssetBT *AssetB::UnPack(const ::flatbuffers::resolver_function_t *_resolv
inline void AssetB::UnPackTo(AssetBT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = asset_a_ref(); if (_e) _o->asset_a_ref = ::flatbuffers::UnPackHardRefAssetA(*_e); }
{ auto _e = asset_a_refs(); if (_e) { _o->asset_a_refs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->asset_a_refs[_i] = ::flatbuffers::UnPackSoftRefAssetA(*_e->Get(_i)); } } else { _o->asset_a_refs.resize(0); } }
{ auto _e = asset_a_ref(); if (_e) _o->asset_a_ref = ::flatbuffers::UnPackHardReferenceAssetA(*_e); }
{ auto _e = asset_a_refs(); if (_e) { _o->asset_a_refs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->asset_a_refs[_i] = ::flatbuffers::UnPackSoftReferenceAssetA(*_e->Get(_i)); } } else { _o->asset_a_refs.resize(0); } }
}
inline ::flatbuffers::Offset<AssetB> CreateAssetB(::flatbuffers::FlatBufferBuilder &_fbb, const AssetBT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
@@ -135,8 +135,8 @@ inline ::flatbuffers::Offset<AssetB> AssetB::Pack(::flatbuffers::FlatBufferBuild
(void)_rehasher;
(void)_o;
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AssetBT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _asset_a_ref = ::flatbuffers::PackHardRefAssetA(_o->asset_a_ref);
auto _asset_a_refs = _fbb.CreateVectorOfNativeStructs<Flat::Bigfoot::SoftRef, ::Bigfoot::SoftRef<::Bigfoot::AssetA>>(_o->asset_a_refs.data(), _o->asset_a_refs.size(), ::flatbuffers::PackSoftRefAssetA);
auto _asset_a_ref = ::flatbuffers::PackHardReferenceAssetA(_o->asset_a_ref);
auto _asset_a_refs = _fbb.CreateVectorOfNativeStructs<Flat::Bigfoot::SoftReference, ::Bigfoot::SoftReference<::Bigfoot::AssetA>>(_o->asset_a_refs.data(), _o->asset_a_refs.size(), ::flatbuffers::PackSoftReferenceAssetA);
return Flat::Bigfoot::CreateAssetB(
_fbb,
&_asset_a_ref,
@@ -149,8 +149,8 @@ inline const ::flatbuffers::TypeTable *AssetBTypeTable() {
{ ::flatbuffers::ET_SEQUENCE, 1, 1 }
};
static const ::flatbuffers::TypeFunction type_refs[] = {
Flat::Bigfoot::HardRefTypeTable,
Flat::Bigfoot::SoftRefTypeTable
Flat::Bigfoot::HardReferenceTypeTable,
Flat::Bigfoot::SoftReferenceTypeTable
};
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, nullptr

8
Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetC.fbs
View File

@@ -9,16 +9,16 @@ namespace Flat.Bigfoot;
table InnerTable
{
asset_a_ref: Flat.Bigfoot.HardRef (native_type: "::Bigfoot::HardRef<::Bigfoot::AssetA>", native_inline, native_type_pack_name: "HardRefAssetA");
asset_a_refs: [Flat.Bigfoot.HardRef] (native_type: "::Bigfoot::HardRef<::Bigfoot::AssetA>", native_inline, native_type_pack_name: "HardRefAssetA");
asset_a_ref: Flat.Bigfoot.HardReference (native_type: "::Bigfoot::HardReference<::Bigfoot::AssetA>", native_inline, native_type_pack_name: "HardReferenceAssetA");
asset_a_refs: [Flat.Bigfoot.HardReference] (native_type: "::Bigfoot::HardReference<::Bigfoot::AssetA>", native_inline, native_type_pack_name: "HardReferenceAssetA");
}
table AssetC
{
inner_table: InnerTable (required);
asset_b_ref: Flat.Bigfoot.HardRef (native_type: "::Bigfoot::HardRef<::Bigfoot::AssetB>", native_inline, native_type_pack_name: "HardRefAssetB");
asset_b_refs: [Flat.Bigfoot.SoftRef] (native_type: "::Bigfoot::SoftRef<::Bigfoot::AssetB>", native_inline, native_type_pack_name: "SoftRefAssetB");
asset_b_ref: Flat.Bigfoot.HardReference (native_type: "::Bigfoot::HardReference<::Bigfoot::AssetB>", native_inline, native_type_pack_name: "HardReferenceAssetB");
asset_b_refs: [Flat.Bigfoot.SoftReference] (native_type: "::Bigfoot::SoftReference<::Bigfoot::AssetB>", native_inline, native_type_pack_name: "SoftReferenceAssetB");
}
root_type AssetC;

2
Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetC_fwd.hpp
View File

@@ -6,7 +6,7 @@
*********************************************************************/
#ifndef BIGFOOT_ENGINE_ASSETC_FWD_HPP
#define BIGFOOT_ENGINE_ASSETC_FWD_HPP
#include <Engine/Asset/Reference_generated.hpp>
#include <Engine/Asset/AssetHelper.hpp>
namespace Bigfoot
{

66
Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetC_generated.hpp
View File

@@ -47,8 +47,8 @@ struct InnerTableT : public ::flatbuffers::NativeTable {
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
return "Flat.Bigfoot.InnerTableT";
}
::Bigfoot::HardRef<::Bigfoot::AssetA> asset_a_ref{};
eastl::vector<::Bigfoot::HardRef<::Bigfoot::AssetA>> asset_a_refs{};
::Bigfoot::HardReference<::Bigfoot::AssetA> asset_a_ref{};
eastl::vector<::Bigfoot::HardReference<::Bigfoot::AssetA>> asset_a_refs{};
};
struct InnerTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
@@ -65,16 +65,16 @@ struct InnerTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
VT_ASSET_A_REF = 4,
VT_ASSET_A_REFS = 6
};
const Flat::Bigfoot::HardRef *asset_a_ref() const {
return GetStruct<const Flat::Bigfoot::HardRef *>(VT_ASSET_A_REF);
const Flat::Bigfoot::HardReference *asset_a_ref() const {
return GetStruct<const Flat::Bigfoot::HardReference *>(VT_ASSET_A_REF);
}
const ::flatbuffers::Vector<const Flat::Bigfoot::HardRef *> *asset_a_refs() const {
return GetPointer<const ::flatbuffers::Vector<const Flat::Bigfoot::HardRef *> *>(VT_ASSET_A_REFS);
const ::flatbuffers::Vector<const Flat::Bigfoot::HardReference *> *asset_a_refs() const {
return GetPointer<const ::flatbuffers::Vector<const Flat::Bigfoot::HardReference *> *>(VT_ASSET_A_REFS);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<Flat::Bigfoot::HardRef>(verifier, VT_ASSET_A_REF, 1) &&
VerifyField<Flat::Bigfoot::HardReference>(verifier, VT_ASSET_A_REF, 1) &&
VerifyOffset(verifier, VT_ASSET_A_REFS) &&
verifier.VerifyVector(asset_a_refs()) &&
verifier.EndTable();
@@ -88,10 +88,10 @@ struct InnerTableBuilder {
typedef InnerTable Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_asset_a_ref(const Flat::Bigfoot::HardRef *asset_a_ref) {
void add_asset_a_ref(const Flat::Bigfoot::HardReference *asset_a_ref) {
fbb_.AddStruct(InnerTable::VT_ASSET_A_REF, asset_a_ref);
}
void add_asset_a_refs(::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::HardRef *>> asset_a_refs) {
void add_asset_a_refs(::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::HardReference *>> asset_a_refs) {
fbb_.AddOffset(InnerTable::VT_ASSET_A_REFS, asset_a_refs);
}
explicit InnerTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
@@ -107,8 +107,8 @@ struct InnerTableBuilder {
inline ::flatbuffers::Offset<InnerTable> CreateInnerTable(
::flatbuffers::FlatBufferBuilder &_fbb,
const Flat::Bigfoot::HardRef *asset_a_ref = nullptr,
::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::HardRef *>> asset_a_refs = 0) {
const Flat::Bigfoot::HardReference *asset_a_ref = nullptr,
::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::HardReference *>> asset_a_refs = 0) {
InnerTableBuilder builder_(_fbb);
builder_.add_asset_a_refs(asset_a_refs);
builder_.add_asset_a_ref(asset_a_ref);
@@ -128,8 +128,8 @@ struct AssetCT : public ::flatbuffers::NativeTable {
return "Flat.Bigfoot.AssetCT";
}
eastl::unique_ptr<Flat::Bigfoot::InnerTableT> inner_table{};
::Bigfoot::HardRef<::Bigfoot::AssetB> asset_b_ref{};
eastl::vector<::Bigfoot::SoftRef<::Bigfoot::AssetB>> asset_b_refs{};
::Bigfoot::HardReference<::Bigfoot::AssetB> asset_b_ref{};
eastl::vector<::Bigfoot::SoftReference<::Bigfoot::AssetB>> asset_b_refs{};
AssetCT() = default;
AssetCT(const AssetCT &o);
AssetCT(AssetCT&&) FLATBUFFERS_NOEXCEPT = default;
@@ -154,18 +154,18 @@ struct AssetC FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
const Flat::Bigfoot::InnerTable *inner_table() const {
return GetPointer<const Flat::Bigfoot::InnerTable *>(VT_INNER_TABLE);
}
const Flat::Bigfoot::HardRef *asset_b_ref() const {
return GetStruct<const Flat::Bigfoot::HardRef *>(VT_ASSET_B_REF);
const Flat::Bigfoot::HardReference *asset_b_ref() const {
return GetStruct<const Flat::Bigfoot::HardReference *>(VT_ASSET_B_REF);
}
const ::flatbuffers::Vector<const Flat::Bigfoot::SoftRef *> *asset_b_refs() const {
return GetPointer<const ::flatbuffers::Vector<const Flat::Bigfoot::SoftRef *> *>(VT_ASSET_B_REFS);
const ::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *> *asset_b_refs() const {
return GetPointer<const ::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *> *>(VT_ASSET_B_REFS);
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffsetRequired(verifier, VT_INNER_TABLE) &&
verifier.VerifyTable(inner_table()) &&
VerifyField<Flat::Bigfoot::HardRef>(verifier, VT_ASSET_B_REF, 1) &&
VerifyField<Flat::Bigfoot::HardReference>(verifier, VT_ASSET_B_REF, 1) &&
VerifyOffset(verifier, VT_ASSET_B_REFS) &&
verifier.VerifyVector(asset_b_refs()) &&
verifier.EndTable();
@@ -182,10 +182,10 @@ struct AssetCBuilder {
void add_inner_table(::flatbuffers::Offset<Flat::Bigfoot::InnerTable> inner_table) {
fbb_.AddOffset(AssetC::VT_INNER_TABLE, inner_table);
}
void add_asset_b_ref(const Flat::Bigfoot::HardRef *asset_b_ref) {
void add_asset_b_ref(const Flat::Bigfoot::HardReference *asset_b_ref) {
fbb_.AddStruct(AssetC::VT_ASSET_B_REF, asset_b_ref);
}
void add_asset_b_refs(::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::SoftRef *>> asset_b_refs) {
void add_asset_b_refs(::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *>> asset_b_refs) {
fbb_.AddOffset(AssetC::VT_ASSET_B_REFS, asset_b_refs);
}
explicit AssetCBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
@@ -203,8 +203,8 @@ struct AssetCBuilder {
inline ::flatbuffers::Offset<AssetC> CreateAssetC(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<Flat::Bigfoot::InnerTable> inner_table = 0,
const Flat::Bigfoot::HardRef *asset_b_ref = nullptr,
::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::SoftRef *>> asset_b_refs = 0) {
const Flat::Bigfoot::HardReference *asset_b_ref = nullptr,
::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *>> asset_b_refs = 0) {
AssetCBuilder builder_(_fbb);
builder_.add_asset_b_refs(asset_b_refs);
builder_.add_asset_b_ref(asset_b_ref);
@@ -228,8 +228,8 @@ inline InnerTableT *InnerTable::UnPack(const ::flatbuffers::resolver_function_t
inline void InnerTable::UnPackTo(InnerTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = asset_a_ref(); if (_e) _o->asset_a_ref = ::flatbuffers::UnPackHardRefAssetA(*_e); }
{ auto _e = asset_a_refs(); if (_e) { _o->asset_a_refs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->asset_a_refs[_i] = ::flatbuffers::UnPackHardRefAssetA(*_e->Get(_i)); } } else { _o->asset_a_refs.resize(0); } }
{ auto _e = asset_a_ref(); if (_e) _o->asset_a_ref = ::flatbuffers::UnPackHardReferenceAssetA(*_e); }
{ auto _e = asset_a_refs(); if (_e) { _o->asset_a_refs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->asset_a_refs[_i] = ::flatbuffers::UnPackHardReferenceAssetA(*_e->Get(_i)); } } else { _o->asset_a_refs.resize(0); } }
}
inline ::flatbuffers::Offset<InnerTable> CreateInnerTable(::flatbuffers::FlatBufferBuilder &_fbb, const InnerTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
@@ -240,8 +240,8 @@ inline ::flatbuffers::Offset<InnerTable> InnerTable::Pack(::flatbuffers::FlatBuf
(void)_rehasher;
(void)_o;
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const InnerTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _asset_a_ref = ::flatbuffers::PackHardRefAssetA(_o->asset_a_ref);
auto _asset_a_refs = _fbb.CreateVectorOfNativeStructs<Flat::Bigfoot::HardRef, ::Bigfoot::HardRef<::Bigfoot::AssetA>>(_o->asset_a_refs.data(), _o->asset_a_refs.size(), ::flatbuffers::PackHardRefAssetA);
auto _asset_a_ref = ::flatbuffers::PackHardReferenceAssetA(_o->asset_a_ref);
auto _asset_a_refs = _fbb.CreateVectorOfNativeStructs<Flat::Bigfoot::HardReference, ::Bigfoot::HardReference<::Bigfoot::AssetA>>(_o->asset_a_refs.data(), _o->asset_a_refs.size(), ::flatbuffers::PackHardReferenceAssetA);
return Flat::Bigfoot::CreateInnerTable(
_fbb,
&_asset_a_ref,
@@ -271,8 +271,8 @@ inline void AssetC::UnPackTo(AssetCT *_o, const ::flatbuffers::resolver_function
(void)_o;
(void)_resolver;
{ auto _e = inner_table(); if (_e) { if(_o->inner_table) { _e->UnPackTo(_o->inner_table.get(), _resolver); } else { _o->inner_table = eastl::unique_ptr<Flat::Bigfoot::InnerTableT>(_e->UnPack(_resolver)); } } else if (_o->inner_table) { _o->inner_table.reset(); } }
{ auto _e = asset_b_ref(); if (_e) _o->asset_b_ref = ::flatbuffers::UnPackHardRefAssetB(*_e); }
{ auto _e = asset_b_refs(); if (_e) { _o->asset_b_refs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->asset_b_refs[_i] = ::flatbuffers::UnPackSoftRefAssetB(*_e->Get(_i)); } } else { _o->asset_b_refs.resize(0); } }
{ auto _e = asset_b_ref(); if (_e) _o->asset_b_ref = ::flatbuffers::UnPackHardReferenceAssetB(*_e); }
{ auto _e = asset_b_refs(); if (_e) { _o->asset_b_refs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->asset_b_refs[_i] = ::flatbuffers::UnPackSoftReferenceAssetB(*_e->Get(_i)); } } else { _o->asset_b_refs.resize(0); } }
}
inline ::flatbuffers::Offset<AssetC> CreateAssetC(::flatbuffers::FlatBufferBuilder &_fbb, const AssetCT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
@@ -284,8 +284,8 @@ inline ::flatbuffers::Offset<AssetC> AssetC::Pack(::flatbuffers::FlatBufferBuild
(void)_o;
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AssetCT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _inner_table = _o->inner_table ? CreateInnerTable(_fbb, _o->inner_table.get(), _rehasher) : 0;
auto _asset_b_ref = ::flatbuffers::PackHardRefAssetB(_o->asset_b_ref);
auto _asset_b_refs = _fbb.CreateVectorOfNativeStructs<Flat::Bigfoot::SoftRef, ::Bigfoot::SoftRef<::Bigfoot::AssetB>>(_o->asset_b_refs.data(), _o->asset_b_refs.size(), ::flatbuffers::PackSoftRefAssetB);
auto _asset_b_ref = ::flatbuffers::PackHardReferenceAssetB(_o->asset_b_ref);
auto _asset_b_refs = _fbb.CreateVectorOfNativeStructs<Flat::Bigfoot::SoftReference, ::Bigfoot::SoftReference<::Bigfoot::AssetB>>(_o->asset_b_refs.data(), _o->asset_b_refs.size(), ::flatbuffers::PackSoftReferenceAssetB);
return Flat::Bigfoot::CreateAssetC(
_fbb,
_inner_table,
@@ -299,7 +299,7 @@ inline const ::flatbuffers::TypeTable *InnerTableTypeTable() {
{ ::flatbuffers::ET_SEQUENCE, 1, 0 }
};
static const ::flatbuffers::TypeFunction type_refs[] = {
Flat::Bigfoot::HardRefTypeTable
Flat::Bigfoot::HardReferenceTypeTable
};
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, nullptr
@@ -315,8 +315,8 @@ inline const ::flatbuffers::TypeTable *AssetCTypeTable() {
};
static const ::flatbuffers::TypeFunction type_refs[] = {
Flat::Bigfoot::InnerTableTypeTable,
Flat::Bigfoot::HardRefTypeTable,
Flat::Bigfoot::SoftRefTypeTable
Flat::Bigfoot::HardReferenceTypeTable,
Flat::Bigfoot::SoftReferenceTypeTable
};
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, nullptr, nullptr