monster_test_generated.h | Explore in Territory

// automatically generated by the FlatBuffers compiler, do not modify


#ifndef FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_
#define FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_

#include "flatbuffers/flatbuffers.h"
#include "flatbuffers/flexbuffers.h"
#include "flatbuffers/flex_flat_util.h"

// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert …;

// For access to the binary schema that produced this file.
#include "monster_test_bfbs_generated.h"

namespace MyGame {

struct InParentNamespace;
struct InParentNamespaceBuilder;
struct InParentNamespaceT;

namespace Example2 {

struct Monster;
struct MonsterBuilder;
struct MonsterT;

}  // namespace Example2

namespace Example {

struct Test;

struct TestSimpleTableWithEnum;
struct TestSimpleTableWithEnumBuilder;
struct TestSimpleTableWithEnumT;

struct Vec3;

struct Ability;

struct StructOfStructs;

struct StructOfStructsOfStructs;

struct Stat;
struct StatBuilder;
struct StatT;

struct Referrable;
struct ReferrableBuilder;
struct ReferrableT;

struct Monster;
struct MonsterBuilder;
struct MonsterT;

struct TypeAliases;
struct TypeAliasesBuilder;
struct TypeAliasesT;

}  // namespace Example

bool operator==(const InParentNamespaceT &lhs, const InParentNamespaceT &rhs);
bool operator!=(const InParentNamespaceT &lhs, const InParentNamespaceT &rhs);
namespace Example2 {

bool operator==(const MonsterT &lhs, const MonsterT &rhs);
bool operator!=(const MonsterT &lhs, const MonsterT &rhs);
}  // namespace Example2

namespace Example {

bool operator==(const Test &lhs, const Test &rhs);
bool operator!=(const Test &lhs, const Test &rhs);
bool operator==(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs);
bool operator!=(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs);
bool operator==(const Vec3 &lhs, const Vec3 &rhs);
bool operator!=(const Vec3 &lhs, const Vec3 &rhs);
bool operator==(const Ability &lhs, const Ability &rhs);
bool operator!=(const Ability &lhs, const Ability &rhs);
bool operator==(const StructOfStructs &lhs, const StructOfStructs &rhs);
bool operator!=(const StructOfStructs &lhs, const StructOfStructs &rhs);
bool operator==(const StructOfStructsOfStructs &lhs, const StructOfStructsOfStructs &rhs);
bool operator!=(const StructOfStructsOfStructs &lhs, const StructOfStructsOfStructs &rhs);
bool operator==(const StatT &lhs, const StatT &rhs);
bool operator!=(const StatT &lhs, const StatT &rhs);
bool operator==(const ReferrableT &lhs, const ReferrableT &rhs);
bool operator!=(const ReferrableT &lhs, const ReferrableT &rhs);
bool operator==(const MonsterT &lhs, const MonsterT &rhs);
bool operator!=(const MonsterT &lhs, const MonsterT &rhs);
bool operator==(const TypeAliasesT &lhs, const TypeAliasesT &rhs);
bool operator!=(const TypeAliasesT &lhs, const TypeAliasesT &rhs);

}  // namespace Example

inline const ::flatbuffers::TypeTable *InParentNamespaceTypeTable();

namespace Example2 {

inline const ::flatbuffers::TypeTable *MonsterTypeTable();

}  // namespace Example2

Example  // namespace Example

struct InParentNamespaceT : public ::flatbuffers::NativeTable { … };

struct InParentNamespace FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct InParentNamespaceBuilder { … };

inline ::flatbuffers::Offset<InParentNamespace> CreateInParentNamespace(
    ::flatbuffers::FlatBufferBuilder &_fbb) { … }

::flatbuffers::Offset<InParentNamespace> CreateInParentNamespace(::flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

namespace Example2 {

struct MonsterT : public ::flatbuffers::NativeTable { … };

struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct MonsterBuilder { … };

inline ::flatbuffers::Offset<Monster> CreateMonster(
    ::flatbuffers::FlatBufferBuilder &_fbb) { … }

::flatbuffers::Offset<Monster> CreateMonster(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

}  // namespace Example2

namespace Example {

struct TestSimpleTableWithEnumT : public ::flatbuffers::NativeTable { … };

struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct TestSimpleTableWithEnumBuilder { … };

inline ::flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    MyGame::Example::Color color = MyGame::Example::Color_Green) { … }

::flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum(::flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct StatT : public ::flatbuffers::NativeTable { … };

struct Stat FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct StatBuilder { … };

inline ::flatbuffers::Offset<Stat> CreateStat(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> id = 0,
    int64_t val = 0,
    uint16_t count = 0) { … }

inline ::flatbuffers::Offset<Stat> CreateStatDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *id = nullptr,
    int64_t val = 0,
    uint16_t count = 0) { … }

::flatbuffers::Offset<Stat> CreateStat(::flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct ReferrableT : public ::flatbuffers::NativeTable { … };

struct Referrable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct ReferrableBuilder { … };

inline ::flatbuffers::Offset<Referrable> CreateReferrable(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t id = 0) { … }

::flatbuffers::Offset<Referrable> CreateReferrable(::flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct MonsterT : public ::flatbuffers::NativeTable { … };

/// an example documentation comment: "monster object"
struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

template<> inline const MyGame::Example::Monster *Monster::test_as<MyGame::Example::Monster>() const { … }

template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::test_as<MyGame::Example::TestSimpleTableWithEnum>() const { … }

template<> inline const MyGame::Example2::Monster *Monster::test_as<MyGame::Example2::Monster>() const { … }

template<> inline const MyGame::Example::Monster *Monster::any_unique_as<MyGame::Example::Monster>() const { … }

template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::any_unique_as<MyGame::Example::TestSimpleTableWithEnum>() const { … }

template<> inline const MyGame::Example2::Monster *Monster::any_unique_as<MyGame::Example2::Monster>() const { … }

struct MonsterBuilder { … };

inline ::flatbuffers::Offset<Monster> CreateMonster(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const MyGame::Example::Vec3 *pos = nullptr,
    int16_t mana = 150,
    int16_t hp = 100,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> inventory = 0,
    MyGame::Example::Color color = MyGame::Example::Color_Blue,
    MyGame::Example::Any test_type = MyGame::Example::Any_NONE,
    ::flatbuffers::Offset<void> test = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<const MyGame::Example::Test *>> test4 = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> testarrayofstring = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Monster>>> testarrayoftables = 0,
    ::flatbuffers::Offset<MyGame::Example::Monster> enemy = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> testnestedflatbuffer = 0,
    ::flatbuffers::Offset<MyGame::Example::Stat> testempty = 0,
    bool testbool = false,
    int32_t testhashs32_fnv1 = 0,
    uint32_t testhashu32_fnv1 = 0,
    int64_t testhashs64_fnv1 = 0,
    uint64_t testhashu64_fnv1 = 0,
    int32_t testhashs32_fnv1a = 0,
    uint32_t testhashu32_fnv1a = 0,
    int64_t testhashs64_fnv1a = 0,
    uint64_t testhashu64_fnv1a = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> testarrayofbools = 0,
    float testf = 3.14159f,
    float testf2 = 3.0f,
    float testf3 = 0.0f,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> testarrayofstring2 = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<const MyGame::Example::Ability *>> testarrayofsortedstruct = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> flex = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<const MyGame::Example::Test *>> test5 = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> vector_of_longs = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<double>> vector_of_doubles = 0,
    ::flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>>> vector_of_referrables = 0,
    uint64_t single_weak_reference = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> vector_of_weak_references = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Referrable>>> vector_of_strong_referrables = 0,
    uint64_t co_owning_reference = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> vector_of_co_owning_references = 0,
    uint64_t non_owning_reference = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> vector_of_non_owning_references = 0,
    MyGame::Example::AnyUniqueAliases any_unique_type = MyGame::Example::AnyUniqueAliases_NONE,
    ::flatbuffers::Offset<void> any_unique = 0,
    MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases_NONE,
    ::flatbuffers::Offset<void> any_ambiguous = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> vector_of_enums = 0,
    MyGame::Example::Race signed_enum = MyGame::Example::Race_None,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0,
    const MyGame::Example::Test *native_inline = nullptr,
    MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne,
    float nan_default = std::numeric_limits<float>::quiet_NaN(),
    float inf_default = std::numeric_limits<float>::infinity(),
    float positive_inf_default = std::numeric_limits<float>::infinity(),
    float infinity_default = std::numeric_limits<float>::infinity(),
    float positive_infinity_default = std::numeric_limits<float>::infinity(),
    float negative_inf_default = -std::numeric_limits<float>::infinity(),
    float negative_infinity_default = -std::numeric_limits<float>::infinity(),
    double double_inf_default = std::numeric_limits<double>::infinity()) { … }

inline ::flatbuffers::Offset<Monster> CreateMonsterDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const MyGame::Example::Vec3 *pos = nullptr,
    int16_t mana = 150,
    int16_t hp = 100,
    const char *name = nullptr,
    const std::vector<uint8_t> *inventory = nullptr,
    MyGame::Example::Color color = MyGame::Example::Color_Blue,
    MyGame::Example::Any test_type = MyGame::Example::Any_NONE,
    ::flatbuffers::Offset<void> test = 0,
    const std::vector<MyGame::Example::Test> *test4 = nullptr,
    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *testarrayofstring = nullptr,
    std::vector<::flatbuffers::Offset<MyGame::Example::Monster>> *testarrayoftables = nullptr,
    ::flatbuffers::Offset<MyGame::Example::Monster> enemy = 0,
    const std::vector<uint8_t> *testnestedflatbuffer = nullptr,
    ::flatbuffers::Offset<MyGame::Example::Stat> testempty = 0,
    bool testbool = false,
    int32_t testhashs32_fnv1 = 0,
    uint32_t testhashu32_fnv1 = 0,
    int64_t testhashs64_fnv1 = 0,
    uint64_t testhashu64_fnv1 = 0,
    int32_t testhashs32_fnv1a = 0,
    uint32_t testhashu32_fnv1a = 0,
    int64_t testhashs64_fnv1a = 0,
    uint64_t testhashu64_fnv1a = 0,
    const std::vector<uint8_t> *testarrayofbools = nullptr,
    float testf = 3.14159f,
    float testf2 = 3.0f,
    float testf3 = 0.0f,
    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *testarrayofstring2 = nullptr,
    std::vector<MyGame::Example::Ability> *testarrayofsortedstruct = nullptr,
    const std::vector<uint8_t> *flex = nullptr,
    const std::vector<MyGame::Example::Test> *test5 = nullptr,
    const std::vector<int64_t> *vector_of_longs = nullptr,
    const std::vector<double> *vector_of_doubles = nullptr,
    ::flatbuffers::Offset<MyGame::InParentNamespace> parent_namespace_test = 0,
    std::vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *vector_of_referrables = nullptr,
    uint64_t single_weak_reference = 0,
    const std::vector<uint64_t> *vector_of_weak_references = nullptr,
    std::vector<::flatbuffers::Offset<MyGame::Example::Referrable>> *vector_of_strong_referrables = nullptr,
    uint64_t co_owning_reference = 0,
    const std::vector<uint64_t> *vector_of_co_owning_references = nullptr,
    uint64_t non_owning_reference = 0,
    const std::vector<uint64_t> *vector_of_non_owning_references = nullptr,
    MyGame::Example::AnyUniqueAliases any_unique_type = MyGame::Example::AnyUniqueAliases_NONE,
    ::flatbuffers::Offset<void> any_unique = 0,
    MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases_NONE,
    ::flatbuffers::Offset<void> any_ambiguous = 0,
    const std::vector<uint8_t> *vector_of_enums = nullptr,
    MyGame::Example::Race signed_enum = MyGame::Example::Race_None,
    const std::vector<uint8_t> *testrequirednestedflatbuffer = nullptr,
    std::vector<::flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr,
    const MyGame::Example::Test *native_inline = nullptr,
    MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne,
    float nan_default = std::numeric_limits<float>::quiet_NaN(),
    float inf_default = std::numeric_limits<float>::infinity(),
    float positive_inf_default = std::numeric_limits<float>::infinity(),
    float infinity_default = std::numeric_limits<float>::infinity(),
    float positive_infinity_default = std::numeric_limits<float>::infinity(),
    float negative_inf_default = -std::numeric_limits<float>::infinity(),
    float negative_infinity_default = -std::numeric_limits<float>::infinity(),
    double double_inf_default = std::numeric_limits<double>::infinity()) { … }

::flatbuffers::Offset<Monster> CreateMonster(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct TypeAliasesT : public ::flatbuffers::NativeTable { … };

struct TypeAliases FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { … };

struct TypeAliasesBuilder { … };

inline ::flatbuffers::Offset<TypeAliases> CreateTypeAliases(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int8_t i8 = 0,
    uint8_t u8 = 0,
    int16_t i16 = 0,
    uint16_t u16 = 0,
    int32_t i32 = 0,
    uint32_t u32 = 0,
    int64_t i64 = 0,
    uint64_t u64 = 0,
    float f32 = 0.0f,
    double f64 = 0.0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int8_t>> v8 = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<double>> vf64 = 0) { … }

inline ::flatbuffers::Offset<TypeAliases> CreateTypeAliasesDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int8_t i8 = 0,
    uint8_t u8 = 0,
    int16_t i16 = 0,
    uint16_t u16 = 0,
    int32_t i32 = 0,
    uint32_t u32 = 0,
    int64_t i64 = 0,
    uint64_t u64 = 0,
    float f32 = 0.0f,
    double f64 = 0.0,
    const std::vector<int8_t> *v8 = nullptr,
    const std::vector<double> *vf64 = nullptr) { … }

::flatbuffers::Offset<TypeAliases> CreateTypeAliases(::flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

}  // namespace Example


inline bool operator==(const InParentNamespaceT &, const InParentNamespaceT &) { … }

inline bool operator!=(const InParentNamespaceT &lhs, const InParentNamespaceT &rhs) { … }


inline InParentNamespaceT *InParentNamespace::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void InParentNamespace::UnPackTo(InParentNamespaceT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<InParentNamespace> InParentNamespace::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<InParentNamespace> CreateInParentNamespace(::flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

namespace Example2 {


inline bool operator==(const MonsterT &, const MonsterT &) { … }

inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) { … }


inline MonsterT *Monster::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void Monster::UnPackTo(MonsterT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<Monster> Monster::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<Monster> CreateMonster(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

}  // namespace Example2

namespace Example {


inline bool operator==(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs) { … }

inline bool operator!=(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs) { … }


inline TestSimpleTableWithEnumT *TestSimpleTableWithEnum::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void TestSimpleTableWithEnum::UnPackTo(TestSimpleTableWithEnumT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<TestSimpleTableWithEnum> TestSimpleTableWithEnum::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<TestSimpleTableWithEnum> CreateTestSimpleTableWithEnum(::flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const StatT &lhs, const StatT &rhs) { … }

inline bool operator!=(const StatT &lhs, const StatT &rhs) { … }


inline StatT *Stat::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void Stat::UnPackTo(StatT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<Stat> Stat::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StatT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<Stat> CreateStat(::flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const ReferrableT &lhs, const ReferrableT &rhs) { … }

inline bool operator!=(const ReferrableT &lhs, const ReferrableT &rhs) { … }


inline ReferrableT *Referrable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void Referrable::UnPackTo(ReferrableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<Referrable> Referrable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<Referrable> CreateReferrable(::flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) { … }

inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) { … }


inline MonsterT::MonsterT(const MonsterT &o)
      : … { … }

inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT { … }

inline MonsterT *Monster::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void Monster::UnPackTo(MonsterT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<Monster> Monster::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<Monster> CreateMonster(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


inline bool operator==(const TypeAliasesT &lhs, const TypeAliasesT &rhs) { … }

inline bool operator!=(const TypeAliasesT &lhs, const TypeAliasesT &rhs) { … }


inline TypeAliasesT *TypeAliases::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline void TypeAliases::UnPackTo(TypeAliasesT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { … }

inline ::flatbuffers::Offset<TypeAliases> TypeAliases::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline ::flatbuffers::Offset<TypeAliases> CreateTypeAliases(::flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

inline bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any type) { … }

inline bool VerifyAnyVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) { … }

inline void *AnyUnion::UnPack(const void *obj, Any type, const ::flatbuffers::resolver_function_t *resolver) { … }

inline ::flatbuffers::Offset<void> AnyUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const { … }

inline AnyUnion::AnyUnion(const AnyUnion &u) : … { … }

inline void AnyUnion::Reset() { … }

inline bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type) { … }

inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) { … }

inline void *AnyUniqueAliasesUnion::UnPack(const void *obj, AnyUniqueAliases type, const ::flatbuffers::resolver_function_t *resolver) { … }

inline ::flatbuffers::Offset<void> AnyUniqueAliasesUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const { … }

inline AnyUniqueAliasesUnion::AnyUniqueAliasesUnion(const AnyUniqueAliasesUnion &u) : … { … }

inline void AnyUniqueAliasesUnion::Reset() { … }

inline bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type) { … }

inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) { … }

inline void *AnyAmbiguousAliasesUnion::UnPack(const void *obj, AnyAmbiguousAliases type, const ::flatbuffers::resolver_function_t *resolver) { … }

inline ::flatbuffers::Offset<void> AnyAmbiguousAliasesUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const { … }

inline AnyAmbiguousAliasesUnion::AnyAmbiguousAliasesUnion(const AnyAmbiguousAliasesUnion &u) : … { … }

inline void AnyAmbiguousAliasesUnion::Reset() { … }

inline const ::flatbuffers::TypeTable *ColorTypeTable() { … }

inline const ::flatbuffers::TypeTable *RaceTypeTable() { … }

inline const ::flatbuffers::TypeTable *LongEnumTypeTable() { … }

inline const ::flatbuffers::TypeTable *AnyTypeTable() { … }

inline const ::flatbuffers::TypeTable *AnyUniqueAliasesTypeTable() { … }

inline const ::flatbuffers::TypeTable *AnyAmbiguousAliasesTypeTable() { … }

}  // namespace Example

inline const ::flatbuffers::TypeTable *InParentNamespaceTypeTable() { … }

namespace Example2 {

inline const ::flatbuffers::TypeTable *MonsterTypeTable() { … }

}  // namespace Example2

namespace Example {

inline const ::flatbuffers::TypeTable *TestTypeTable() { … }

inline const ::flatbuffers::TypeTable *TestSimpleTableWithEnumTypeTable() { … }

inline const ::flatbuffers::TypeTable *Vec3TypeTable() { … }

inline const ::flatbuffers::TypeTable *AbilityTypeTable() { … }

inline const ::flatbuffers::TypeTable *StructOfStructsTypeTable() { … }

inline const ::flatbuffers::TypeTable *StructOfStructsOfStructsTypeTable() { … }

inline const ::flatbuffers::TypeTable *StatTypeTable() { … }

inline const ::flatbuffers::TypeTable *ReferrableTypeTable() { … }

inline const ::flatbuffers::TypeTable *MonsterTypeTable() { … }

inline const ::flatbuffers::TypeTable *TypeAliasesTypeTable() { … }

inline const MyGame::Example::Monster *GetMonster(const void *buf) { … }

inline const MyGame::Example::Monster *GetSizePrefixedMonster(const void *buf) { … }

inline Monster *GetMutableMonster(void *buf) { … }

inline MyGame::Example::Monster *GetMutableSizePrefixedMonster(void *buf) { … }

inline const char *MonsterIdentifier() { … }

inline bool MonsterBufferHasIdentifier(const void *buf) { … }

inline bool SizePrefixedMonsterBufferHasIdentifier(const void *buf) { … }

inline bool VerifyMonsterBuffer(
    ::flatbuffers::Verifier &verifier) { … }

inline bool VerifySizePrefixedMonsterBuffer(
    ::flatbuffers::Verifier &verifier) { … }

inline const char *MonsterExtension() { … }

inline void FinishMonsterBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<MyGame::Example::Monster> root) { … }

inline void FinishSizePrefixedMonsterBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<MyGame::Example::Monster> root) { … }

inline std::unique_ptr<MyGame::Example::MonsterT> UnPackMonster(
    const void *buf,
    const ::flatbuffers::resolver_function_t *res = nullptr) { … }

inline std::unique_ptr<MyGame::Example::MonsterT> UnPackSizePrefixedMonster(
    const void *buf,
    const ::flatbuffers::resolver_function_t *res = nullptr) { … }

}  // namespace Example
}  // namespace MyGame

#endif  // FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_
chromium/third_party/flatbuffers/src/tests/monster_test_generated.h
