chromium/third_party/flatbuffers/src/tests/union_vector/union_vector_generated.h

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


#ifndef FLATBUFFERS_GENERATED_UNIONVECTOR_H_
#define FLATBUFFERS_GENERATED_UNIONVECTOR_H_

#include "flatbuffers/flatbuffers.h"

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

struct Attacker;
struct AttackerBuilder;
struct AttackerT;

struct Rapunzel;

struct BookReader;

struct FallingTub;

struct HandFan;
struct HandFanBuilder;
struct HandFanT;

struct Movie;
struct MovieBuilder;
struct MovieT;

bool operator==(const AttackerT &lhs, const AttackerT &rhs);
bool operator!=(const AttackerT &lhs, const AttackerT &rhs);
bool operator==(const Rapunzel &lhs, const Rapunzel &rhs);
bool operator!=(const Rapunzel &lhs, const Rapunzel &rhs);
bool operator==(const BookReader &lhs, const BookReader &rhs);
bool operator!=(const BookReader &lhs, const BookReader &rhs);
bool operator==(const FallingTub &lhs, const FallingTub &rhs);
bool operator!=(const FallingTub &lhs, const FallingTub &rhs);
bool operator==(const HandFanT &lhs, const HandFanT &rhs);
bool operator!=(const HandFanT &lhs, const HandFanT &rhs);
bool operator==(const MovieT &lhs, const MovieT &rhs);
bool operator!=(const MovieT &lhs, const MovieT &rhs);

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

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

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

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

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

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

enum Character : uint8_t { … };

inline const Character (&EnumValuesCharacter())[7] { … }

inline const char * const *EnumNamesCharacter() { … }

inline const char *EnumNameCharacter(Character e) { … }

struct CharacterUnion { … };


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

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

bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj, Character type);
bool VerifyCharacterVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);

enum Gadget : uint8_t { … };

inline const Gadget (&EnumValuesGadget())[3] { … }

inline const char * const *EnumNamesGadget() { … }

inline const char *EnumNameGadget(Gadget e) { … }

template<typename T> struct GadgetTraits { … };

template<> struct GadgetTraits<FallingTub> { … };

template<> struct GadgetTraits<HandFan> { … };

template<typename T> struct GadgetUnionTraits { … };

template<> struct GadgetUnionTraits<FallingTub> { … };

template<> struct GadgetUnionTraits<HandFanT> { … };

struct GadgetUnion { … };


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

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

bool VerifyGadget(::flatbuffers::Verifier &verifier, const void *obj, Gadget type);
bool VerifyGadgetVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS { … };
FLATBUFFERS_STRUCT_END(…);

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

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


FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BookReader FLATBUFFERS_FINAL_CLASS { … };
FLATBUFFERS_STRUCT_END(…);

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

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


FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) FallingTub FLATBUFFERS_FINAL_CLASS { … };
FLATBUFFERS_STRUCT_END(…);

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

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


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

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

struct AttackerBuilder { … };

inline ::flatbuffers::Offset<Attacker> CreateAttacker(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t sword_attack_damage = 0) { … }

::flatbuffers::Offset<Attacker> CreateAttacker(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

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

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

struct HandFanBuilder { … };

inline ::flatbuffers::Offset<HandFan> CreateHandFan(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t length = 0) { … }

::flatbuffers::Offset<HandFan> CreateHandFan(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);

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

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

struct MovieBuilder { … };

inline ::flatbuffers::Offset<Movie> CreateMovie(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    Character main_character_type = Character_NONE,
    ::flatbuffers::Offset<void> main_character = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> characters_type = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters = 0) { … }

inline ::flatbuffers::Offset<Movie> CreateMovieDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    Character main_character_type = Character_NONE,
    ::flatbuffers::Offset<void> main_character = 0,
    const std::vector<uint8_t> *characters_type = nullptr,
    const std::vector<::flatbuffers::Offset<void>> *characters = nullptr) { … }

::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);


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

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


inline AttackerT *Attacker::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

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

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

inline ::flatbuffers::Offset<Attacker> CreateAttacker(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


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

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


inline HandFanT *HandFan::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

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

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

inline ::flatbuffers::Offset<HandFan> CreateHandFan(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }


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

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


inline MovieT *Movie::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { … }

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

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

inline ::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { … }

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

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

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

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

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

inline void CharacterUnion::Reset() { … }

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

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

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

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

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

inline void GadgetUnion::Reset() { … }

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

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

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

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

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

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

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

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

inline const Movie *GetMovie(const void *buf) { … }

inline const Movie *GetSizePrefixedMovie(const void *buf) { … }

inline Movie *GetMutableMovie(void *buf) { … }

inline Movie *GetMutableSizePrefixedMovie(void *buf) { … }

inline const char *MovieIdentifier() { … }

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

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

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

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

inline void FinishMovieBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<Movie> root) { … }

inline void FinishSizePrefixedMovieBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<Movie> root) { … }

inline std::unique_ptr<MovieT> UnPackMovie(
    const void *buf,
    const ::flatbuffers::resolver_function_t *res = nullptr) { … }

inline std::unique_ptr<MovieT> UnPackSizePrefixedMovie(
    const void *buf,
    const ::flatbuffers::resolver_function_t *res = nullptr) { … }

#endif  // FLATBUFFERS_GENERATED_UNIONVECTOR_H_