alignment_test_generated.h | Explore in Territory

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

#ifndef FLATBUFFERS_GENERATED_ALIGNMENTTEST_H_
#define FLATBUFFERS_GENERATED_ALIGNMENTTEST_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 BadAlignmentSmall;

struct BadAlignmentLarge;

struct OuterLarge;
struct OuterLargeBuilder;
struct OuterLargeT;

struct BadAlignmentRoot;
struct BadAlignmentRootBuilder;
struct BadAlignmentRootT;

struct EvenSmallStruct;

struct OddSmallStruct;

struct SmallStructs;
struct SmallStructsBuilder;
struct SmallStructsT;

bool operator==(const BadAlignmentSmall& lhs, const BadAlignmentSmall& rhs);
bool operator!=(const BadAlignmentSmall& lhs, const BadAlignmentSmall& rhs);
bool operator==(const BadAlignmentLarge& lhs, const BadAlignmentLarge& rhs);
bool operator!=(const BadAlignmentLarge& lhs, const BadAlignmentLarge& rhs);
bool operator==(const OuterLargeT& lhs, const OuterLargeT& rhs);
bool operator!=(const OuterLargeT& lhs, const OuterLargeT& rhs);
bool operator==(const BadAlignmentRootT& lhs, const BadAlignmentRootT& rhs);
bool operator!=(const BadAlignmentRootT& lhs, const BadAlignmentRootT& rhs);
bool operator==(const EvenSmallStruct& lhs, const EvenSmallStruct& rhs);
bool operator!=(const EvenSmallStruct& lhs, const EvenSmallStruct& rhs);
bool operator==(const OddSmallStruct& lhs, const OddSmallStruct& rhs);
bool operator!=(const OddSmallStruct& lhs, const OddSmallStruct& rhs);
bool operator==(const SmallStructsT& lhs, const SmallStructsT& rhs);
bool operator!=(const SmallStructsT& lhs, const SmallStructsT& rhs);

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

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

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

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

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

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

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

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

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

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

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8)
BadAlignmentLarge FLATBUFFERS_FINAL_CLASS { … };
FLATBUFFERS_STRUCT_END(…);

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

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

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) EvenSmallStruct FLATBUFFERS_FINAL_CLASS { … };
FLATBUFFERS_STRUCT_END(…);

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

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

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) OddSmallStruct FLATBUFFERS_FINAL_CLASS { … };
FLATBUFFERS_STRUCT_END(…);

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

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

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

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

struct OuterLargeBuilder { … };

inline ::flatbuffers::Offset<OuterLarge> CreateOuterLarge(
    ::flatbuffers::FlatBufferBuilder& _fbb,
    const BadAlignmentLarge* large = nullptr) { … }

::flatbuffers::Offset<OuterLarge> CreateOuterLarge(
    ::flatbuffers::FlatBufferBuilder& _fbb,
    const OuterLargeT* _o,
    const ::flatbuffers::rehasher_function_t* _rehasher = nullptr);

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

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

struct BadAlignmentRootBuilder { … };

inline ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(
    ::flatbuffers::FlatBufferBuilder& _fbb,
    ::flatbuffers::Offset<OuterLarge> large = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<const BadAlignmentSmall*>>
        small = 0) { … }

inline ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRootDirect(
    ::flatbuffers::FlatBufferBuilder& _fbb,
    ::flatbuffers::Offset<OuterLarge> large = 0,
    const std::vector<BadAlignmentSmall>* small = nullptr) { … }

::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(
    ::flatbuffers::FlatBufferBuilder& _fbb,
    const BadAlignmentRootT* _o,
    const ::flatbuffers::rehasher_function_t* _rehasher = nullptr);

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

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

struct SmallStructsBuilder { … };

inline ::flatbuffers::Offset<SmallStructs> CreateSmallStructs(
    ::flatbuffers::FlatBufferBuilder& _fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<const EvenSmallStruct*>>
        even_structs = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<const OddSmallStruct*>>
        odd_structs = 0) { … }

inline ::flatbuffers::Offset<SmallStructs> CreateSmallStructsDirect(
    ::flatbuffers::FlatBufferBuilder& _fbb,
    const std::vector<EvenSmallStruct>* even_structs = nullptr,
    const std::vector<OddSmallStruct>* odd_structs = nullptr) { … }

::flatbuffers::Offset<SmallStructs> CreateSmallStructs(
    ::flatbuffers::FlatBufferBuilder& _fbb,
    const SmallStructsT* _o,
    const ::flatbuffers::rehasher_function_t* _rehasher = nullptr);

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

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

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

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

inline OuterLargeT* OuterLarge::UnPack(
    const ::flatbuffers::resolver_function_t* _resolver) const { … }

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

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

inline ::flatbuffers::Offset<OuterLarge> CreateOuterLarge(
    ::flatbuffers::FlatBufferBuilder& _fbb,
    const OuterLargeT* _o,
    const ::flatbuffers::rehasher_function_t* _rehasher) { … }

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

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

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

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

inline BadAlignmentRootT* BadAlignmentRoot::UnPack(
    const ::flatbuffers::resolver_function_t* _resolver) const { … }

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

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

inline ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(
    ::flatbuffers::FlatBufferBuilder& _fbb,
    const BadAlignmentRootT* _o,
    const ::flatbuffers::rehasher_function_t* _rehasher) { … }

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

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

inline SmallStructsT* SmallStructs::UnPack(
    const ::flatbuffers::resolver_function_t* _resolver) const { … }

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

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

inline ::flatbuffers::Offset<SmallStructs> CreateSmallStructs(
    ::flatbuffers::FlatBufferBuilder& _fbb,
    const SmallStructsT* _o,
    const ::flatbuffers::rehasher_function_t* _rehasher) { … }

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

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

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

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

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

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

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

inline const SmallStructs* GetSmallStructs(const void* buf) { … }

inline const SmallStructs* GetSizePrefixedSmallStructs(const void* buf) { … }

inline SmallStructs* GetMutableSmallStructs(void* buf) { … }

inline SmallStructs* GetMutableSizePrefixedSmallStructs(void* buf) { … }

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

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

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

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

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

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

#endif  // FLATBUFFERS_GENERATED_ALIGNMENTTEST_H_
chromium/third_party/flatbuffers/generated/tests/alignment_test_generated.h
