cpp-cli/wire_gen/bex_stream_generated.h

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


#ifndef FLATBUFFERS_GENERATED_BEXSTREAM_BEX_WIRE_H_
#define FLATBUFFERS_GENERATED_BEXSTREAM_BEX_WIRE_H_

#include "flatbuffers/flatbuffers.h"

// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
              FLATBUFFERS_VERSION_MINOR == 12 &&
              FLATBUFFERS_VERSION_REVISION == 19,
             "Non-compatible flatbuffers version included");

#include "bex_common_generated.h"

namespace bex {
namespace wire {

struct VideoResolution;
struct VideoResolutionBuilder;

struct VideoTrack;
struct VideoTrackBuilder;

struct SubtitleTrack;
struct SubtitleTrackBuilder;

struct Server;
struct ServerBuilder;

struct StreamSource;
struct StreamSourceBuilder;

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);
  }
  uint32_t height() const {
    return GetField<uint32_t>(VT_HEIGHT, 0);
  }
  bool hdr() const {
    return GetField<uint8_t>(VT_HDR, 0) != 0;
  }
  const ::flatbuffers::String *label() const {
    return GetPointer<const ::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);
  }
  const ::flatbuffers::String *url() const {
    return GetPointer<const ::flatbuffers::String *>(VT_URL);
  }
  const ::flatbuffers::String *mime_type() const {
    return GetPointer<const ::flatbuffers::String *>(VT_MIME_TYPE);
  }
  uint64_t bitrate() const {
    return GetField<uint64_t>(VT_BITRATE, 0);
  }
  const ::flatbuffers::String *codecs() const {
    return GetPointer<const ::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);
  }
  const ::flatbuffers::String *url() const {
    return GetPointer<const ::flatbuffers::String *>(VT_URL);
  }
  const ::flatbuffers::String *language() const {
    return GetPointer<const ::flatbuffers::String *>(VT_LANGUAGE);
  }
  const ::flatbuffers::String *format() const {
    return GetPointer<const ::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);
  }
  const ::flatbuffers::String *label() const {
    return GetPointer<const ::flatbuffers::String *>(VT_LABEL);
  }
  const ::flatbuffers::String *url() const {
    return GetPointer<const ::flatbuffers::String *>(VT_URL);
  }
  uint8_t priority() const {
    return GetField<uint8_t>(VT_PRIORITY, 0);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *extra() const {
    return GetPointer<const ::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);
  }
  const ::flatbuffers::String *label() const {
    return GetPointer<const ::flatbuffers::String *>(VT_LABEL);
  }
  bex::wire::StreamFormat format() const {
    return static_cast<bex::wire::StreamFormat>(GetField<int8_t>(VT_FORMAT, 0));
  }
  const ::flatbuffers::String *manifest_url() const {
    return GetPointer<const ::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);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::SubtitleTrack>> *subtitles() const {
    return GetPointer<const ::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);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<bex::wire::Attr>> *extra() const {
    return GetPointer<const ::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__);
}

inline const bex::wire::StreamSource *GetStreamSource(const void *buf) {
  return ::flatbuffers::GetRoot<bex::wire::StreamSource>(buf);
}

inline const bex::wire::StreamSource *GetSizePrefixedStreamSource(const void *buf) {
  return ::flatbuffers::GetSizePrefixedRoot<bex::wire::StreamSource>(buf);
}

template <bool B = false>
inline bool VerifyStreamSourceBuffer(
    ::flatbuffers::VerifierTemplate<B> &verifier) {
  return verifier.template VerifyBuffer<bex::wire::StreamSource>(nullptr);
}

template <bool B = false>
inline bool VerifySizePrefixedStreamSourceBuffer(
    ::flatbuffers::VerifierTemplate<B> &verifier) {
  return verifier.template VerifySizePrefixedBuffer<bex::wire::StreamSource>(nullptr);
}

inline void FinishStreamSourceBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<bex::wire::StreamSource> root) {
  fbb.Finish(root);
}

inline void FinishSizePrefixedStreamSourceBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<bex::wire::StreamSource> root) {
  fbb.FinishSizePrefixed(root);
}

}  // namespace wire
}  // namespace bex

#endif  // FLATBUFFERS_GENERATED_BEXSTREAM_BEX_WIRE_H_