| |
|
|
|
|
| #ifndef FLATBUFFERS_GENERATED_BEXALL_BEX_WIRE_H_ |
| #define FLATBUFFERS_GENERATED_BEXALL_BEX_WIRE_H_ |
|
|
| #include "flatbuffers/flatbuffers.h" |
|
|
| |
| |
| static_assert(FLATBUFFERS_VERSION_MAJOR == 25 && |
| FLATBUFFERS_VERSION_MINOR == 12 && |
| FLATBUFFERS_VERSION_REVISION == 19, |
| "Non-compatible flatbuffers version included"); |
|
|
| namespace bex { |
| namespace wire { |
|
|
| struct Image; |
| struct ImageBuilder; |
|
|
| struct ImageSet; |
| struct ImageSetBuilder; |
|
|
| struct LinkedId; |
| struct LinkedIdBuilder; |
|
|
| struct Attr; |
| struct AttrBuilder; |
|
|
| struct MediaCard; |
| struct MediaCardBuilder; |
|
|
| struct CategoryLink; |
| struct CategoryLinkBuilder; |
|
|
| struct HomeSection; |
| struct HomeSectionBuilder; |
|
|
| struct PagedResult; |
| struct PagedResultBuilder; |
|
|
| struct Episode; |
| struct EpisodeBuilder; |
|
|
| struct Season; |
| struct SeasonBuilder; |
|
|
| struct Person; |
| struct PersonBuilder; |
|
|
| struct MediaInfo; |
| struct MediaInfoBuilder; |
|
|
| struct VideoResolution; |
| struct VideoResolutionBuilder; |
|
|
| struct VideoTrack; |
| struct VideoTrackBuilder; |
|
|
| struct SubtitleTrack; |
| struct SubtitleTrackBuilder; |
|
|
| struct Server; |
| struct ServerBuilder; |
|
|
| struct StreamSource; |
| struct StreamSourceBuilder; |
|
|
| struct HomeResult; |
| struct HomeResultBuilder; |
|
|
| struct CategoryResult; |
| struct CategoryResultBuilder; |
|
|
| struct SearchResult; |
| struct SearchResultBuilder; |
|
|
| struct InfoResult; |
| struct InfoResultBuilder; |
|
|
| struct ServersResult; |
| struct ServersResultBuilder; |
|
|
| struct StreamResult; |
| struct StreamResultBuilder; |
|
|
| struct ErrorInfo; |
| struct ErrorInfoBuilder; |
|
|
| enum MediaKind : int8_t { |
| MediaKind_Movie = 0, |
| MediaKind_Series = 1, |
| MediaKind_Anime = 2, |
| MediaKind_Short = 3, |
| MediaKind_Special = 4, |
| MediaKind_Documentary = 5, |
| MediaKind_Music = 6, |
| MediaKind_Podcast = 7, |
| MediaKind_Book = 8, |
| MediaKind_Live = 9, |
| MediaKind_Unknown = 10, |
| MediaKind_MIN = MediaKind_Movie, |
| MediaKind_MAX = MediaKind_Unknown |
| }; |
|
|
| inline const MediaKind (&EnumValuesMediaKind())[11] { |
| static const MediaKind values[] = { |
| MediaKind_Movie, |
| MediaKind_Series, |
| MediaKind_Anime, |
| MediaKind_Short, |
| MediaKind_Special, |
| MediaKind_Documentary, |
| MediaKind_Music, |
| MediaKind_Podcast, |
| MediaKind_Book, |
| MediaKind_Live, |
| MediaKind_Unknown |
| }; |
| return values; |
| } |
|
|
| inline const char * const *EnumNamesMediaKind() { |
| static const char * const names[12] = { |
| "Movie", |
| "Series", |
| "Anime", |
| "Short", |
| "Special", |
| "Documentary", |
| "Music", |
| "Podcast", |
| "Book", |
| "Live", |
| "Unknown", |
| nullptr |
| }; |
| return names; |
| } |
|
|
| inline const char *EnumNameMediaKind(MediaKind e) { |
| if (::flatbuffers::IsOutRange(e, MediaKind_Movie, MediaKind_Unknown)) return ""; |
| const size_t index = static_cast<size_t>(e); |
| return EnumNamesMediaKind()[index]; |
| } |
|
|
| enum Status : int8_t { |
| Status_Unknown = 0, |
| Status_Upcoming = 1, |
| Status_Ongoing = 2, |
| Status_Completed = 3, |
| Status_Cancelled = 4, |
| Status_Paused = 5, |
| Status_MIN = Status_Unknown, |
| Status_MAX = Status_Paused |
| }; |
|
|
| inline const Status (&EnumValuesStatus())[6] { |
| static const Status values[] = { |
| Status_Unknown, |
| Status_Upcoming, |
| Status_Ongoing, |
| Status_Completed, |
| Status_Cancelled, |
| Status_Paused |
| }; |
| return values; |
| } |
|
|
| inline const char * const *EnumNamesStatus() { |
| static const char * const names[7] = { |
| "Unknown", |
| "Upcoming", |
| "Ongoing", |
| "Completed", |
| "Cancelled", |
| "Paused", |
| nullptr |
| }; |
| return names; |
| } |
|
|
| inline const char *EnumNameStatus(Status e) { |
| if (::flatbuffers::IsOutRange(e, Status_Unknown, Status_Paused)) return ""; |
| const size_t index = static_cast<size_t>(e); |
| return EnumNamesStatus()[index]; |
| } |
|
|
| enum StreamFormat : int8_t { |
| StreamFormat_Hls = 0, |
| StreamFormat_Dash = 1, |
| StreamFormat_Progressive = 2, |
| StreamFormat_Unknown = 3, |
| StreamFormat_MIN = StreamFormat_Hls, |
| StreamFormat_MAX = StreamFormat_Unknown |
| }; |
|
|
| inline const StreamFormat (&EnumValuesStreamFormat())[4] { |
| static const StreamFormat values[] = { |
| StreamFormat_Hls, |
| StreamFormat_Dash, |
| StreamFormat_Progressive, |
| StreamFormat_Unknown |
| }; |
| return values; |
| } |
|
|
| inline const char * const *EnumNamesStreamFormat() { |
| static const char * const names[5] = { |
| "Hls", |
| "Dash", |
| "Progressive", |
| "Unknown", |
| nullptr |
| }; |
| return names; |
| } |
|
|
| inline const char *EnumNameStreamFormat(StreamFormat e) { |
| if (::flatbuffers::IsOutRange(e, StreamFormat_Hls, StreamFormat_Unknown)) return ""; |
| const size_t index = static_cast<size_t>(e); |
| return EnumNamesStreamFormat()[index]; |
| } |
|
|
| struct Image FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef ImageBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_URL = 4, |
| VT_LAYOUT = 6, |
| VT_WIDTH = 8, |
| VT_HEIGHT = 10, |
| VT_BLURHASH = 12 |
| }; |
| const ::flatbuffers::String *url() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_URL); |
| } |
| ::flatbuffers::String *mutable_url() { |
| return GetPointer<::flatbuffers::String *>(VT_URL); |
| } |
| const ::flatbuffers::String *layout() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_LAYOUT); |
| } |
| ::flatbuffers::String *mutable_layout() { |
| return GetPointer<::flatbuffers::String *>(VT_LAYOUT); |
| } |
| uint32_t width() const { |
| return GetField<uint32_t>(VT_WIDTH, 0); |
| } |
| bool mutate_width(uint32_t _width = 0) { |
| return SetField<uint32_t>(VT_WIDTH, _width, 0); |
| } |
| uint32_t height() const { |
| return GetField<uint32_t>(VT_HEIGHT, 0); |
| } |
| bool mutate_height(uint32_t _height = 0) { |
| return SetField<uint32_t>(VT_HEIGHT, _height, 0); |
| } |
| const ::flatbuffers::String *blurhash() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_BLURHASH); |
| } |
| ::flatbuffers::String *mutable_blurhash() { |
| return GetPointer<::flatbuffers::String *>(VT_BLURHASH); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_URL) && |
| verifier.VerifyString(url()) && |
| VerifyOffset(verifier, VT_LAYOUT) && |
| verifier.VerifyString(layout()) && |
| VerifyField<uint32_t>(verifier, VT_WIDTH, 4) && |
| VerifyField<uint32_t>(verifier, VT_HEIGHT, 4) && |
| VerifyOffset(verifier, VT_BLURHASH) && |
| verifier.VerifyString(blurhash()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct ImageBuilder { |
| typedef Image Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_url(::flatbuffers::Offset<::flatbuffers::String> url) { |
| fbb_.AddOffset(Image::VT_URL, url); |
| } |
| void add_layout(::flatbuffers::Offset<::flatbuffers::String> layout) { |
| fbb_.AddOffset(Image::VT_LAYOUT, layout); |
| } |
| void add_width(uint32_t width) { |
| fbb_.AddElement<uint32_t>(Image::VT_WIDTH, width, 0); |
| } |
| void add_height(uint32_t height) { |
| fbb_.AddElement<uint32_t>(Image::VT_HEIGHT, height, 0); |
| } |
| void add_blurhash(::flatbuffers::Offset<::flatbuffers::String> blurhash) { |
| fbb_.AddOffset(Image::VT_BLURHASH, blurhash); |
| } |
| explicit ImageBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<Image> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<Image>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<Image> CreateImage( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<::flatbuffers::String> url = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> layout = 0, |
| uint32_t width = 0, |
| uint32_t height = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> blurhash = 0) { |
| ImageBuilder builder_(_fbb); |
| builder_.add_blurhash(blurhash); |
| builder_.add_height(height); |
| builder_.add_width(width); |
| builder_.add_layout(layout); |
| builder_.add_url(url); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<Image> CreateImageDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| const char *url = nullptr, |
| const char *layout = nullptr, |
| uint32_t width = 0, |
| uint32_t height = 0, |
| const char *blurhash = nullptr) { |
| auto url__ = url ? _fbb.CreateString(url) : 0; |
| auto layout__ = layout ? _fbb.CreateString(layout) : 0; |
| auto blurhash__ = blurhash ? _fbb.CreateString(blurhash) : 0; |
| return bex::wire::CreateImage( |
| _fbb, |
| url__, |
| layout__, |
| width, |
| height, |
| blurhash__); |
| } |
|
|
| struct ImageSet FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef ImageSetBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_LOW = 4, |
| VT_MEDIUM = 6, |
| VT_HIGH = 8, |
| VT_BACKDROP = 10, |
| VT_LOGO = 12 |
| }; |
| const bex::wire::Image *low() const { |
| return GetPointer<const bex::wire::Image *>(VT_LOW); |
| } |
| bex::wire::Image *mutable_low() { |
| return GetPointer<bex::wire::Image *>(VT_LOW); |
| } |
| const bex::wire::Image *medium() const { |
| return GetPointer<const bex::wire::Image *>(VT_MEDIUM); |
| } |
| bex::wire::Image *mutable_medium() { |
| return GetPointer<bex::wire::Image *>(VT_MEDIUM); |
| } |
| const bex::wire::Image *high() const { |
| return GetPointer<const bex::wire::Image *>(VT_HIGH); |
| } |
| bex::wire::Image *mutable_high() { |
| return GetPointer<bex::wire::Image *>(VT_HIGH); |
| } |
| const bex::wire::Image *backdrop() const { |
| return GetPointer<const bex::wire::Image *>(VT_BACKDROP); |
| } |
| bex::wire::Image *mutable_backdrop() { |
| return GetPointer<bex::wire::Image *>(VT_BACKDROP); |
| } |
| const bex::wire::Image *logo() const { |
| return GetPointer<const bex::wire::Image *>(VT_LOGO); |
| } |
| bex::wire::Image *mutable_logo() { |
| return GetPointer<bex::wire::Image *>(VT_LOGO); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_LOW) && |
| verifier.VerifyTable(low()) && |
| VerifyOffset(verifier, VT_MEDIUM) && |
| verifier.VerifyTable(medium()) && |
| VerifyOffset(verifier, VT_HIGH) && |
| verifier.VerifyTable(high()) && |
| VerifyOffset(verifier, VT_BACKDROP) && |
| verifier.VerifyTable(backdrop()) && |
| VerifyOffset(verifier, VT_LOGO) && |
| verifier.VerifyTable(logo()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct ImageSetBuilder { |
| typedef ImageSet Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_low(::flatbuffers::Offset<bex::wire::Image> low) { |
| fbb_.AddOffset(ImageSet::VT_LOW, low); |
| } |
| void add_medium(::flatbuffers::Offset<bex::wire::Image> medium) { |
| fbb_.AddOffset(ImageSet::VT_MEDIUM, medium); |
| } |
| void add_high(::flatbuffers::Offset<bex::wire::Image> high) { |
| fbb_.AddOffset(ImageSet::VT_HIGH, high); |
| } |
| void add_backdrop(::flatbuffers::Offset<bex::wire::Image> backdrop) { |
| fbb_.AddOffset(ImageSet::VT_BACKDROP, backdrop); |
| } |
| void add_logo(::flatbuffers::Offset<bex::wire::Image> logo) { |
| fbb_.AddOffset(ImageSet::VT_LOGO, logo); |
| } |
| explicit ImageSetBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<ImageSet> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<ImageSet>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<ImageSet> CreateImageSet( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<bex::wire::Image> low = 0, |
| ::flatbuffers::Offset<bex::wire::Image> medium = 0, |
| ::flatbuffers::Offset<bex::wire::Image> high = 0, |
| ::flatbuffers::Offset<bex::wire::Image> backdrop = 0, |
| ::flatbuffers::Offset<bex::wire::Image> logo = 0) { |
| ImageSetBuilder builder_(_fbb); |
| builder_.add_logo(logo); |
| builder_.add_backdrop(backdrop); |
| builder_.add_high(high); |
| builder_.add_medium(medium); |
| builder_.add_low(low); |
| return builder_.Finish(); |
| } |
|
|
| struct LinkedId FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef LinkedIdBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_SOURCE = 4, |
| VT_ID = 6 |
| }; |
| const ::flatbuffers::String *source() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_SOURCE); |
| } |
| ::flatbuffers::String *mutable_source() { |
| return GetPointer<::flatbuffers::String *>(VT_SOURCE); |
| } |
| const ::flatbuffers::String *id() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_ID); |
| } |
| ::flatbuffers::String *mutable_id() { |
| return GetPointer<::flatbuffers::String *>(VT_ID); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_SOURCE) && |
| verifier.VerifyString(source()) && |
| VerifyOffset(verifier, VT_ID) && |
| verifier.VerifyString(id()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct LinkedIdBuilder { |
| typedef LinkedId Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_source(::flatbuffers::Offset<::flatbuffers::String> source) { |
| fbb_.AddOffset(LinkedId::VT_SOURCE, source); |
| } |
| void add_id(::flatbuffers::Offset<::flatbuffers::String> id) { |
| fbb_.AddOffset(LinkedId::VT_ID, id); |
| } |
| explicit LinkedIdBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<LinkedId> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<LinkedId>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<LinkedId> CreateLinkedId( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<::flatbuffers::String> source = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> id = 0) { |
| LinkedIdBuilder builder_(_fbb); |
| builder_.add_id(id); |
| builder_.add_source(source); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<LinkedId> CreateLinkedIdDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| const char *source = nullptr, |
| const char *id = nullptr) { |
| auto source__ = source ? _fbb.CreateString(source) : 0; |
| auto id__ = id ? _fbb.CreateString(id) : 0; |
| return bex::wire::CreateLinkedId( |
| _fbb, |
| source__, |
| id__); |
| } |
|
|
| struct Attr FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef AttrBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_KEY = 4, |
| VT_VALUE = 6 |
| }; |
| const ::flatbuffers::String *key() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_KEY); |
| } |
| ::flatbuffers::String *mutable_key() { |
| return GetPointer<::flatbuffers::String *>(VT_KEY); |
| } |
| const ::flatbuffers::String *value() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_VALUE); |
| } |
| ::flatbuffers::String *mutable_value() { |
| return GetPointer<::flatbuffers::String *>(VT_VALUE); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_KEY) && |
| verifier.VerifyString(key()) && |
| VerifyOffset(verifier, VT_VALUE) && |
| verifier.VerifyString(value()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct AttrBuilder { |
| typedef Attr Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_key(::flatbuffers::Offset<::flatbuffers::String> key) { |
| fbb_.AddOffset(Attr::VT_KEY, key); |
| } |
| void add_value(::flatbuffers::Offset<::flatbuffers::String> value) { |
| fbb_.AddOffset(Attr::VT_VALUE, value); |
| } |
| explicit AttrBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<Attr> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<Attr>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<Attr> CreateAttr( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<::flatbuffers::String> key = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> value = 0) { |
| AttrBuilder builder_(_fbb); |
| builder_.add_value(value); |
| builder_.add_key(key); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<Attr> CreateAttrDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| const char *key = nullptr, |
| const char *value = nullptr) { |
| auto key__ = key ? _fbb.CreateString(key) : 0; |
| auto value__ = value ? _fbb.CreateString(value) : 0; |
| return bex::wire::CreateAttr( |
| _fbb, |
| key__, |
| value__); |
| } |
|
|
| struct MediaCard FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef MediaCardBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_ID = 4, |
| VT_TITLE = 6, |
| VT_KIND = 8, |
| VT_IMAGES = 10, |
| VT_ORIGINAL_TITLE = 12, |
| VT_TAGLINE = 14, |
| VT_YEAR = 16, |
| VT_SCORE = 18, |
| VT_GENRES = 20, |
| VT_STATUS = 22, |
| VT_CONTENT_RATING = 24, |
| VT_URL = 26, |
| VT_IDS = 28, |
| VT_EXTRA = 30 |
| }; |
| const ::flatbuffers::String *id() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_ID); |
| } |
| ::flatbuffers::String *mutable_id() { |
| return GetPointer<::flatbuffers::String *>(VT_ID); |
| } |
| const ::flatbuffers::String *title() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_TITLE); |
| } |
| ::flatbuffers::String *mutable_title() { |
| return GetPointer<::flatbuffers::String *>(VT_TITLE); |
| } |
| bex::wire::MediaKind kind() const { |
| return static_cast<bex::wire::MediaKind>(GetField<int8_t>(VT_KIND, 0)); |
| } |
| bool mutate_kind(bex::wire::MediaKind _kind = static_cast<bex::wire::MediaKind>(0)) { |
| return SetField<int8_t>(VT_KIND, static_cast<int8_t>(_kind), 0); |
| } |
| const bex::wire::ImageSet *images() const { |
| return GetPointer<const bex::wire::ImageSet *>(VT_IMAGES); |
| } |
| bex::wire::ImageSet *mutable_images() { |
| return GetPointer<bex::wire::ImageSet *>(VT_IMAGES); |
| } |
| const ::flatbuffers::String *original_title() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_ORIGINAL_TITLE); |
| } |
| ::flatbuffers::String *mutable_original_title() { |
| return GetPointer<::flatbuffers::String *>(VT_ORIGINAL_TITLE); |
| } |
| const ::flatbuffers::String *tagline() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_TAGLINE); |
| } |
| ::flatbuffers::String *mutable_tagline() { |
| return GetPointer<::flatbuffers::String *>(VT_TAGLINE); |
| } |
| const ::flatbuffers::String *year() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_YEAR); |
| } |
| ::flatbuffers::String *mutable_year() { |
| return GetPointer<::flatbuffers::String *>(VT_YEAR); |
| } |
| uint32_t score() const { |
| return GetField<uint32_t>(VT_SCORE, 0); |
| } |
| bool mutate_score(uint32_t _score = 0) { |
| return SetField<uint32_t>(VT_SCORE, _score, 0); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *genres() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_GENRES); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *mutable_genres() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_GENRES); |
| } |
| bex::wire::Status status() const { |
| return static_cast<bex::wire::Status>(GetField<int8_t>(VT_STATUS, 0)); |
| } |
| bool mutate_status(bex::wire::Status _status = static_cast<bex::wire::Status>(0)) { |
| return SetField<int8_t>(VT_STATUS, static_cast<int8_t>(_status), 0); |
| } |
| const ::flatbuffers::String *content_rating() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_CONTENT_RATING); |
| } |
| ::flatbuffers::String *mutable_content_rating() { |
| return GetPointer<::flatbuffers::String *>(VT_CONTENT_RATING); |
| } |
| const ::flatbuffers::String *url() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_URL); |
| } |
| ::flatbuffers::String *mutable_url() { |
| return GetPointer<::flatbuffers::String *>(VT_URL); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>> *ids() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>> *>(VT_IDS); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>> *mutable_ids() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>> *>(VT_IDS); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *extra() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *mutable_extra() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_ID) && |
| verifier.VerifyString(id()) && |
| VerifyOffset(verifier, VT_TITLE) && |
| verifier.VerifyString(title()) && |
| VerifyField<int8_t>(verifier, VT_KIND, 1) && |
| VerifyOffset(verifier, VT_IMAGES) && |
| verifier.VerifyTable(images()) && |
| VerifyOffset(verifier, VT_ORIGINAL_TITLE) && |
| verifier.VerifyString(original_title()) && |
| VerifyOffset(verifier, VT_TAGLINE) && |
| verifier.VerifyString(tagline()) && |
| VerifyOffset(verifier, VT_YEAR) && |
| verifier.VerifyString(year()) && |
| VerifyField<uint32_t>(verifier, VT_SCORE, 4) && |
| VerifyOffset(verifier, VT_GENRES) && |
| verifier.VerifyVector(genres()) && |
| verifier.VerifyVectorOfStrings(genres()) && |
| VerifyField<int8_t>(verifier, VT_STATUS, 1) && |
| VerifyOffset(verifier, VT_CONTENT_RATING) && |
| verifier.VerifyString(content_rating()) && |
| VerifyOffset(verifier, VT_URL) && |
| verifier.VerifyString(url()) && |
| VerifyOffset(verifier, VT_IDS) && |
| verifier.VerifyVector(ids()) && |
| verifier.VerifyVectorOfTables(ids()) && |
| VerifyOffset(verifier, VT_EXTRA) && |
| verifier.VerifyVector(extra()) && |
| verifier.VerifyVectorOfTables(extra()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct MediaCardBuilder { |
| typedef MediaCard Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_id(::flatbuffers::Offset<::flatbuffers::String> id) { |
| fbb_.AddOffset(MediaCard::VT_ID, id); |
| } |
| void add_title(::flatbuffers::Offset<::flatbuffers::String> title) { |
| fbb_.AddOffset(MediaCard::VT_TITLE, title); |
| } |
| void add_kind(bex::wire::MediaKind kind) { |
| fbb_.AddElement<int8_t>(MediaCard::VT_KIND, static_cast<int8_t>(kind), 0); |
| } |
| void add_images(::flatbuffers::Offset<bex::wire::ImageSet> images) { |
| fbb_.AddOffset(MediaCard::VT_IMAGES, images); |
| } |
| void add_original_title(::flatbuffers::Offset<::flatbuffers::String> original_title) { |
| fbb_.AddOffset(MediaCard::VT_ORIGINAL_TITLE, original_title); |
| } |
| void add_tagline(::flatbuffers::Offset<::flatbuffers::String> tagline) { |
| fbb_.AddOffset(MediaCard::VT_TAGLINE, tagline); |
| } |
| void add_year(::flatbuffers::Offset<::flatbuffers::String> year) { |
| fbb_.AddOffset(MediaCard::VT_YEAR, year); |
| } |
| void add_score(uint32_t score) { |
| fbb_.AddElement<uint32_t>(MediaCard::VT_SCORE, score, 0); |
| } |
| void add_genres(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> genres) { |
| fbb_.AddOffset(MediaCard::VT_GENRES, genres); |
| } |
| void add_status(bex::wire::Status status) { |
| fbb_.AddElement<int8_t>(MediaCard::VT_STATUS, static_cast<int8_t>(status), 0); |
| } |
| void add_content_rating(::flatbuffers::Offset<::flatbuffers::String> content_rating) { |
| fbb_.AddOffset(MediaCard::VT_CONTENT_RATING, content_rating); |
| } |
| void add_url(::flatbuffers::Offset<::flatbuffers::String> url) { |
| fbb_.AddOffset(MediaCard::VT_URL, url); |
| } |
| void add_ids(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>>> ids) { |
| fbb_.AddOffset(MediaCard::VT_IDS, ids); |
| } |
| void add_extra(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra) { |
| fbb_.AddOffset(MediaCard::VT_EXTRA, extra); |
| } |
| explicit MediaCardBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<MediaCard> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<MediaCard>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<MediaCard> CreateMediaCard( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<::flatbuffers::String> id = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> title = 0, |
| bex::wire::MediaKind kind = bex::wire::MediaKind_Movie, |
| ::flatbuffers::Offset<bex::wire::ImageSet> images = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> original_title = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> tagline = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> year = 0, |
| uint32_t score = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> genres = 0, |
| bex::wire::Status status = bex::wire::Status_Unknown, |
| ::flatbuffers::Offset<::flatbuffers::String> content_rating = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> url = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>>> ids = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra = 0) { |
| MediaCardBuilder builder_(_fbb); |
| builder_.add_extra(extra); |
| builder_.add_ids(ids); |
| builder_.add_url(url); |
| builder_.add_content_rating(content_rating); |
| builder_.add_genres(genres); |
| builder_.add_score(score); |
| builder_.add_year(year); |
| builder_.add_tagline(tagline); |
| builder_.add_original_title(original_title); |
| builder_.add_images(images); |
| builder_.add_title(title); |
| builder_.add_id(id); |
| builder_.add_status(status); |
| builder_.add_kind(kind); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<MediaCard> CreateMediaCardDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| const char *id = nullptr, |
| const char *title = nullptr, |
| bex::wire::MediaKind kind = bex::wire::MediaKind_Movie, |
| ::flatbuffers::Offset<bex::wire::ImageSet> images = 0, |
| const char *original_title = nullptr, |
| const char *tagline = nullptr, |
| const char *year = nullptr, |
| uint32_t score = 0, |
| const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *genres = nullptr, |
| bex::wire::Status status = bex::wire::Status_Unknown, |
| const char *content_rating = nullptr, |
| const char *url = nullptr, |
| const std::vector<::flatbuffers::Offset<bex::wire::LinkedId>> *ids = nullptr, |
| const std::vector<::flatbuffers::Offset<bex::wire::Attr>> *extra = nullptr) { |
| auto id__ = id ? _fbb.CreateString(id) : 0; |
| auto title__ = title ? _fbb.CreateString(title) : 0; |
| auto original_title__ = original_title ? _fbb.CreateString(original_title) : 0; |
| auto tagline__ = tagline ? _fbb.CreateString(tagline) : 0; |
| auto year__ = year ? _fbb.CreateString(year) : 0; |
| auto genres__ = genres ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*genres) : 0; |
| auto content_rating__ = content_rating ? _fbb.CreateString(content_rating) : 0; |
| auto url__ = url ? _fbb.CreateString(url) : 0; |
| auto ids__ = ids ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::LinkedId>>(*ids) : 0; |
| auto extra__ = extra ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Attr>>(*extra) : 0; |
| return bex::wire::CreateMediaCard( |
| _fbb, |
| id__, |
| title__, |
| kind, |
| images, |
| original_title__, |
| tagline__, |
| year__, |
| score, |
| genres__, |
| status, |
| content_rating__, |
| url__, |
| ids__, |
| extra__); |
| } |
|
|
| struct CategoryLink FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef CategoryLinkBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_ID = 4, |
| VT_TITLE = 6, |
| VT_SUBTITLE = 8, |
| VT_IMAGE = 10 |
| }; |
| const ::flatbuffers::String *id() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_ID); |
| } |
| ::flatbuffers::String *mutable_id() { |
| return GetPointer<::flatbuffers::String *>(VT_ID); |
| } |
| const ::flatbuffers::String *title() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_TITLE); |
| } |
| ::flatbuffers::String *mutable_title() { |
| return GetPointer<::flatbuffers::String *>(VT_TITLE); |
| } |
| const ::flatbuffers::String *subtitle() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_SUBTITLE); |
| } |
| ::flatbuffers::String *mutable_subtitle() { |
| return GetPointer<::flatbuffers::String *>(VT_SUBTITLE); |
| } |
| const bex::wire::Image *image() const { |
| return GetPointer<const bex::wire::Image *>(VT_IMAGE); |
| } |
| bex::wire::Image *mutable_image() { |
| return GetPointer<bex::wire::Image *>(VT_IMAGE); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_ID) && |
| verifier.VerifyString(id()) && |
| VerifyOffset(verifier, VT_TITLE) && |
| verifier.VerifyString(title()) && |
| VerifyOffset(verifier, VT_SUBTITLE) && |
| verifier.VerifyString(subtitle()) && |
| VerifyOffset(verifier, VT_IMAGE) && |
| verifier.VerifyTable(image()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct CategoryLinkBuilder { |
| typedef CategoryLink Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_id(::flatbuffers::Offset<::flatbuffers::String> id) { |
| fbb_.AddOffset(CategoryLink::VT_ID, id); |
| } |
| void add_title(::flatbuffers::Offset<::flatbuffers::String> title) { |
| fbb_.AddOffset(CategoryLink::VT_TITLE, title); |
| } |
| void add_subtitle(::flatbuffers::Offset<::flatbuffers::String> subtitle) { |
| fbb_.AddOffset(CategoryLink::VT_SUBTITLE, subtitle); |
| } |
| void add_image(::flatbuffers::Offset<bex::wire::Image> image) { |
| fbb_.AddOffset(CategoryLink::VT_IMAGE, image); |
| } |
| explicit CategoryLinkBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<CategoryLink> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<CategoryLink>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<CategoryLink> CreateCategoryLink( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<::flatbuffers::String> id = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> title = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> subtitle = 0, |
| ::flatbuffers::Offset<bex::wire::Image> image = 0) { |
| CategoryLinkBuilder builder_(_fbb); |
| builder_.add_image(image); |
| builder_.add_subtitle(subtitle); |
| builder_.add_title(title); |
| builder_.add_id(id); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<CategoryLink> CreateCategoryLinkDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| const char *id = nullptr, |
| const char *title = nullptr, |
| const char *subtitle = nullptr, |
| ::flatbuffers::Offset<bex::wire::Image> image = 0) { |
| auto id__ = id ? _fbb.CreateString(id) : 0; |
| auto title__ = title ? _fbb.CreateString(title) : 0; |
| auto subtitle__ = subtitle ? _fbb.CreateString(subtitle) : 0; |
| return bex::wire::CreateCategoryLink( |
| _fbb, |
| id__, |
| title__, |
| subtitle__, |
| image); |
| } |
|
|
| struct HomeSection FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef HomeSectionBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_ID = 4, |
| VT_TITLE = 6, |
| VT_SUBTITLE = 8, |
| VT_ITEMS = 10, |
| VT_NEXT_PAGE = 12, |
| VT_LAYOUT = 14, |
| VT_SHOW_RANK = 16, |
| VT_CATEGORIES = 18, |
| VT_EXTRA = 20 |
| }; |
| const ::flatbuffers::String *id() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_ID); |
| } |
| ::flatbuffers::String *mutable_id() { |
| return GetPointer<::flatbuffers::String *>(VT_ID); |
| } |
| const ::flatbuffers::String *title() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_TITLE); |
| } |
| ::flatbuffers::String *mutable_title() { |
| return GetPointer<::flatbuffers::String *>(VT_TITLE); |
| } |
| const ::flatbuffers::String *subtitle() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_SUBTITLE); |
| } |
| ::flatbuffers::String *mutable_subtitle() { |
| return GetPointer<::flatbuffers::String *>(VT_SUBTITLE); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>> *items() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>> *>(VT_ITEMS); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>> *mutable_items() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>> *>(VT_ITEMS); |
| } |
| const ::flatbuffers::String *next_page() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_NEXT_PAGE); |
| } |
| ::flatbuffers::String *mutable_next_page() { |
| return GetPointer<::flatbuffers::String *>(VT_NEXT_PAGE); |
| } |
| const ::flatbuffers::String *layout() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_LAYOUT); |
| } |
| ::flatbuffers::String *mutable_layout() { |
| return GetPointer<::flatbuffers::String *>(VT_LAYOUT); |
| } |
| bool show_rank() const { |
| return GetField<uint8_t>(VT_SHOW_RANK, 0) != 0; |
| } |
| bool mutate_show_rank(bool _show_rank = 0) { |
| return SetField<uint8_t>(VT_SHOW_RANK, static_cast<uint8_t>(_show_rank), 0); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *categories() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *>(VT_CATEGORIES); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *mutable_categories() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *>(VT_CATEGORIES); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *extra() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *mutable_extra() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_ID) && |
| verifier.VerifyString(id()) && |
| VerifyOffset(verifier, VT_TITLE) && |
| verifier.VerifyString(title()) && |
| VerifyOffset(verifier, VT_SUBTITLE) && |
| verifier.VerifyString(subtitle()) && |
| VerifyOffset(verifier, VT_ITEMS) && |
| verifier.VerifyVector(items()) && |
| verifier.VerifyVectorOfTables(items()) && |
| VerifyOffset(verifier, VT_NEXT_PAGE) && |
| verifier.VerifyString(next_page()) && |
| VerifyOffset(verifier, VT_LAYOUT) && |
| verifier.VerifyString(layout()) && |
| VerifyField<uint8_t>(verifier, VT_SHOW_RANK, 1) && |
| VerifyOffset(verifier, VT_CATEGORIES) && |
| verifier.VerifyVector(categories()) && |
| verifier.VerifyVectorOfTables(categories()) && |
| VerifyOffset(verifier, VT_EXTRA) && |
| verifier.VerifyVector(extra()) && |
| verifier.VerifyVectorOfTables(extra()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct HomeSectionBuilder { |
| typedef HomeSection Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_id(::flatbuffers::Offset<::flatbuffers::String> id) { |
| fbb_.AddOffset(HomeSection::VT_ID, id); |
| } |
| void add_title(::flatbuffers::Offset<::flatbuffers::String> title) { |
| fbb_.AddOffset(HomeSection::VT_TITLE, title); |
| } |
| void add_subtitle(::flatbuffers::Offset<::flatbuffers::String> subtitle) { |
| fbb_.AddOffset(HomeSection::VT_SUBTITLE, subtitle); |
| } |
| void add_items(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>>> items) { |
| fbb_.AddOffset(HomeSection::VT_ITEMS, items); |
| } |
| void add_next_page(::flatbuffers::Offset<::flatbuffers::String> next_page) { |
| fbb_.AddOffset(HomeSection::VT_NEXT_PAGE, next_page); |
| } |
| void add_layout(::flatbuffers::Offset<::flatbuffers::String> layout) { |
| fbb_.AddOffset(HomeSection::VT_LAYOUT, layout); |
| } |
| void add_show_rank(bool show_rank) { |
| fbb_.AddElement<uint8_t>(HomeSection::VT_SHOW_RANK, static_cast<uint8_t>(show_rank), 0); |
| } |
| void add_categories(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>>> categories) { |
| fbb_.AddOffset(HomeSection::VT_CATEGORIES, categories); |
| } |
| void add_extra(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra) { |
| fbb_.AddOffset(HomeSection::VT_EXTRA, extra); |
| } |
| explicit HomeSectionBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<HomeSection> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<HomeSection>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<HomeSection> CreateHomeSection( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<::flatbuffers::String> id = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> title = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> subtitle = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>>> items = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> next_page = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> layout = 0, |
| bool show_rank = false, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>>> categories = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra = 0) { |
| HomeSectionBuilder builder_(_fbb); |
| builder_.add_extra(extra); |
| builder_.add_categories(categories); |
| builder_.add_layout(layout); |
| builder_.add_next_page(next_page); |
| builder_.add_items(items); |
| builder_.add_subtitle(subtitle); |
| builder_.add_title(title); |
| builder_.add_id(id); |
| builder_.add_show_rank(show_rank); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<HomeSection> CreateHomeSectionDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| const char *id = nullptr, |
| const char *title = nullptr, |
| const char *subtitle = nullptr, |
| const std::vector<::flatbuffers::Offset<bex::wire::MediaCard>> *items = nullptr, |
| const char *next_page = nullptr, |
| const char *layout = nullptr, |
| bool show_rank = false, |
| const std::vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *categories = nullptr, |
| const std::vector<::flatbuffers::Offset<bex::wire::Attr>> *extra = nullptr) { |
| auto id__ = id ? _fbb.CreateString(id) : 0; |
| auto title__ = title ? _fbb.CreateString(title) : 0; |
| auto subtitle__ = subtitle ? _fbb.CreateString(subtitle) : 0; |
| auto items__ = items ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::MediaCard>>(*items) : 0; |
| auto next_page__ = next_page ? _fbb.CreateString(next_page) : 0; |
| auto layout__ = layout ? _fbb.CreateString(layout) : 0; |
| auto categories__ = categories ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::CategoryLink>>(*categories) : 0; |
| auto extra__ = extra ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Attr>>(*extra) : 0; |
| return bex::wire::CreateHomeSection( |
| _fbb, |
| id__, |
| title__, |
| subtitle__, |
| items__, |
| next_page__, |
| layout__, |
| show_rank, |
| categories__, |
| extra__); |
| } |
|
|
| struct PagedResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef PagedResultBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_ITEMS = 4, |
| VT_CATEGORIES = 6, |
| VT_NEXT_PAGE = 8 |
| }; |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>> *items() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>> *>(VT_ITEMS); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>> *mutable_items() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>> *>(VT_ITEMS); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *categories() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *>(VT_CATEGORIES); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *mutable_categories() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *>(VT_CATEGORIES); |
| } |
| const ::flatbuffers::String *next_page() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_NEXT_PAGE); |
| } |
| ::flatbuffers::String *mutable_next_page() { |
| return GetPointer<::flatbuffers::String *>(VT_NEXT_PAGE); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_ITEMS) && |
| verifier.VerifyVector(items()) && |
| verifier.VerifyVectorOfTables(items()) && |
| VerifyOffset(verifier, VT_CATEGORIES) && |
| verifier.VerifyVector(categories()) && |
| verifier.VerifyVectorOfTables(categories()) && |
| VerifyOffset(verifier, VT_NEXT_PAGE) && |
| verifier.VerifyString(next_page()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct PagedResultBuilder { |
| typedef PagedResult Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_items(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>>> items) { |
| fbb_.AddOffset(PagedResult::VT_ITEMS, items); |
| } |
| void add_categories(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>>> categories) { |
| fbb_.AddOffset(PagedResult::VT_CATEGORIES, categories); |
| } |
| void add_next_page(::flatbuffers::Offset<::flatbuffers::String> next_page) { |
| fbb_.AddOffset(PagedResult::VT_NEXT_PAGE, next_page); |
| } |
| explicit PagedResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<PagedResult> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<PagedResult>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<PagedResult> CreatePagedResult( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::MediaCard>>> items = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::CategoryLink>>> categories = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> next_page = 0) { |
| PagedResultBuilder builder_(_fbb); |
| builder_.add_next_page(next_page); |
| builder_.add_categories(categories); |
| builder_.add_items(items); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<PagedResult> CreatePagedResultDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| const std::vector<::flatbuffers::Offset<bex::wire::MediaCard>> *items = nullptr, |
| const std::vector<::flatbuffers::Offset<bex::wire::CategoryLink>> *categories = nullptr, |
| const char *next_page = nullptr) { |
| auto items__ = items ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::MediaCard>>(*items) : 0; |
| auto categories__ = categories ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::CategoryLink>>(*categories) : 0; |
| auto next_page__ = next_page ? _fbb.CreateString(next_page) : 0; |
| return bex::wire::CreatePagedResult( |
| _fbb, |
| items__, |
| categories__, |
| next_page__); |
| } |
|
|
| struct Episode FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef EpisodeBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_ID = 4, |
| VT_TITLE = 6, |
| VT_NUMBER = 8, |
| VT_SEASON = 10, |
| VT_IMAGES = 12, |
| VT_DESCRIPTION = 14, |
| VT_RELEASED = 16, |
| VT_SCORE = 18, |
| VT_URL = 20, |
| VT_TAGS = 22, |
| VT_EXTRA = 24 |
| }; |
| const ::flatbuffers::String *id() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_ID); |
| } |
| ::flatbuffers::String *mutable_id() { |
| return GetPointer<::flatbuffers::String *>(VT_ID); |
| } |
| const ::flatbuffers::String *title() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_TITLE); |
| } |
| ::flatbuffers::String *mutable_title() { |
| return GetPointer<::flatbuffers::String *>(VT_TITLE); |
| } |
| double number() const { |
| return GetField<double>(VT_NUMBER, 0.0); |
| } |
| bool mutate_number(double _number = 0.0) { |
| return SetField<double>(VT_NUMBER, _number, 0.0); |
| } |
| double season() const { |
| return GetField<double>(VT_SEASON, 0.0); |
| } |
| bool mutate_season(double _season = 0.0) { |
| return SetField<double>(VT_SEASON, _season, 0.0); |
| } |
| const bex::wire::ImageSet *images() const { |
| return GetPointer<const bex::wire::ImageSet *>(VT_IMAGES); |
| } |
| bex::wire::ImageSet *mutable_images() { |
| return GetPointer<bex::wire::ImageSet *>(VT_IMAGES); |
| } |
| const ::flatbuffers::String *description() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_DESCRIPTION); |
| } |
| ::flatbuffers::String *mutable_description() { |
| return GetPointer<::flatbuffers::String *>(VT_DESCRIPTION); |
| } |
| const ::flatbuffers::String *released() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_RELEASED); |
| } |
| ::flatbuffers::String *mutable_released() { |
| return GetPointer<::flatbuffers::String *>(VT_RELEASED); |
| } |
| uint32_t score() const { |
| return GetField<uint32_t>(VT_SCORE, 0); |
| } |
| bool mutate_score(uint32_t _score = 0) { |
| return SetField<uint32_t>(VT_SCORE, _score, 0); |
| } |
| const ::flatbuffers::String *url() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_URL); |
| } |
| ::flatbuffers::String *mutable_url() { |
| return GetPointer<::flatbuffers::String *>(VT_URL); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *tags() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TAGS); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *mutable_tags() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TAGS); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *extra() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *mutable_extra() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_ID) && |
| verifier.VerifyString(id()) && |
| VerifyOffset(verifier, VT_TITLE) && |
| verifier.VerifyString(title()) && |
| VerifyField<double>(verifier, VT_NUMBER, 8) && |
| VerifyField<double>(verifier, VT_SEASON, 8) && |
| VerifyOffset(verifier, VT_IMAGES) && |
| verifier.VerifyTable(images()) && |
| VerifyOffset(verifier, VT_DESCRIPTION) && |
| verifier.VerifyString(description()) && |
| VerifyOffset(verifier, VT_RELEASED) && |
| verifier.VerifyString(released()) && |
| VerifyField<uint32_t>(verifier, VT_SCORE, 4) && |
| VerifyOffset(verifier, VT_URL) && |
| verifier.VerifyString(url()) && |
| VerifyOffset(verifier, VT_TAGS) && |
| verifier.VerifyVector(tags()) && |
| verifier.VerifyVectorOfStrings(tags()) && |
| VerifyOffset(verifier, VT_EXTRA) && |
| verifier.VerifyVector(extra()) && |
| verifier.VerifyVectorOfTables(extra()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct EpisodeBuilder { |
| typedef Episode Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_id(::flatbuffers::Offset<::flatbuffers::String> id) { |
| fbb_.AddOffset(Episode::VT_ID, id); |
| } |
| void add_title(::flatbuffers::Offset<::flatbuffers::String> title) { |
| fbb_.AddOffset(Episode::VT_TITLE, title); |
| } |
| void add_number(double number) { |
| fbb_.AddElement<double>(Episode::VT_NUMBER, number, 0.0); |
| } |
| void add_season(double season) { |
| fbb_.AddElement<double>(Episode::VT_SEASON, season, 0.0); |
| } |
| void add_images(::flatbuffers::Offset<bex::wire::ImageSet> images) { |
| fbb_.AddOffset(Episode::VT_IMAGES, images); |
| } |
| void add_description(::flatbuffers::Offset<::flatbuffers::String> description) { |
| fbb_.AddOffset(Episode::VT_DESCRIPTION, description); |
| } |
| void add_released(::flatbuffers::Offset<::flatbuffers::String> released) { |
| fbb_.AddOffset(Episode::VT_RELEASED, released); |
| } |
| void add_score(uint32_t score) { |
| fbb_.AddElement<uint32_t>(Episode::VT_SCORE, score, 0); |
| } |
| void add_url(::flatbuffers::Offset<::flatbuffers::String> url) { |
| fbb_.AddOffset(Episode::VT_URL, url); |
| } |
| void add_tags(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> tags) { |
| fbb_.AddOffset(Episode::VT_TAGS, tags); |
| } |
| void add_extra(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra) { |
| fbb_.AddOffset(Episode::VT_EXTRA, extra); |
| } |
| explicit EpisodeBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<Episode> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<Episode>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<Episode> CreateEpisode( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<::flatbuffers::String> id = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> title = 0, |
| double number = 0.0, |
| double season = 0.0, |
| ::flatbuffers::Offset<bex::wire::ImageSet> images = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> description = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> released = 0, |
| uint32_t score = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> url = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> tags = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra = 0) { |
| EpisodeBuilder builder_(_fbb); |
| builder_.add_season(season); |
| builder_.add_number(number); |
| builder_.add_extra(extra); |
| builder_.add_tags(tags); |
| builder_.add_url(url); |
| builder_.add_score(score); |
| builder_.add_released(released); |
| builder_.add_description(description); |
| builder_.add_images(images); |
| builder_.add_title(title); |
| builder_.add_id(id); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<Episode> CreateEpisodeDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| const char *id = nullptr, |
| const char *title = nullptr, |
| double number = 0.0, |
| double season = 0.0, |
| ::flatbuffers::Offset<bex::wire::ImageSet> images = 0, |
| const char *description = nullptr, |
| const char *released = nullptr, |
| uint32_t score = 0, |
| const char *url = nullptr, |
| const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *tags = nullptr, |
| const std::vector<::flatbuffers::Offset<bex::wire::Attr>> *extra = nullptr) { |
| auto id__ = id ? _fbb.CreateString(id) : 0; |
| auto title__ = title ? _fbb.CreateString(title) : 0; |
| auto description__ = description ? _fbb.CreateString(description) : 0; |
| auto released__ = released ? _fbb.CreateString(released) : 0; |
| auto url__ = url ? _fbb.CreateString(url) : 0; |
| auto tags__ = tags ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*tags) : 0; |
| auto extra__ = extra ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Attr>>(*extra) : 0; |
| return bex::wire::CreateEpisode( |
| _fbb, |
| id__, |
| title__, |
| number, |
| season, |
| images, |
| description__, |
| released__, |
| score, |
| url__, |
| tags__, |
| extra__); |
| } |
|
|
| struct Season FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef SeasonBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_ID = 4, |
| VT_TITLE = 6, |
| VT_NUMBER = 8, |
| VT_YEAR = 10, |
| VT_EPISODES = 12 |
| }; |
| const ::flatbuffers::String *id() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_ID); |
| } |
| ::flatbuffers::String *mutable_id() { |
| return GetPointer<::flatbuffers::String *>(VT_ID); |
| } |
| const ::flatbuffers::String *title() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_TITLE); |
| } |
| ::flatbuffers::String *mutable_title() { |
| return GetPointer<::flatbuffers::String *>(VT_TITLE); |
| } |
| double number() const { |
| return GetField<double>(VT_NUMBER, 0.0); |
| } |
| bool mutate_number(double _number = 0.0) { |
| return SetField<double>(VT_NUMBER, _number, 0.0); |
| } |
| uint32_t year() const { |
| return GetField<uint32_t>(VT_YEAR, 0); |
| } |
| bool mutate_year(uint32_t _year = 0) { |
| return SetField<uint32_t>(VT_YEAR, _year, 0); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Episode>> *episodes() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Episode>> *>(VT_EPISODES); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Episode>> *mutable_episodes() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Episode>> *>(VT_EPISODES); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_ID) && |
| verifier.VerifyString(id()) && |
| VerifyOffset(verifier, VT_TITLE) && |
| verifier.VerifyString(title()) && |
| VerifyField<double>(verifier, VT_NUMBER, 8) && |
| VerifyField<uint32_t>(verifier, VT_YEAR, 4) && |
| VerifyOffset(verifier, VT_EPISODES) && |
| verifier.VerifyVector(episodes()) && |
| verifier.VerifyVectorOfTables(episodes()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct SeasonBuilder { |
| typedef Season Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_id(::flatbuffers::Offset<::flatbuffers::String> id) { |
| fbb_.AddOffset(Season::VT_ID, id); |
| } |
| void add_title(::flatbuffers::Offset<::flatbuffers::String> title) { |
| fbb_.AddOffset(Season::VT_TITLE, title); |
| } |
| void add_number(double number) { |
| fbb_.AddElement<double>(Season::VT_NUMBER, number, 0.0); |
| } |
| void add_year(uint32_t year) { |
| fbb_.AddElement<uint32_t>(Season::VT_YEAR, year, 0); |
| } |
| void add_episodes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Episode>>> episodes) { |
| fbb_.AddOffset(Season::VT_EPISODES, episodes); |
| } |
| explicit SeasonBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<Season> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<Season>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<Season> CreateSeason( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<::flatbuffers::String> id = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> title = 0, |
| double number = 0.0, |
| uint32_t year = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Episode>>> episodes = 0) { |
| SeasonBuilder builder_(_fbb); |
| builder_.add_number(number); |
| builder_.add_episodes(episodes); |
| builder_.add_year(year); |
| builder_.add_title(title); |
| builder_.add_id(id); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<Season> CreateSeasonDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| const char *id = nullptr, |
| const char *title = nullptr, |
| double number = 0.0, |
| uint32_t year = 0, |
| const std::vector<::flatbuffers::Offset<bex::wire::Episode>> *episodes = nullptr) { |
| auto id__ = id ? _fbb.CreateString(id) : 0; |
| auto title__ = title ? _fbb.CreateString(title) : 0; |
| auto episodes__ = episodes ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Episode>>(*episodes) : 0; |
| return bex::wire::CreateSeason( |
| _fbb, |
| id__, |
| title__, |
| number, |
| year, |
| episodes__); |
| } |
|
|
| struct Person FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef PersonBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_ID = 4, |
| VT_NAME = 6, |
| VT_IMAGE = 8, |
| VT_ROLE = 10, |
| VT_URL = 12 |
| }; |
| const ::flatbuffers::String *id() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_ID); |
| } |
| ::flatbuffers::String *mutable_id() { |
| return GetPointer<::flatbuffers::String *>(VT_ID); |
| } |
| const ::flatbuffers::String *name() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_NAME); |
| } |
| ::flatbuffers::String *mutable_name() { |
| return GetPointer<::flatbuffers::String *>(VT_NAME); |
| } |
| const bex::wire::ImageSet *image() const { |
| return GetPointer<const bex::wire::ImageSet *>(VT_IMAGE); |
| } |
| bex::wire::ImageSet *mutable_image() { |
| return GetPointer<bex::wire::ImageSet *>(VT_IMAGE); |
| } |
| const ::flatbuffers::String *role() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_ROLE); |
| } |
| ::flatbuffers::String *mutable_role() { |
| return GetPointer<::flatbuffers::String *>(VT_ROLE); |
| } |
| const ::flatbuffers::String *url() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_URL); |
| } |
| ::flatbuffers::String *mutable_url() { |
| return GetPointer<::flatbuffers::String *>(VT_URL); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_ID) && |
| verifier.VerifyString(id()) && |
| VerifyOffset(verifier, VT_NAME) && |
| verifier.VerifyString(name()) && |
| VerifyOffset(verifier, VT_IMAGE) && |
| verifier.VerifyTable(image()) && |
| VerifyOffset(verifier, VT_ROLE) && |
| verifier.VerifyString(role()) && |
| VerifyOffset(verifier, VT_URL) && |
| verifier.VerifyString(url()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct PersonBuilder { |
| typedef Person Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_id(::flatbuffers::Offset<::flatbuffers::String> id) { |
| fbb_.AddOffset(Person::VT_ID, id); |
| } |
| void add_name(::flatbuffers::Offset<::flatbuffers::String> name) { |
| fbb_.AddOffset(Person::VT_NAME, name); |
| } |
| void add_image(::flatbuffers::Offset<bex::wire::ImageSet> image) { |
| fbb_.AddOffset(Person::VT_IMAGE, image); |
| } |
| void add_role(::flatbuffers::Offset<::flatbuffers::String> role) { |
| fbb_.AddOffset(Person::VT_ROLE, role); |
| } |
| void add_url(::flatbuffers::Offset<::flatbuffers::String> url) { |
| fbb_.AddOffset(Person::VT_URL, url); |
| } |
| explicit PersonBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<Person> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<Person>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<Person> CreatePerson( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<::flatbuffers::String> id = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> name = 0, |
| ::flatbuffers::Offset<bex::wire::ImageSet> image = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> role = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> url = 0) { |
| PersonBuilder builder_(_fbb); |
| builder_.add_url(url); |
| builder_.add_role(role); |
| builder_.add_image(image); |
| builder_.add_name(name); |
| builder_.add_id(id); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<Person> CreatePersonDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| const char *id = nullptr, |
| const char *name = nullptr, |
| ::flatbuffers::Offset<bex::wire::ImageSet> image = 0, |
| const char *role = nullptr, |
| const char *url = nullptr) { |
| auto id__ = id ? _fbb.CreateString(id) : 0; |
| auto name__ = name ? _fbb.CreateString(name) : 0; |
| auto role__ = role ? _fbb.CreateString(role) : 0; |
| auto url__ = url ? _fbb.CreateString(url) : 0; |
| return bex::wire::CreatePerson( |
| _fbb, |
| id__, |
| name__, |
| image, |
| role__, |
| url__); |
| } |
|
|
| struct MediaInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef MediaInfoBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_ID = 4, |
| VT_TITLE = 6, |
| VT_KIND = 8, |
| VT_IMAGES = 10, |
| VT_ORIGINAL_TITLE = 12, |
| VT_DESCRIPTION = 14, |
| VT_SCORE = 16, |
| VT_SCORED_BY = 18, |
| VT_YEAR = 20, |
| VT_RELEASE_DATE = 22, |
| VT_GENRES = 24, |
| VT_TAGS = 26, |
| VT_STATUS = 28, |
| VT_CONTENT_RATING = 30, |
| VT_SEASONS = 32, |
| VT_CAST = 34, |
| VT_CREW = 36, |
| VT_RUNTIME_MINUTES = 38, |
| VT_TRAILER_URL = 40, |
| VT_IDS = 42, |
| VT_STUDIO = 44, |
| VT_COUNTRY = 46, |
| VT_LANGUAGE = 48, |
| VT_URL = 50, |
| VT_EXTRA = 52 |
| }; |
| const ::flatbuffers::String *id() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_ID); |
| } |
| ::flatbuffers::String *mutable_id() { |
| return GetPointer<::flatbuffers::String *>(VT_ID); |
| } |
| const ::flatbuffers::String *title() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_TITLE); |
| } |
| ::flatbuffers::String *mutable_title() { |
| return GetPointer<::flatbuffers::String *>(VT_TITLE); |
| } |
| bex::wire::MediaKind kind() const { |
| return static_cast<bex::wire::MediaKind>(GetField<int8_t>(VT_KIND, 0)); |
| } |
| bool mutate_kind(bex::wire::MediaKind _kind = static_cast<bex::wire::MediaKind>(0)) { |
| return SetField<int8_t>(VT_KIND, static_cast<int8_t>(_kind), 0); |
| } |
| const bex::wire::ImageSet *images() const { |
| return GetPointer<const bex::wire::ImageSet *>(VT_IMAGES); |
| } |
| bex::wire::ImageSet *mutable_images() { |
| return GetPointer<bex::wire::ImageSet *>(VT_IMAGES); |
| } |
| const ::flatbuffers::String *original_title() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_ORIGINAL_TITLE); |
| } |
| ::flatbuffers::String *mutable_original_title() { |
| return GetPointer<::flatbuffers::String *>(VT_ORIGINAL_TITLE); |
| } |
| const ::flatbuffers::String *description() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_DESCRIPTION); |
| } |
| ::flatbuffers::String *mutable_description() { |
| return GetPointer<::flatbuffers::String *>(VT_DESCRIPTION); |
| } |
| uint32_t score() const { |
| return GetField<uint32_t>(VT_SCORE, 0); |
| } |
| bool mutate_score(uint32_t _score = 0) { |
| return SetField<uint32_t>(VT_SCORE, _score, 0); |
| } |
| uint64_t scored_by() const { |
| return GetField<uint64_t>(VT_SCORED_BY, 0); |
| } |
| bool mutate_scored_by(uint64_t _scored_by = 0) { |
| return SetField<uint64_t>(VT_SCORED_BY, _scored_by, 0); |
| } |
| const ::flatbuffers::String *year() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_YEAR); |
| } |
| ::flatbuffers::String *mutable_year() { |
| return GetPointer<::flatbuffers::String *>(VT_YEAR); |
| } |
| const ::flatbuffers::String *release_date() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_RELEASE_DATE); |
| } |
| ::flatbuffers::String *mutable_release_date() { |
| return GetPointer<::flatbuffers::String *>(VT_RELEASE_DATE); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *genres() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_GENRES); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *mutable_genres() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_GENRES); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *tags() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TAGS); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *mutable_tags() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TAGS); |
| } |
| bex::wire::Status status() const { |
| return static_cast<bex::wire::Status>(GetField<int8_t>(VT_STATUS, 0)); |
| } |
| bool mutate_status(bex::wire::Status _status = static_cast<bex::wire::Status>(0)) { |
| return SetField<int8_t>(VT_STATUS, static_cast<int8_t>(_status), 0); |
| } |
| const ::flatbuffers::String *content_rating() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_CONTENT_RATING); |
| } |
| ::flatbuffers::String *mutable_content_rating() { |
| return GetPointer<::flatbuffers::String *>(VT_CONTENT_RATING); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Season>> *seasons() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Season>> *>(VT_SEASONS); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Season>> *mutable_seasons() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Season>> *>(VT_SEASONS); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>> *cast() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>> *>(VT_CAST); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>> *mutable_cast() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>> *>(VT_CAST); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>> *crew() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>> *>(VT_CREW); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>> *mutable_crew() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>> *>(VT_CREW); |
| } |
| uint32_t runtime_minutes() const { |
| return GetField<uint32_t>(VT_RUNTIME_MINUTES, 0); |
| } |
| bool mutate_runtime_minutes(uint32_t _runtime_minutes = 0) { |
| return SetField<uint32_t>(VT_RUNTIME_MINUTES, _runtime_minutes, 0); |
| } |
| const ::flatbuffers::String *trailer_url() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_TRAILER_URL); |
| } |
| ::flatbuffers::String *mutable_trailer_url() { |
| return GetPointer<::flatbuffers::String *>(VT_TRAILER_URL); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>> *ids() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>> *>(VT_IDS); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>> *mutable_ids() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>> *>(VT_IDS); |
| } |
| const ::flatbuffers::String *studio() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_STUDIO); |
| } |
| ::flatbuffers::String *mutable_studio() { |
| return GetPointer<::flatbuffers::String *>(VT_STUDIO); |
| } |
| const ::flatbuffers::String *country() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_COUNTRY); |
| } |
| ::flatbuffers::String *mutable_country() { |
| return GetPointer<::flatbuffers::String *>(VT_COUNTRY); |
| } |
| const ::flatbuffers::String *language() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_LANGUAGE); |
| } |
| ::flatbuffers::String *mutable_language() { |
| return GetPointer<::flatbuffers::String *>(VT_LANGUAGE); |
| } |
| const ::flatbuffers::String *url() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_URL); |
| } |
| ::flatbuffers::String *mutable_url() { |
| return GetPointer<::flatbuffers::String *>(VT_URL); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *extra() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *mutable_extra() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_ID) && |
| verifier.VerifyString(id()) && |
| VerifyOffset(verifier, VT_TITLE) && |
| verifier.VerifyString(title()) && |
| VerifyField<int8_t>(verifier, VT_KIND, 1) && |
| VerifyOffset(verifier, VT_IMAGES) && |
| verifier.VerifyTable(images()) && |
| VerifyOffset(verifier, VT_ORIGINAL_TITLE) && |
| verifier.VerifyString(original_title()) && |
| VerifyOffset(verifier, VT_DESCRIPTION) && |
| verifier.VerifyString(description()) && |
| VerifyField<uint32_t>(verifier, VT_SCORE, 4) && |
| VerifyField<uint64_t>(verifier, VT_SCORED_BY, 8) && |
| VerifyOffset(verifier, VT_YEAR) && |
| verifier.VerifyString(year()) && |
| VerifyOffset(verifier, VT_RELEASE_DATE) && |
| verifier.VerifyString(release_date()) && |
| VerifyOffset(verifier, VT_GENRES) && |
| verifier.VerifyVector(genres()) && |
| verifier.VerifyVectorOfStrings(genres()) && |
| VerifyOffset(verifier, VT_TAGS) && |
| verifier.VerifyVector(tags()) && |
| verifier.VerifyVectorOfStrings(tags()) && |
| VerifyField<int8_t>(verifier, VT_STATUS, 1) && |
| VerifyOffset(verifier, VT_CONTENT_RATING) && |
| verifier.VerifyString(content_rating()) && |
| VerifyOffset(verifier, VT_SEASONS) && |
| verifier.VerifyVector(seasons()) && |
| verifier.VerifyVectorOfTables(seasons()) && |
| VerifyOffset(verifier, VT_CAST) && |
| verifier.VerifyVector(cast()) && |
| verifier.VerifyVectorOfTables(cast()) && |
| VerifyOffset(verifier, VT_CREW) && |
| verifier.VerifyVector(crew()) && |
| verifier.VerifyVectorOfTables(crew()) && |
| VerifyField<uint32_t>(verifier, VT_RUNTIME_MINUTES, 4) && |
| VerifyOffset(verifier, VT_TRAILER_URL) && |
| verifier.VerifyString(trailer_url()) && |
| VerifyOffset(verifier, VT_IDS) && |
| verifier.VerifyVector(ids()) && |
| verifier.VerifyVectorOfTables(ids()) && |
| VerifyOffset(verifier, VT_STUDIO) && |
| verifier.VerifyString(studio()) && |
| VerifyOffset(verifier, VT_COUNTRY) && |
| verifier.VerifyString(country()) && |
| VerifyOffset(verifier, VT_LANGUAGE) && |
| verifier.VerifyString(language()) && |
| VerifyOffset(verifier, VT_URL) && |
| verifier.VerifyString(url()) && |
| VerifyOffset(verifier, VT_EXTRA) && |
| verifier.VerifyVector(extra()) && |
| verifier.VerifyVectorOfTables(extra()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct MediaInfoBuilder { |
| typedef MediaInfo Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_id(::flatbuffers::Offset<::flatbuffers::String> id) { |
| fbb_.AddOffset(MediaInfo::VT_ID, id); |
| } |
| void add_title(::flatbuffers::Offset<::flatbuffers::String> title) { |
| fbb_.AddOffset(MediaInfo::VT_TITLE, title); |
| } |
| void add_kind(bex::wire::MediaKind kind) { |
| fbb_.AddElement<int8_t>(MediaInfo::VT_KIND, static_cast<int8_t>(kind), 0); |
| } |
| void add_images(::flatbuffers::Offset<bex::wire::ImageSet> images) { |
| fbb_.AddOffset(MediaInfo::VT_IMAGES, images); |
| } |
| void add_original_title(::flatbuffers::Offset<::flatbuffers::String> original_title) { |
| fbb_.AddOffset(MediaInfo::VT_ORIGINAL_TITLE, original_title); |
| } |
| void add_description(::flatbuffers::Offset<::flatbuffers::String> description) { |
| fbb_.AddOffset(MediaInfo::VT_DESCRIPTION, description); |
| } |
| void add_score(uint32_t score) { |
| fbb_.AddElement<uint32_t>(MediaInfo::VT_SCORE, score, 0); |
| } |
| void add_scored_by(uint64_t scored_by) { |
| fbb_.AddElement<uint64_t>(MediaInfo::VT_SCORED_BY, scored_by, 0); |
| } |
| void add_year(::flatbuffers::Offset<::flatbuffers::String> year) { |
| fbb_.AddOffset(MediaInfo::VT_YEAR, year); |
| } |
| void add_release_date(::flatbuffers::Offset<::flatbuffers::String> release_date) { |
| fbb_.AddOffset(MediaInfo::VT_RELEASE_DATE, release_date); |
| } |
| void add_genres(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> genres) { |
| fbb_.AddOffset(MediaInfo::VT_GENRES, genres); |
| } |
| void add_tags(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> tags) { |
| fbb_.AddOffset(MediaInfo::VT_TAGS, tags); |
| } |
| void add_status(bex::wire::Status status) { |
| fbb_.AddElement<int8_t>(MediaInfo::VT_STATUS, static_cast<int8_t>(status), 0); |
| } |
| void add_content_rating(::flatbuffers::Offset<::flatbuffers::String> content_rating) { |
| fbb_.AddOffset(MediaInfo::VT_CONTENT_RATING, content_rating); |
| } |
| void add_seasons(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Season>>> seasons) { |
| fbb_.AddOffset(MediaInfo::VT_SEASONS, seasons); |
| } |
| void add_cast(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>>> cast) { |
| fbb_.AddOffset(MediaInfo::VT_CAST, cast); |
| } |
| void add_crew(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>>> crew) { |
| fbb_.AddOffset(MediaInfo::VT_CREW, crew); |
| } |
| void add_runtime_minutes(uint32_t runtime_minutes) { |
| fbb_.AddElement<uint32_t>(MediaInfo::VT_RUNTIME_MINUTES, runtime_minutes, 0); |
| } |
| void add_trailer_url(::flatbuffers::Offset<::flatbuffers::String> trailer_url) { |
| fbb_.AddOffset(MediaInfo::VT_TRAILER_URL, trailer_url); |
| } |
| void add_ids(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>>> ids) { |
| fbb_.AddOffset(MediaInfo::VT_IDS, ids); |
| } |
| void add_studio(::flatbuffers::Offset<::flatbuffers::String> studio) { |
| fbb_.AddOffset(MediaInfo::VT_STUDIO, studio); |
| } |
| void add_country(::flatbuffers::Offset<::flatbuffers::String> country) { |
| fbb_.AddOffset(MediaInfo::VT_COUNTRY, country); |
| } |
| void add_language(::flatbuffers::Offset<::flatbuffers::String> language) { |
| fbb_.AddOffset(MediaInfo::VT_LANGUAGE, language); |
| } |
| void add_url(::flatbuffers::Offset<::flatbuffers::String> url) { |
| fbb_.AddOffset(MediaInfo::VT_URL, url); |
| } |
| void add_extra(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra) { |
| fbb_.AddOffset(MediaInfo::VT_EXTRA, extra); |
| } |
| explicit MediaInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<MediaInfo> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<MediaInfo>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<MediaInfo> CreateMediaInfo( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<::flatbuffers::String> id = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> title = 0, |
| bex::wire::MediaKind kind = bex::wire::MediaKind_Movie, |
| ::flatbuffers::Offset<bex::wire::ImageSet> images = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> original_title = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> description = 0, |
| uint32_t score = 0, |
| uint64_t scored_by = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> year = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> release_date = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> genres = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> tags = 0, |
| bex::wire::Status status = bex::wire::Status_Unknown, |
| ::flatbuffers::Offset<::flatbuffers::String> content_rating = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Season>>> seasons = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>>> cast = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Person>>> crew = 0, |
| uint32_t runtime_minutes = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> trailer_url = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::LinkedId>>> ids = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> studio = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> country = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> language = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> url = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra = 0) { |
| MediaInfoBuilder builder_(_fbb); |
| builder_.add_scored_by(scored_by); |
| builder_.add_extra(extra); |
| builder_.add_url(url); |
| builder_.add_language(language); |
| builder_.add_country(country); |
| builder_.add_studio(studio); |
| builder_.add_ids(ids); |
| builder_.add_trailer_url(trailer_url); |
| builder_.add_runtime_minutes(runtime_minutes); |
| builder_.add_crew(crew); |
| builder_.add_cast(cast); |
| builder_.add_seasons(seasons); |
| builder_.add_content_rating(content_rating); |
| builder_.add_tags(tags); |
| builder_.add_genres(genres); |
| builder_.add_release_date(release_date); |
| builder_.add_year(year); |
| builder_.add_score(score); |
| builder_.add_description(description); |
| builder_.add_original_title(original_title); |
| builder_.add_images(images); |
| builder_.add_title(title); |
| builder_.add_id(id); |
| builder_.add_status(status); |
| builder_.add_kind(kind); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<MediaInfo> CreateMediaInfoDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| const char *id = nullptr, |
| const char *title = nullptr, |
| bex::wire::MediaKind kind = bex::wire::MediaKind_Movie, |
| ::flatbuffers::Offset<bex::wire::ImageSet> images = 0, |
| const char *original_title = nullptr, |
| const char *description = nullptr, |
| uint32_t score = 0, |
| uint64_t scored_by = 0, |
| const char *year = nullptr, |
| const char *release_date = nullptr, |
| const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *genres = nullptr, |
| const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *tags = nullptr, |
| bex::wire::Status status = bex::wire::Status_Unknown, |
| const char *content_rating = nullptr, |
| const std::vector<::flatbuffers::Offset<bex::wire::Season>> *seasons = nullptr, |
| const std::vector<::flatbuffers::Offset<bex::wire::Person>> *cast = nullptr, |
| const std::vector<::flatbuffers::Offset<bex::wire::Person>> *crew = nullptr, |
| uint32_t runtime_minutes = 0, |
| const char *trailer_url = nullptr, |
| const std::vector<::flatbuffers::Offset<bex::wire::LinkedId>> *ids = nullptr, |
| const char *studio = nullptr, |
| const char *country = nullptr, |
| const char *language = nullptr, |
| const char *url = nullptr, |
| const std::vector<::flatbuffers::Offset<bex::wire::Attr>> *extra = nullptr) { |
| auto id__ = id ? _fbb.CreateString(id) : 0; |
| auto title__ = title ? _fbb.CreateString(title) : 0; |
| auto original_title__ = original_title ? _fbb.CreateString(original_title) : 0; |
| auto description__ = description ? _fbb.CreateString(description) : 0; |
| auto year__ = year ? _fbb.CreateString(year) : 0; |
| auto release_date__ = release_date ? _fbb.CreateString(release_date) : 0; |
| auto genres__ = genres ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*genres) : 0; |
| auto tags__ = tags ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*tags) : 0; |
| auto content_rating__ = content_rating ? _fbb.CreateString(content_rating) : 0; |
| auto seasons__ = seasons ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Season>>(*seasons) : 0; |
| auto cast__ = cast ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Person>>(*cast) : 0; |
| auto crew__ = crew ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Person>>(*crew) : 0; |
| auto trailer_url__ = trailer_url ? _fbb.CreateString(trailer_url) : 0; |
| auto ids__ = ids ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::LinkedId>>(*ids) : 0; |
| auto studio__ = studio ? _fbb.CreateString(studio) : 0; |
| auto country__ = country ? _fbb.CreateString(country) : 0; |
| auto language__ = language ? _fbb.CreateString(language) : 0; |
| auto url__ = url ? _fbb.CreateString(url) : 0; |
| auto extra__ = extra ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Attr>>(*extra) : 0; |
| return bex::wire::CreateMediaInfo( |
| _fbb, |
| id__, |
| title__, |
| kind, |
| images, |
| original_title__, |
| description__, |
| score, |
| scored_by, |
| year__, |
| release_date__, |
| genres__, |
| tags__, |
| status, |
| content_rating__, |
| seasons__, |
| cast__, |
| crew__, |
| runtime_minutes, |
| trailer_url__, |
| ids__, |
| studio__, |
| country__, |
| language__, |
| url__, |
| extra__); |
| } |
|
|
| struct VideoResolution FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef VideoResolutionBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_WIDTH = 4, |
| VT_HEIGHT = 6, |
| VT_HDR = 8, |
| VT_LABEL = 10 |
| }; |
| uint32_t width() const { |
| return GetField<uint32_t>(VT_WIDTH, 0); |
| } |
| bool mutate_width(uint32_t _width = 0) { |
| return SetField<uint32_t>(VT_WIDTH, _width, 0); |
| } |
| uint32_t height() const { |
| return GetField<uint32_t>(VT_HEIGHT, 0); |
| } |
| bool mutate_height(uint32_t _height = 0) { |
| return SetField<uint32_t>(VT_HEIGHT, _height, 0); |
| } |
| bool hdr() const { |
| return GetField<uint8_t>(VT_HDR, 0) != 0; |
| } |
| bool mutate_hdr(bool _hdr = 0) { |
| return SetField<uint8_t>(VT_HDR, static_cast<uint8_t>(_hdr), 0); |
| } |
| const ::flatbuffers::String *label() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_LABEL); |
| } |
| ::flatbuffers::String *mutable_label() { |
| return GetPointer<::flatbuffers::String *>(VT_LABEL); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyField<uint32_t>(verifier, VT_WIDTH, 4) && |
| VerifyField<uint32_t>(verifier, VT_HEIGHT, 4) && |
| VerifyField<uint8_t>(verifier, VT_HDR, 1) && |
| VerifyOffset(verifier, VT_LABEL) && |
| verifier.VerifyString(label()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct VideoResolutionBuilder { |
| typedef VideoResolution Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_width(uint32_t width) { |
| fbb_.AddElement<uint32_t>(VideoResolution::VT_WIDTH, width, 0); |
| } |
| void add_height(uint32_t height) { |
| fbb_.AddElement<uint32_t>(VideoResolution::VT_HEIGHT, height, 0); |
| } |
| void add_hdr(bool hdr) { |
| fbb_.AddElement<uint8_t>(VideoResolution::VT_HDR, static_cast<uint8_t>(hdr), 0); |
| } |
| void add_label(::flatbuffers::Offset<::flatbuffers::String> label) { |
| fbb_.AddOffset(VideoResolution::VT_LABEL, label); |
| } |
| explicit VideoResolutionBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<VideoResolution> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<VideoResolution>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<VideoResolution> CreateVideoResolution( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| uint32_t width = 0, |
| uint32_t height = 0, |
| bool hdr = false, |
| ::flatbuffers::Offset<::flatbuffers::String> label = 0) { |
| VideoResolutionBuilder builder_(_fbb); |
| builder_.add_label(label); |
| builder_.add_height(height); |
| builder_.add_width(width); |
| builder_.add_hdr(hdr); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<VideoResolution> CreateVideoResolutionDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| uint32_t width = 0, |
| uint32_t height = 0, |
| bool hdr = false, |
| const char *label = nullptr) { |
| auto label__ = label ? _fbb.CreateString(label) : 0; |
| return bex::wire::CreateVideoResolution( |
| _fbb, |
| width, |
| height, |
| hdr, |
| label__); |
| } |
|
|
| struct VideoTrack FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef VideoTrackBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_RESOLUTION = 4, |
| VT_URL = 6, |
| VT_MIME_TYPE = 8, |
| VT_BITRATE = 10, |
| VT_CODECS = 12 |
| }; |
| const bex::wire::VideoResolution *resolution() const { |
| return GetPointer<const bex::wire::VideoResolution *>(VT_RESOLUTION); |
| } |
| bex::wire::VideoResolution *mutable_resolution() { |
| return GetPointer<bex::wire::VideoResolution *>(VT_RESOLUTION); |
| } |
| const ::flatbuffers::String *url() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_URL); |
| } |
| ::flatbuffers::String *mutable_url() { |
| return GetPointer<::flatbuffers::String *>(VT_URL); |
| } |
| const ::flatbuffers::String *mime_type() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_MIME_TYPE); |
| } |
| ::flatbuffers::String *mutable_mime_type() { |
| return GetPointer<::flatbuffers::String *>(VT_MIME_TYPE); |
| } |
| uint64_t bitrate() const { |
| return GetField<uint64_t>(VT_BITRATE, 0); |
| } |
| bool mutate_bitrate(uint64_t _bitrate = 0) { |
| return SetField<uint64_t>(VT_BITRATE, _bitrate, 0); |
| } |
| const ::flatbuffers::String *codecs() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_CODECS); |
| } |
| ::flatbuffers::String *mutable_codecs() { |
| return GetPointer<::flatbuffers::String *>(VT_CODECS); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_RESOLUTION) && |
| verifier.VerifyTable(resolution()) && |
| VerifyOffset(verifier, VT_URL) && |
| verifier.VerifyString(url()) && |
| VerifyOffset(verifier, VT_MIME_TYPE) && |
| verifier.VerifyString(mime_type()) && |
| VerifyField<uint64_t>(verifier, VT_BITRATE, 8) && |
| VerifyOffset(verifier, VT_CODECS) && |
| verifier.VerifyString(codecs()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct VideoTrackBuilder { |
| typedef VideoTrack Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_resolution(::flatbuffers::Offset<bex::wire::VideoResolution> resolution) { |
| fbb_.AddOffset(VideoTrack::VT_RESOLUTION, resolution); |
| } |
| void add_url(::flatbuffers::Offset<::flatbuffers::String> url) { |
| fbb_.AddOffset(VideoTrack::VT_URL, url); |
| } |
| void add_mime_type(::flatbuffers::Offset<::flatbuffers::String> mime_type) { |
| fbb_.AddOffset(VideoTrack::VT_MIME_TYPE, mime_type); |
| } |
| void add_bitrate(uint64_t bitrate) { |
| fbb_.AddElement<uint64_t>(VideoTrack::VT_BITRATE, bitrate, 0); |
| } |
| void add_codecs(::flatbuffers::Offset<::flatbuffers::String> codecs) { |
| fbb_.AddOffset(VideoTrack::VT_CODECS, codecs); |
| } |
| explicit VideoTrackBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<VideoTrack> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<VideoTrack>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<VideoTrack> CreateVideoTrack( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<bex::wire::VideoResolution> resolution = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> url = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> mime_type = 0, |
| uint64_t bitrate = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> codecs = 0) { |
| VideoTrackBuilder builder_(_fbb); |
| builder_.add_bitrate(bitrate); |
| builder_.add_codecs(codecs); |
| builder_.add_mime_type(mime_type); |
| builder_.add_url(url); |
| builder_.add_resolution(resolution); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<VideoTrack> CreateVideoTrackDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<bex::wire::VideoResolution> resolution = 0, |
| const char *url = nullptr, |
| const char *mime_type = nullptr, |
| uint64_t bitrate = 0, |
| const char *codecs = nullptr) { |
| auto url__ = url ? _fbb.CreateString(url) : 0; |
| auto mime_type__ = mime_type ? _fbb.CreateString(mime_type) : 0; |
| auto codecs__ = codecs ? _fbb.CreateString(codecs) : 0; |
| return bex::wire::CreateVideoTrack( |
| _fbb, |
| resolution, |
| url__, |
| mime_type__, |
| bitrate, |
| codecs__); |
| } |
|
|
| struct SubtitleTrack FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef SubtitleTrackBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_LABEL = 4, |
| VT_URL = 6, |
| VT_LANGUAGE = 8, |
| VT_FORMAT = 10 |
| }; |
| const ::flatbuffers::String *label() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_LABEL); |
| } |
| ::flatbuffers::String *mutable_label() { |
| return GetPointer<::flatbuffers::String *>(VT_LABEL); |
| } |
| const ::flatbuffers::String *url() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_URL); |
| } |
| ::flatbuffers::String *mutable_url() { |
| return GetPointer<::flatbuffers::String *>(VT_URL); |
| } |
| const ::flatbuffers::String *language() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_LANGUAGE); |
| } |
| ::flatbuffers::String *mutable_language() { |
| return GetPointer<::flatbuffers::String *>(VT_LANGUAGE); |
| } |
| const ::flatbuffers::String *format() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_FORMAT); |
| } |
| ::flatbuffers::String *mutable_format() { |
| return GetPointer<::flatbuffers::String *>(VT_FORMAT); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_LABEL) && |
| verifier.VerifyString(label()) && |
| VerifyOffset(verifier, VT_URL) && |
| verifier.VerifyString(url()) && |
| VerifyOffset(verifier, VT_LANGUAGE) && |
| verifier.VerifyString(language()) && |
| VerifyOffset(verifier, VT_FORMAT) && |
| verifier.VerifyString(format()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct SubtitleTrackBuilder { |
| typedef SubtitleTrack Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_label(::flatbuffers::Offset<::flatbuffers::String> label) { |
| fbb_.AddOffset(SubtitleTrack::VT_LABEL, label); |
| } |
| void add_url(::flatbuffers::Offset<::flatbuffers::String> url) { |
| fbb_.AddOffset(SubtitleTrack::VT_URL, url); |
| } |
| void add_language(::flatbuffers::Offset<::flatbuffers::String> language) { |
| fbb_.AddOffset(SubtitleTrack::VT_LANGUAGE, language); |
| } |
| void add_format(::flatbuffers::Offset<::flatbuffers::String> format) { |
| fbb_.AddOffset(SubtitleTrack::VT_FORMAT, format); |
| } |
| explicit SubtitleTrackBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<SubtitleTrack> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<SubtitleTrack>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<SubtitleTrack> CreateSubtitleTrack( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<::flatbuffers::String> label = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> url = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> language = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> format = 0) { |
| SubtitleTrackBuilder builder_(_fbb); |
| builder_.add_format(format); |
| builder_.add_language(language); |
| builder_.add_url(url); |
| builder_.add_label(label); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<SubtitleTrack> CreateSubtitleTrackDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| const char *label = nullptr, |
| const char *url = nullptr, |
| const char *language = nullptr, |
| const char *format = nullptr) { |
| auto label__ = label ? _fbb.CreateString(label) : 0; |
| auto url__ = url ? _fbb.CreateString(url) : 0; |
| auto language__ = language ? _fbb.CreateString(language) : 0; |
| auto format__ = format ? _fbb.CreateString(format) : 0; |
| return bex::wire::CreateSubtitleTrack( |
| _fbb, |
| label__, |
| url__, |
| language__, |
| format__); |
| } |
|
|
| struct Server FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef ServerBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_ID = 4, |
| VT_LABEL = 6, |
| VT_URL = 8, |
| VT_PRIORITY = 10, |
| VT_EXTRA = 12 |
| }; |
| const ::flatbuffers::String *id() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_ID); |
| } |
| ::flatbuffers::String *mutable_id() { |
| return GetPointer<::flatbuffers::String *>(VT_ID); |
| } |
| const ::flatbuffers::String *label() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_LABEL); |
| } |
| ::flatbuffers::String *mutable_label() { |
| return GetPointer<::flatbuffers::String *>(VT_LABEL); |
| } |
| const ::flatbuffers::String *url() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_URL); |
| } |
| ::flatbuffers::String *mutable_url() { |
| return GetPointer<::flatbuffers::String *>(VT_URL); |
| } |
| uint8_t priority() const { |
| return GetField<uint8_t>(VT_PRIORITY, 0); |
| } |
| bool mutate_priority(uint8_t _priority = 0) { |
| return SetField<uint8_t>(VT_PRIORITY, _priority, 0); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *extra() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *mutable_extra() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_ID) && |
| verifier.VerifyString(id()) && |
| VerifyOffset(verifier, VT_LABEL) && |
| verifier.VerifyString(label()) && |
| VerifyOffset(verifier, VT_URL) && |
| verifier.VerifyString(url()) && |
| VerifyField<uint8_t>(verifier, VT_PRIORITY, 1) && |
| VerifyOffset(verifier, VT_EXTRA) && |
| verifier.VerifyVector(extra()) && |
| verifier.VerifyVectorOfTables(extra()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct ServerBuilder { |
| typedef Server Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_id(::flatbuffers::Offset<::flatbuffers::String> id) { |
| fbb_.AddOffset(Server::VT_ID, id); |
| } |
| void add_label(::flatbuffers::Offset<::flatbuffers::String> label) { |
| fbb_.AddOffset(Server::VT_LABEL, label); |
| } |
| void add_url(::flatbuffers::Offset<::flatbuffers::String> url) { |
| fbb_.AddOffset(Server::VT_URL, url); |
| } |
| void add_priority(uint8_t priority) { |
| fbb_.AddElement<uint8_t>(Server::VT_PRIORITY, priority, 0); |
| } |
| void add_extra(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra) { |
| fbb_.AddOffset(Server::VT_EXTRA, extra); |
| } |
| explicit ServerBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<Server> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<Server>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<Server> CreateServer( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<::flatbuffers::String> id = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> label = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> url = 0, |
| uint8_t priority = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra = 0) { |
| ServerBuilder builder_(_fbb); |
| builder_.add_extra(extra); |
| builder_.add_url(url); |
| builder_.add_label(label); |
| builder_.add_id(id); |
| builder_.add_priority(priority); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<Server> CreateServerDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| const char *id = nullptr, |
| const char *label = nullptr, |
| const char *url = nullptr, |
| uint8_t priority = 0, |
| const std::vector<::flatbuffers::Offset<bex::wire::Attr>> *extra = nullptr) { |
| auto id__ = id ? _fbb.CreateString(id) : 0; |
| auto label__ = label ? _fbb.CreateString(label) : 0; |
| auto url__ = url ? _fbb.CreateString(url) : 0; |
| auto extra__ = extra ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Attr>>(*extra) : 0; |
| return bex::wire::CreateServer( |
| _fbb, |
| id__, |
| label__, |
| url__, |
| priority, |
| extra__); |
| } |
|
|
| struct StreamSource FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef StreamSourceBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_ID = 4, |
| VT_LABEL = 6, |
| VT_FORMAT = 8, |
| VT_MANIFEST_URL = 10, |
| VT_VIDEOS = 12, |
| VT_SUBTITLES = 14, |
| VT_HEADERS = 16, |
| VT_EXTRA = 18 |
| }; |
| const ::flatbuffers::String *id() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_ID); |
| } |
| ::flatbuffers::String *mutable_id() { |
| return GetPointer<::flatbuffers::String *>(VT_ID); |
| } |
| const ::flatbuffers::String *label() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_LABEL); |
| } |
| ::flatbuffers::String *mutable_label() { |
| return GetPointer<::flatbuffers::String *>(VT_LABEL); |
| } |
| bex::wire::StreamFormat format() const { |
| return static_cast<bex::wire::StreamFormat>(GetField<int8_t>(VT_FORMAT, 0)); |
| } |
| bool mutate_format(bex::wire::StreamFormat _format = static_cast<bex::wire::StreamFormat>(0)) { |
| return SetField<int8_t>(VT_FORMAT, static_cast<int8_t>(_format), 0); |
| } |
| const ::flatbuffers::String *manifest_url() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_MANIFEST_URL); |
| } |
| ::flatbuffers::String *mutable_manifest_url() { |
| return GetPointer<::flatbuffers::String *>(VT_MANIFEST_URL); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::VideoTrack>> *videos() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::VideoTrack>> *>(VT_VIDEOS); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::VideoTrack>> *mutable_videos() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::VideoTrack>> *>(VT_VIDEOS); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::SubtitleTrack>> *subtitles() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::SubtitleTrack>> *>(VT_SUBTITLES); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::SubtitleTrack>> *mutable_subtitles() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::SubtitleTrack>> *>(VT_SUBTITLES); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *headers() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_HEADERS); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *mutable_headers() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_HEADERS); |
| } |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *extra() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *mutable_extra() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *>(VT_EXTRA); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_ID) && |
| verifier.VerifyString(id()) && |
| VerifyOffset(verifier, VT_LABEL) && |
| verifier.VerifyString(label()) && |
| VerifyField<int8_t>(verifier, VT_FORMAT, 1) && |
| VerifyOffset(verifier, VT_MANIFEST_URL) && |
| verifier.VerifyString(manifest_url()) && |
| VerifyOffset(verifier, VT_VIDEOS) && |
| verifier.VerifyVector(videos()) && |
| verifier.VerifyVectorOfTables(videos()) && |
| VerifyOffset(verifier, VT_SUBTITLES) && |
| verifier.VerifyVector(subtitles()) && |
| verifier.VerifyVectorOfTables(subtitles()) && |
| VerifyOffset(verifier, VT_HEADERS) && |
| verifier.VerifyVector(headers()) && |
| verifier.VerifyVectorOfTables(headers()) && |
| VerifyOffset(verifier, VT_EXTRA) && |
| verifier.VerifyVector(extra()) && |
| verifier.VerifyVectorOfTables(extra()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct StreamSourceBuilder { |
| typedef StreamSource Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_id(::flatbuffers::Offset<::flatbuffers::String> id) { |
| fbb_.AddOffset(StreamSource::VT_ID, id); |
| } |
| void add_label(::flatbuffers::Offset<::flatbuffers::String> label) { |
| fbb_.AddOffset(StreamSource::VT_LABEL, label); |
| } |
| void add_format(bex::wire::StreamFormat format) { |
| fbb_.AddElement<int8_t>(StreamSource::VT_FORMAT, static_cast<int8_t>(format), 0); |
| } |
| void add_manifest_url(::flatbuffers::Offset<::flatbuffers::String> manifest_url) { |
| fbb_.AddOffset(StreamSource::VT_MANIFEST_URL, manifest_url); |
| } |
| void add_videos(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::VideoTrack>>> videos) { |
| fbb_.AddOffset(StreamSource::VT_VIDEOS, videos); |
| } |
| void add_subtitles(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::SubtitleTrack>>> subtitles) { |
| fbb_.AddOffset(StreamSource::VT_SUBTITLES, subtitles); |
| } |
| void add_headers(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> headers) { |
| fbb_.AddOffset(StreamSource::VT_HEADERS, headers); |
| } |
| void add_extra(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra) { |
| fbb_.AddOffset(StreamSource::VT_EXTRA, extra); |
| } |
| explicit StreamSourceBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<StreamSource> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<StreamSource>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<StreamSource> CreateStreamSource( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<::flatbuffers::String> id = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> label = 0, |
| bex::wire::StreamFormat format = bex::wire::StreamFormat_Hls, |
| ::flatbuffers::Offset<::flatbuffers::String> manifest_url = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::VideoTrack>>> videos = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::SubtitleTrack>>> subtitles = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> headers = 0, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>>> extra = 0) { |
| StreamSourceBuilder builder_(_fbb); |
| builder_.add_extra(extra); |
| builder_.add_headers(headers); |
| builder_.add_subtitles(subtitles); |
| builder_.add_videos(videos); |
| builder_.add_manifest_url(manifest_url); |
| builder_.add_label(label); |
| builder_.add_id(id); |
| builder_.add_format(format); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<StreamSource> CreateStreamSourceDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| const char *id = nullptr, |
| const char *label = nullptr, |
| bex::wire::StreamFormat format = bex::wire::StreamFormat_Hls, |
| const char *manifest_url = nullptr, |
| const std::vector<::flatbuffers::Offset<bex::wire::VideoTrack>> *videos = nullptr, |
| const std::vector<::flatbuffers::Offset<bex::wire::SubtitleTrack>> *subtitles = nullptr, |
| const std::vector<::flatbuffers::Offset<bex::wire::Attr>> *headers = nullptr, |
| const std::vector<::flatbuffers::Offset<bex::wire::Attr>> *extra = nullptr) { |
| auto id__ = id ? _fbb.CreateString(id) : 0; |
| auto label__ = label ? _fbb.CreateString(label) : 0; |
| auto manifest_url__ = manifest_url ? _fbb.CreateString(manifest_url) : 0; |
| auto videos__ = videos ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::VideoTrack>>(*videos) : 0; |
| auto subtitles__ = subtitles ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::SubtitleTrack>>(*subtitles) : 0; |
| auto headers__ = headers ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Attr>>(*headers) : 0; |
| auto extra__ = extra ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Attr>>(*extra) : 0; |
| return bex::wire::CreateStreamSource( |
| _fbb, |
| id__, |
| label__, |
| format, |
| manifest_url__, |
| videos__, |
| subtitles__, |
| headers__, |
| extra__); |
| } |
|
|
| struct HomeResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef HomeResultBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_SECTIONS = 4 |
| }; |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::HomeSection>> *sections() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::HomeSection>> *>(VT_SECTIONS); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::HomeSection>> *mutable_sections() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::HomeSection>> *>(VT_SECTIONS); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_SECTIONS) && |
| verifier.VerifyVector(sections()) && |
| verifier.VerifyVectorOfTables(sections()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct HomeResultBuilder { |
| typedef HomeResult Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_sections(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::HomeSection>>> sections) { |
| fbb_.AddOffset(HomeResult::VT_SECTIONS, sections); |
| } |
| explicit HomeResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<HomeResult> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<HomeResult>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<HomeResult> CreateHomeResult( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::HomeSection>>> sections = 0) { |
| HomeResultBuilder builder_(_fbb); |
| builder_.add_sections(sections); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<HomeResult> CreateHomeResultDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| const std::vector<::flatbuffers::Offset<bex::wire::HomeSection>> *sections = nullptr) { |
| auto sections__ = sections ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::HomeSection>>(*sections) : 0; |
| return bex::wire::CreateHomeResult( |
| _fbb, |
| sections__); |
| } |
|
|
| struct CategoryResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef CategoryResultBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_RESULT = 4 |
| }; |
| const bex::wire::PagedResult *result() const { |
| return GetPointer<const bex::wire::PagedResult *>(VT_RESULT); |
| } |
| bex::wire::PagedResult *mutable_result() { |
| return GetPointer<bex::wire::PagedResult *>(VT_RESULT); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_RESULT) && |
| verifier.VerifyTable(result()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct CategoryResultBuilder { |
| typedef CategoryResult Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_result(::flatbuffers::Offset<bex::wire::PagedResult> result) { |
| fbb_.AddOffset(CategoryResult::VT_RESULT, result); |
| } |
| explicit CategoryResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<CategoryResult> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<CategoryResult>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<CategoryResult> CreateCategoryResult( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<bex::wire::PagedResult> result = 0) { |
| CategoryResultBuilder builder_(_fbb); |
| builder_.add_result(result); |
| return builder_.Finish(); |
| } |
|
|
| struct SearchResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef SearchResultBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_RESULT = 4 |
| }; |
| const bex::wire::PagedResult *result() const { |
| return GetPointer<const bex::wire::PagedResult *>(VT_RESULT); |
| } |
| bex::wire::PagedResult *mutable_result() { |
| return GetPointer<bex::wire::PagedResult *>(VT_RESULT); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_RESULT) && |
| verifier.VerifyTable(result()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct SearchResultBuilder { |
| typedef SearchResult Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_result(::flatbuffers::Offset<bex::wire::PagedResult> result) { |
| fbb_.AddOffset(SearchResult::VT_RESULT, result); |
| } |
| explicit SearchResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<SearchResult> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<SearchResult>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<SearchResult> CreateSearchResult( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<bex::wire::PagedResult> result = 0) { |
| SearchResultBuilder builder_(_fbb); |
| builder_.add_result(result); |
| return builder_.Finish(); |
| } |
|
|
| struct InfoResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef InfoResultBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_INFO = 4 |
| }; |
| const bex::wire::MediaInfo *info() const { |
| return GetPointer<const bex::wire::MediaInfo *>(VT_INFO); |
| } |
| bex::wire::MediaInfo *mutable_info() { |
| return GetPointer<bex::wire::MediaInfo *>(VT_INFO); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_INFO) && |
| verifier.VerifyTable(info()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct InfoResultBuilder { |
| typedef InfoResult Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_info(::flatbuffers::Offset<bex::wire::MediaInfo> info) { |
| fbb_.AddOffset(InfoResult::VT_INFO, info); |
| } |
| explicit InfoResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<InfoResult> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<InfoResult>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<InfoResult> CreateInfoResult( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<bex::wire::MediaInfo> info = 0) { |
| InfoResultBuilder builder_(_fbb); |
| builder_.add_info(info); |
| return builder_.Finish(); |
| } |
|
|
| struct ServersResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef ServersResultBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_SERVERS = 4 |
| }; |
| const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Server>> *servers() const { |
| return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Server>> *>(VT_SERVERS); |
| } |
| ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Server>> *mutable_servers() { |
| return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Server>> *>(VT_SERVERS); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_SERVERS) && |
| verifier.VerifyVector(servers()) && |
| verifier.VerifyVectorOfTables(servers()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct ServersResultBuilder { |
| typedef ServersResult Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_servers(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Server>>> servers) { |
| fbb_.AddOffset(ServersResult::VT_SERVERS, servers); |
| } |
| explicit ServersResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<ServersResult> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<ServersResult>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<ServersResult> CreateServersResult( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Server>>> servers = 0) { |
| ServersResultBuilder builder_(_fbb); |
| builder_.add_servers(servers); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<ServersResult> CreateServersResultDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| const std::vector<::flatbuffers::Offset<bex::wire::Server>> *servers = nullptr) { |
| auto servers__ = servers ? _fbb.CreateVector<::flatbuffers::Offset<bex::wire::Server>>(*servers) : 0; |
| return bex::wire::CreateServersResult( |
| _fbb, |
| servers__); |
| } |
|
|
| struct StreamResult FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef StreamResultBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_SOURCE = 4 |
| }; |
| const bex::wire::StreamSource *source() const { |
| return GetPointer<const bex::wire::StreamSource *>(VT_SOURCE); |
| } |
| bex::wire::StreamSource *mutable_source() { |
| return GetPointer<bex::wire::StreamSource *>(VT_SOURCE); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_SOURCE) && |
| verifier.VerifyTable(source()) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct StreamResultBuilder { |
| typedef StreamResult Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_source(::flatbuffers::Offset<bex::wire::StreamSource> source) { |
| fbb_.AddOffset(StreamResult::VT_SOURCE, source); |
| } |
| explicit StreamResultBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<StreamResult> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<StreamResult>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<StreamResult> CreateStreamResult( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<bex::wire::StreamSource> source = 0) { |
| StreamResultBuilder builder_(_fbb); |
| builder_.add_source(source); |
| return builder_.Finish(); |
| } |
|
|
| struct ErrorInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { |
| typedef ErrorInfoBuilder Builder; |
| enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { |
| VT_CODE = 4, |
| VT_MESSAGE = 6, |
| VT_PLUGIN_ID = 8, |
| VT_REQUEST_ID = 10 |
| }; |
| const ::flatbuffers::String *code() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_CODE); |
| } |
| ::flatbuffers::String *mutable_code() { |
| return GetPointer<::flatbuffers::String *>(VT_CODE); |
| } |
| const ::flatbuffers::String *message() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_MESSAGE); |
| } |
| ::flatbuffers::String *mutable_message() { |
| return GetPointer<::flatbuffers::String *>(VT_MESSAGE); |
| } |
| const ::flatbuffers::String *plugin_id() const { |
| return GetPointer<const ::flatbuffers::String *>(VT_PLUGIN_ID); |
| } |
| ::flatbuffers::String *mutable_plugin_id() { |
| return GetPointer<::flatbuffers::String *>(VT_PLUGIN_ID); |
| } |
| uint64_t request_id() const { |
| return GetField<uint64_t>(VT_REQUEST_ID, 0); |
| } |
| bool mutate_request_id(uint64_t _request_id = 0) { |
| return SetField<uint64_t>(VT_REQUEST_ID, _request_id, 0); |
| } |
| template <bool B = false> |
| bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const { |
| return VerifyTableStart(verifier) && |
| VerifyOffset(verifier, VT_CODE) && |
| verifier.VerifyString(code()) && |
| VerifyOffset(verifier, VT_MESSAGE) && |
| verifier.VerifyString(message()) && |
| VerifyOffset(verifier, VT_PLUGIN_ID) && |
| verifier.VerifyString(plugin_id()) && |
| VerifyField<uint64_t>(verifier, VT_REQUEST_ID, 8) && |
| verifier.EndTable(); |
| } |
| }; |
|
|
| struct ErrorInfoBuilder { |
| typedef ErrorInfo Table; |
| ::flatbuffers::FlatBufferBuilder &fbb_; |
| ::flatbuffers::uoffset_t start_; |
| void add_code(::flatbuffers::Offset<::flatbuffers::String> code) { |
| fbb_.AddOffset(ErrorInfo::VT_CODE, code); |
| } |
| void add_message(::flatbuffers::Offset<::flatbuffers::String> message) { |
| fbb_.AddOffset(ErrorInfo::VT_MESSAGE, message); |
| } |
| void add_plugin_id(::flatbuffers::Offset<::flatbuffers::String> plugin_id) { |
| fbb_.AddOffset(ErrorInfo::VT_PLUGIN_ID, plugin_id); |
| } |
| void add_request_id(uint64_t request_id) { |
| fbb_.AddElement<uint64_t>(ErrorInfo::VT_REQUEST_ID, request_id, 0); |
| } |
| explicit ErrorInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb) |
| : fbb_(_fbb) { |
| start_ = fbb_.StartTable(); |
| } |
| ::flatbuffers::Offset<ErrorInfo> Finish() { |
| const auto end = fbb_.EndTable(start_); |
| auto o = ::flatbuffers::Offset<ErrorInfo>(end); |
| return o; |
| } |
| }; |
|
|
| inline ::flatbuffers::Offset<ErrorInfo> CreateErrorInfo( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| ::flatbuffers::Offset<::flatbuffers::String> code = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> message = 0, |
| ::flatbuffers::Offset<::flatbuffers::String> plugin_id = 0, |
| uint64_t request_id = 0) { |
| ErrorInfoBuilder builder_(_fbb); |
| builder_.add_request_id(request_id); |
| builder_.add_plugin_id(plugin_id); |
| builder_.add_message(message); |
| builder_.add_code(code); |
| return builder_.Finish(); |
| } |
|
|
| inline ::flatbuffers::Offset<ErrorInfo> CreateErrorInfoDirect( |
| ::flatbuffers::FlatBufferBuilder &_fbb, |
| const char *code = nullptr, |
| const char *message = nullptr, |
| const char *plugin_id = nullptr, |
| uint64_t request_id = 0) { |
| auto code__ = code ? _fbb.CreateString(code) : 0; |
| auto message__ = message ? _fbb.CreateString(message) : 0; |
| auto plugin_id__ = plugin_id ? _fbb.CreateString(plugin_id) : 0; |
| return bex::wire::CreateErrorInfo( |
| _fbb, |
| code__, |
| message__, |
| plugin_id__, |
| request_id); |
| } |
|
|
| inline const bex::wire::HomeResult *GetHomeResult(const void *buf) { |
| return ::flatbuffers::GetRoot<bex::wire::HomeResult>(buf); |
| } |
|
|
| inline const bex::wire::HomeResult *GetSizePrefixedHomeResult(const void *buf) { |
| return ::flatbuffers::GetSizePrefixedRoot<bex::wire::HomeResult>(buf); |
| } |
|
|
| inline HomeResult *GetMutableHomeResult(void *buf) { |
| return ::flatbuffers::GetMutableRoot<HomeResult>(buf); |
| } |
|
|
| inline bex::wire::HomeResult *GetMutableSizePrefixedHomeResult(void *buf) { |
| return ::flatbuffers::GetMutableSizePrefixedRoot<bex::wire::HomeResult>(buf); |
| } |
|
|
| template <bool B = false> |
| inline bool VerifyHomeResultBuffer( |
| ::flatbuffers::VerifierTemplate<B> &verifier) { |
| return verifier.template VerifyBuffer<bex::wire::HomeResult>(nullptr); |
| } |
|
|
| template <bool B = false> |
| inline bool VerifySizePrefixedHomeResultBuffer( |
| ::flatbuffers::VerifierTemplate<B> &verifier) { |
| return verifier.template VerifySizePrefixedBuffer<bex::wire::HomeResult>(nullptr); |
| } |
|
|
| inline void FinishHomeResultBuffer( |
| ::flatbuffers::FlatBufferBuilder &fbb, |
| ::flatbuffers::Offset<bex::wire::HomeResult> root) { |
| fbb.Finish(root); |
| } |
|
|
| inline void FinishSizePrefixedHomeResultBuffer( |
| ::flatbuffers::FlatBufferBuilder &fbb, |
| ::flatbuffers::Offset<bex::wire::HomeResult> root) { |
| fbb.FinishSizePrefixed(root); |
| } |
|
|
| } |
| } |
|
|
| #endif |
|
|
