#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_results)]
#![allow(unused_mut)]
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_4_0;
#[doc = "Get the initial URL to begin streaming a video"]
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVideo_ClientGetVideoURL_Request {
pub video_id: ::std::option::Option<u64>,
pub client_cellid: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CVideo_ClientGetVideoURL_Request {
fn default() -> &'a CVideo_ClientGetVideoURL_Request {
<CVideo_ClientGetVideoURL_Request as ::protobuf::Message>::default_instance()
}
}
impl CVideo_ClientGetVideoURL_Request {
pub fn new() -> CVideo_ClientGetVideoURL_Request {
::std::default::Default::default()
}
pub fn video_id(&self) -> u64 {
self.video_id.unwrap_or(0)
}
pub fn clear_video_id(&mut self) {
self.video_id = ::std::option::Option::None;
}
pub fn has_video_id(&self) -> bool {
self.video_id.is_some()
}
pub fn set_video_id(&mut self, v: u64) {
self.video_id = ::std::option::Option::Some(v);
}
pub fn client_cellid(&self) -> u32 {
self.client_cellid.unwrap_or(0)
}
pub fn clear_client_cellid(&mut self) {
self.client_cellid = ::std::option::Option::None;
}
pub fn has_client_cellid(&self) -> bool {
self.client_cellid.is_some()
}
pub fn set_client_cellid(&mut self, v: u32) {
self.client_cellid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CVideo_ClientGetVideoURL_Request {
const NAME: &'static str = "CVideo_ClientGetVideoURL_Request";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.video_id = ::std::option::Option::Some(is.read_uint64()?);
},
16 => {
self.client_cellid = ::std::option::Option::Some(is.read_uint32()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.video_id {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.client_cellid {
my_size += ::protobuf::rt::uint32_size(2, v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.video_id {
os.write_uint64(1, v)?;
}
if let Some(v) = self.client_cellid {
os.write_uint32(2, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CVideo_ClientGetVideoURL_Request {
CVideo_ClientGetVideoURL_Request::new()
}
fn clear(&mut self) {
self.video_id = ::std::option::Option::None;
self.client_cellid = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CVideo_ClientGetVideoURL_Request {
static instance: CVideo_ClientGetVideoURL_Request = CVideo_ClientGetVideoURL_Request {
video_id: ::std::option::Option::None,
client_cellid: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVideo_ClientGetVideoURL_Response {
pub video_id: ::std::option::Option<u64>,
pub video_url: ::std::option::Option<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CVideo_ClientGetVideoURL_Response {
fn default() -> &'a CVideo_ClientGetVideoURL_Response {
<CVideo_ClientGetVideoURL_Response as ::protobuf::Message>::default_instance()
}
}
impl CVideo_ClientGetVideoURL_Response {
pub fn new() -> CVideo_ClientGetVideoURL_Response {
::std::default::Default::default()
}
pub fn video_id(&self) -> u64 {
self.video_id.unwrap_or(0)
}
pub fn clear_video_id(&mut self) {
self.video_id = ::std::option::Option::None;
}
pub fn has_video_id(&self) -> bool {
self.video_id.is_some()
}
pub fn set_video_id(&mut self, v: u64) {
self.video_id = ::std::option::Option::Some(v);
}
pub fn video_url(&self) -> &str {
match self.video_url.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_video_url(&mut self) {
self.video_url = ::std::option::Option::None;
}
pub fn has_video_url(&self) -> bool {
self.video_url.is_some()
}
pub fn set_video_url(&mut self, v: ::std::string::String) {
self.video_url = ::std::option::Option::Some(v);
}
pub fn mut_video_url(&mut self) -> &mut ::std::string::String {
if self.video_url.is_none() {
self.video_url = ::std::option::Option::Some(::std::string::String::new());
}
self.video_url.as_mut().unwrap()
}
pub fn take_video_url(&mut self) -> ::std::string::String {
self.video_url.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for CVideo_ClientGetVideoURL_Response {
const NAME: &'static str = "CVideo_ClientGetVideoURL_Response";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.video_id = ::std::option::Option::Some(is.read_uint64()?);
},
18 => {
self.video_url = ::std::option::Option::Some(is.read_string()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.video_id {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.video_url.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.video_id {
os.write_uint64(1, v)?;
}
if let Some(v) = self.video_url.as_ref() {
os.write_string(2, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CVideo_ClientGetVideoURL_Response {
CVideo_ClientGetVideoURL_Response::new()
}
fn clear(&mut self) {
self.video_id = ::std::option::Option::None;
self.video_url = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CVideo_ClientGetVideoURL_Response {
static instance: CVideo_ClientGetVideoURL_Response = CVideo_ClientGetVideoURL_Response {
video_id: ::std::option::Option::None,
video_url: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct VideoBookmark {
pub app_id: ::std::option::Option<u32>,
pub playback_position_in_seconds: ::std::option::Option<u32>,
pub video_track_id: ::std::option::Option<u64>,
pub audio_track_id: ::std::option::Option<u64>,
pub timedtext_track_id: ::std::option::Option<u64>,
pub last_modified: ::std::option::Option<u32>,
pub hide_from_watch_history: ::std::option::Option<bool>,
pub hide_from_library: ::std::option::Option<bool>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a VideoBookmark {
fn default() -> &'a VideoBookmark {
<VideoBookmark as ::protobuf::Message>::default_instance()
}
}
impl VideoBookmark {
pub fn new() -> VideoBookmark {
::std::default::Default::default()
}
pub fn app_id(&self) -> u32 {
self.app_id.unwrap_or(0)
}
pub fn clear_app_id(&mut self) {
self.app_id = ::std::option::Option::None;
}
pub fn has_app_id(&self) -> bool {
self.app_id.is_some()
}
pub fn set_app_id(&mut self, v: u32) {
self.app_id = ::std::option::Option::Some(v);
}
pub fn playback_position_in_seconds(&self) -> u32 {
self.playback_position_in_seconds.unwrap_or(0)
}
pub fn clear_playback_position_in_seconds(&mut self) {
self.playback_position_in_seconds = ::std::option::Option::None;
}
pub fn has_playback_position_in_seconds(&self) -> bool {
self.playback_position_in_seconds.is_some()
}
pub fn set_playback_position_in_seconds(&mut self, v: u32) {
self.playback_position_in_seconds = ::std::option::Option::Some(v);
}
pub fn video_track_id(&self) -> u64 {
self.video_track_id.unwrap_or(0)
}
pub fn clear_video_track_id(&mut self) {
self.video_track_id = ::std::option::Option::None;
}
pub fn has_video_track_id(&self) -> bool {
self.video_track_id.is_some()
}
pub fn set_video_track_id(&mut self, v: u64) {
self.video_track_id = ::std::option::Option::Some(v);
}
pub fn audio_track_id(&self) -> u64 {
self.audio_track_id.unwrap_or(0)
}
pub fn clear_audio_track_id(&mut self) {
self.audio_track_id = ::std::option::Option::None;
}
pub fn has_audio_track_id(&self) -> bool {
self.audio_track_id.is_some()
}
pub fn set_audio_track_id(&mut self, v: u64) {
self.audio_track_id = ::std::option::Option::Some(v);
}
pub fn timedtext_track_id(&self) -> u64 {
self.timedtext_track_id.unwrap_or(0)
}
pub fn clear_timedtext_track_id(&mut self) {
self.timedtext_track_id = ::std::option::Option::None;
}
pub fn has_timedtext_track_id(&self) -> bool {
self.timedtext_track_id.is_some()
}
pub fn set_timedtext_track_id(&mut self, v: u64) {
self.timedtext_track_id = ::std::option::Option::Some(v);
}
pub fn last_modified(&self) -> u32 {
self.last_modified.unwrap_or(0)
}
pub fn clear_last_modified(&mut self) {
self.last_modified = ::std::option::Option::None;
}
pub fn has_last_modified(&self) -> bool {
self.last_modified.is_some()
}
pub fn set_last_modified(&mut self, v: u32) {
self.last_modified = ::std::option::Option::Some(v);
}
pub fn hide_from_watch_history(&self) -> bool {
self.hide_from_watch_history.unwrap_or(false)
}
pub fn clear_hide_from_watch_history(&mut self) {
self.hide_from_watch_history = ::std::option::Option::None;
}
pub fn has_hide_from_watch_history(&self) -> bool {
self.hide_from_watch_history.is_some()
}
pub fn set_hide_from_watch_history(&mut self, v: bool) {
self.hide_from_watch_history = ::std::option::Option::Some(v);
}
pub fn hide_from_library(&self) -> bool {
self.hide_from_library.unwrap_or(false)
}
pub fn clear_hide_from_library(&mut self) {
self.hide_from_library = ::std::option::Option::None;
}
pub fn has_hide_from_library(&self) -> bool {
self.hide_from_library.is_some()
}
pub fn set_hide_from_library(&mut self, v: bool) {
self.hide_from_library = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for VideoBookmark {
const NAME: &'static str = "VideoBookmark";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.app_id = ::std::option::Option::Some(is.read_uint32()?);
},
16 => {
self.playback_position_in_seconds = ::std::option::Option::Some(is.read_uint32()?);
},
24 => {
self.video_track_id = ::std::option::Option::Some(is.read_uint64()?);
},
32 => {
self.audio_track_id = ::std::option::Option::Some(is.read_uint64()?);
},
40 => {
self.timedtext_track_id = ::std::option::Option::Some(is.read_uint64()?);
},
48 => {
self.last_modified = ::std::option::Option::Some(is.read_uint32()?);
},
56 => {
self.hide_from_watch_history = ::std::option::Option::Some(is.read_bool()?);
},
64 => {
self.hide_from_library = ::std::option::Option::Some(is.read_bool()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.app_id {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.playback_position_in_seconds {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.video_track_id {
my_size += ::protobuf::rt::uint64_size(3, v);
}
if let Some(v) = self.audio_track_id {
my_size += ::protobuf::rt::uint64_size(4, v);
}
if let Some(v) = self.timedtext_track_id {
my_size += ::protobuf::rt::uint64_size(5, v);
}
if let Some(v) = self.last_modified {
my_size += ::protobuf::rt::uint32_size(6, v);
}
if let Some(v) = self.hide_from_watch_history {
my_size += 1 + 1;
}
if let Some(v) = self.hide_from_library {
my_size += 1 + 1;
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.app_id {
os.write_uint32(1, v)?;
}
if let Some(v) = self.playback_position_in_seconds {
os.write_uint32(2, v)?;
}
if let Some(v) = self.video_track_id {
os.write_uint64(3, v)?;
}
if let Some(v) = self.audio_track_id {
os.write_uint64(4, v)?;
}
if let Some(v) = self.timedtext_track_id {
os.write_uint64(5, v)?;
}
if let Some(v) = self.last_modified {
os.write_uint32(6, v)?;
}
if let Some(v) = self.hide_from_watch_history {
os.write_bool(7, v)?;
}
if let Some(v) = self.hide_from_library {
os.write_bool(8, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> VideoBookmark {
VideoBookmark::new()
}
fn clear(&mut self) {
self.app_id = ::std::option::Option::None;
self.playback_position_in_seconds = ::std::option::Option::None;
self.video_track_id = ::std::option::Option::None;
self.audio_track_id = ::std::option::Option::None;
self.timedtext_track_id = ::std::option::Option::None;
self.last_modified = ::std::option::Option::None;
self.hide_from_watch_history = ::std::option::Option::None;
self.hide_from_library = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static VideoBookmark {
static instance: VideoBookmark = VideoBookmark {
app_id: ::std::option::Option::None,
playback_position_in_seconds: ::std::option::Option::None,
video_track_id: ::std::option::Option::None,
audio_track_id: ::std::option::Option::None,
timedtext_track_id: ::std::option::Option::None,
last_modified: ::std::option::Option::None,
hide_from_watch_history: ::std::option::Option::None,
hide_from_library: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[doc = "Bookmarks the locations in the video the user has reached. As as record playback settings per video. Fire and forget."]
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVideo_SetVideoBookmark_Notification {
pub bookmarks: ::std::vec::Vec<VideoBookmark>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CVideo_SetVideoBookmark_Notification {
fn default() -> &'a CVideo_SetVideoBookmark_Notification {
<CVideo_SetVideoBookmark_Notification as ::protobuf::Message>::default_instance()
}
}
impl CVideo_SetVideoBookmark_Notification {
pub fn new() -> CVideo_SetVideoBookmark_Notification {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CVideo_SetVideoBookmark_Notification {
const NAME: &'static str = "CVideo_SetVideoBookmark_Notification";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.bookmarks.push(is.read_message()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
for value in &self.bookmarks {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
for v in &self.bookmarks {
::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
};
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CVideo_SetVideoBookmark_Notification {
CVideo_SetVideoBookmark_Notification::new()
}
fn clear(&mut self) {
self.bookmarks.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CVideo_SetVideoBookmark_Notification {
static instance: CVideo_SetVideoBookmark_Notification = CVideo_SetVideoBookmark_Notification {
bookmarks: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[doc = "Returns the video bookmarks locations for the specific videos. Includes playback settings per video"]
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVideo_GetVideoBookmarks_Request {
pub appids: ::std::vec::Vec<u32>,
pub updated_since: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CVideo_GetVideoBookmarks_Request {
fn default() -> &'a CVideo_GetVideoBookmarks_Request {
<CVideo_GetVideoBookmarks_Request as ::protobuf::Message>::default_instance()
}
}
impl CVideo_GetVideoBookmarks_Request {
pub fn new() -> CVideo_GetVideoBookmarks_Request {
::std::default::Default::default()
}
pub fn updated_since(&self) -> u32 {
self.updated_since.unwrap_or(0)
}
pub fn clear_updated_since(&mut self) {
self.updated_since = ::std::option::Option::None;
}
pub fn has_updated_since(&self) -> bool {
self.updated_since.is_some()
}
pub fn set_updated_since(&mut self, v: u32) {
self.updated_since = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CVideo_GetVideoBookmarks_Request {
const NAME: &'static str = "CVideo_GetVideoBookmarks_Request";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
is.read_repeated_packed_uint32_into(&mut self.appids)?;
},
8 => {
self.appids.push(is.read_uint32()?);
},
16 => {
self.updated_since = ::std::option::Option::Some(is.read_uint32()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
for value in &self.appids {
my_size += ::protobuf::rt::uint32_size(1, *value);
};
if let Some(v) = self.updated_since {
my_size += ::protobuf::rt::uint32_size(2, v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
for v in &self.appids {
os.write_uint32(1, *v)?;
};
if let Some(v) = self.updated_since {
os.write_uint32(2, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CVideo_GetVideoBookmarks_Request {
CVideo_GetVideoBookmarks_Request::new()
}
fn clear(&mut self) {
self.appids.clear();
self.updated_since = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CVideo_GetVideoBookmarks_Request {
static instance: CVideo_GetVideoBookmarks_Request = CVideo_GetVideoBookmarks_Request {
appids: ::std::vec::Vec::new(),
updated_since: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVideo_GetVideoBookmarks_Response {
pub bookmarks: ::std::vec::Vec<VideoBookmark>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CVideo_GetVideoBookmarks_Response {
fn default() -> &'a CVideo_GetVideoBookmarks_Response {
<CVideo_GetVideoBookmarks_Response as ::protobuf::Message>::default_instance()
}
}
impl CVideo_GetVideoBookmarks_Response {
pub fn new() -> CVideo_GetVideoBookmarks_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CVideo_GetVideoBookmarks_Response {
const NAME: &'static str = "CVideo_GetVideoBookmarks_Response";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.bookmarks.push(is.read_message()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
for value in &self.bookmarks {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
for v in &self.bookmarks {
::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
};
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CVideo_GetVideoBookmarks_Response {
CVideo_GetVideoBookmarks_Response::new()
}
fn clear(&mut self) {
self.bookmarks.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CVideo_GetVideoBookmarks_Response {
static instance: CVideo_GetVideoBookmarks_Response = CVideo_GetVideoBookmarks_Response {
bookmarks: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVideo_GameClipRepresentation {
pub representation_name: ::std::option::Option<::std::string::String>,
pub horizontal_resolution: ::std::option::Option<u32>,
pub vertical_resolution: ::std::option::Option<u32>,
pub frame_rate: ::std::option::Option<f64>,
pub bandwidth: ::std::option::Option<u32>,
pub audio_sample_rate: ::std::option::Option<u32>,
pub frame_rate_string: ::std::option::Option<::std::string::String>,
pub codec: ::std::option::Option<::std::string::String>,
pub audio_channel_config: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CVideo_GameClipRepresentation {
fn default() -> &'a CVideo_GameClipRepresentation {
<CVideo_GameClipRepresentation as ::protobuf::Message>::default_instance()
}
}
impl CVideo_GameClipRepresentation {
pub fn new() -> CVideo_GameClipRepresentation {
::std::default::Default::default()
}
pub fn representation_name(&self) -> &str {
match self.representation_name.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_representation_name(&mut self) {
self.representation_name = ::std::option::Option::None;
}
pub fn has_representation_name(&self) -> bool {
self.representation_name.is_some()
}
pub fn set_representation_name(&mut self, v: ::std::string::String) {
self.representation_name = ::std::option::Option::Some(v);
}
pub fn mut_representation_name(&mut self) -> &mut ::std::string::String {
if self.representation_name.is_none() {
self.representation_name = ::std::option::Option::Some(::std::string::String::new());
}
self.representation_name.as_mut().unwrap()
}
pub fn take_representation_name(&mut self) -> ::std::string::String {
self.representation_name.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn horizontal_resolution(&self) -> u32 {
self.horizontal_resolution.unwrap_or(0)
}
pub fn clear_horizontal_resolution(&mut self) {
self.horizontal_resolution = ::std::option::Option::None;
}
pub fn has_horizontal_resolution(&self) -> bool {
self.horizontal_resolution.is_some()
}
pub fn set_horizontal_resolution(&mut self, v: u32) {
self.horizontal_resolution = ::std::option::Option::Some(v);
}
pub fn vertical_resolution(&self) -> u32 {
self.vertical_resolution.unwrap_or(0)
}
pub fn clear_vertical_resolution(&mut self) {
self.vertical_resolution = ::std::option::Option::None;
}
pub fn has_vertical_resolution(&self) -> bool {
self.vertical_resolution.is_some()
}
pub fn set_vertical_resolution(&mut self, v: u32) {
self.vertical_resolution = ::std::option::Option::Some(v);
}
pub fn frame_rate(&self) -> f64 {
self.frame_rate.unwrap_or(0.)
}
pub fn clear_frame_rate(&mut self) {
self.frame_rate = ::std::option::Option::None;
}
pub fn has_frame_rate(&self) -> bool {
self.frame_rate.is_some()
}
pub fn set_frame_rate(&mut self, v: f64) {
self.frame_rate = ::std::option::Option::Some(v);
}
pub fn bandwidth(&self) -> u32 {
self.bandwidth.unwrap_or(0)
}
pub fn clear_bandwidth(&mut self) {
self.bandwidth = ::std::option::Option::None;
}
pub fn has_bandwidth(&self) -> bool {
self.bandwidth.is_some()
}
pub fn set_bandwidth(&mut self, v: u32) {
self.bandwidth = ::std::option::Option::Some(v);
}
pub fn audio_sample_rate(&self) -> u32 {
self.audio_sample_rate.unwrap_or(0)
}
pub fn clear_audio_sample_rate(&mut self) {
self.audio_sample_rate = ::std::option::Option::None;
}
pub fn has_audio_sample_rate(&self) -> bool {
self.audio_sample_rate.is_some()
}
pub fn set_audio_sample_rate(&mut self, v: u32) {
self.audio_sample_rate = ::std::option::Option::Some(v);
}
pub fn frame_rate_string(&self) -> &str {
match self.frame_rate_string.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_frame_rate_string(&mut self) {
self.frame_rate_string = ::std::option::Option::None;
}
pub fn has_frame_rate_string(&self) -> bool {
self.frame_rate_string.is_some()
}
pub fn set_frame_rate_string(&mut self, v: ::std::string::String) {
self.frame_rate_string = ::std::option::Option::Some(v);
}
pub fn mut_frame_rate_string(&mut self) -> &mut ::std::string::String {
if self.frame_rate_string.is_none() {
self.frame_rate_string = ::std::option::Option::Some(::std::string::String::new());
}
self.frame_rate_string.as_mut().unwrap()
}
pub fn take_frame_rate_string(&mut self) -> ::std::string::String {
self.frame_rate_string.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn codec(&self) -> &str {
match self.codec.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_codec(&mut self) {
self.codec = ::std::option::Option::None;
}
pub fn has_codec(&self) -> bool {
self.codec.is_some()
}
pub fn set_codec(&mut self, v: ::std::string::String) {
self.codec = ::std::option::Option::Some(v);
}
pub fn mut_codec(&mut self) -> &mut ::std::string::String {
if self.codec.is_none() {
self.codec = ::std::option::Option::Some(::std::string::String::new());
}
self.codec.as_mut().unwrap()
}
pub fn take_codec(&mut self) -> ::std::string::String {
self.codec.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn audio_channel_config(&self) -> u32 {
self.audio_channel_config.unwrap_or(0)
}
pub fn clear_audio_channel_config(&mut self) {
self.audio_channel_config = ::std::option::Option::None;
}
pub fn has_audio_channel_config(&self) -> bool {
self.audio_channel_config.is_some()
}
pub fn set_audio_channel_config(&mut self, v: u32) {
self.audio_channel_config = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CVideo_GameClipRepresentation {
const NAME: &'static str = "CVideo_GameClipRepresentation";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
18 => {
self.representation_name = ::std::option::Option::Some(is.read_string()?);
},
24 => {
self.horizontal_resolution = ::std::option::Option::Some(is.read_uint32()?);
},
32 => {
self.vertical_resolution = ::std::option::Option::Some(is.read_uint32()?);
},
41 => {
self.frame_rate = ::std::option::Option::Some(is.read_double()?);
},
48 => {
self.bandwidth = ::std::option::Option::Some(is.read_uint32()?);
},
56 => {
self.audio_sample_rate = ::std::option::Option::Some(is.read_uint32()?);
},
66 => {
self.frame_rate_string = ::std::option::Option::Some(is.read_string()?);
},
74 => {
self.codec = ::std::option::Option::Some(is.read_string()?);
},
80 => {
self.audio_channel_config = ::std::option::Option::Some(is.read_uint32()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.representation_name.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
if let Some(v) = self.horizontal_resolution {
my_size += ::protobuf::rt::uint32_size(3, v);
}
if let Some(v) = self.vertical_resolution {
my_size += ::protobuf::rt::uint32_size(4, v);
}
if let Some(v) = self.frame_rate {
my_size += 1 + 8;
}
if let Some(v) = self.bandwidth {
my_size += ::protobuf::rt::uint32_size(6, v);
}
if let Some(v) = self.audio_sample_rate {
my_size += ::protobuf::rt::uint32_size(7, v);
}
if let Some(v) = self.frame_rate_string.as_ref() {
my_size += ::protobuf::rt::string_size(8, &v);
}
if let Some(v) = self.codec.as_ref() {
my_size += ::protobuf::rt::string_size(9, &v);
}
if let Some(v) = self.audio_channel_config {
my_size += ::protobuf::rt::uint32_size(10, v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.representation_name.as_ref() {
os.write_string(2, v)?;
}
if let Some(v) = self.horizontal_resolution {
os.write_uint32(3, v)?;
}
if let Some(v) = self.vertical_resolution {
os.write_uint32(4, v)?;
}
if let Some(v) = self.frame_rate {
os.write_double(5, v)?;
}
if let Some(v) = self.bandwidth {
os.write_uint32(6, v)?;
}
if let Some(v) = self.audio_sample_rate {
os.write_uint32(7, v)?;
}
if let Some(v) = self.frame_rate_string.as_ref() {
os.write_string(8, v)?;
}
if let Some(v) = self.codec.as_ref() {
os.write_string(9, v)?;
}
if let Some(v) = self.audio_channel_config {
os.write_uint32(10, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CVideo_GameClipRepresentation {
CVideo_GameClipRepresentation::new()
}
fn clear(&mut self) {
self.representation_name = ::std::option::Option::None;
self.horizontal_resolution = ::std::option::Option::None;
self.vertical_resolution = ::std::option::Option::None;
self.frame_rate = ::std::option::Option::None;
self.bandwidth = ::std::option::Option::None;
self.audio_sample_rate = ::std::option::Option::None;
self.frame_rate_string = ::std::option::Option::None;
self.codec = ::std::option::Option::None;
self.audio_channel_config = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CVideo_GameClipRepresentation {
static instance: CVideo_GameClipRepresentation = CVideo_GameClipRepresentation {
representation_name: ::std::option::Option::None,
horizontal_resolution: ::std::option::Option::None,
vertical_resolution: ::std::option::Option::None,
frame_rate: ::std::option::Option::None,
bandwidth: ::std::option::Option::None,
audio_sample_rate: ::std::option::Option::None,
frame_rate_string: ::std::option::Option::None,
codec: ::std::option::Option::None,
audio_channel_config: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVideo_GameClipComponent {
pub component_name: ::std::option::Option<::std::string::String>,
pub contents: ::std::option::Option<u32>,
pub segment_size: ::std::option::Option<u32>,
pub file_type: ::std::option::Option<::std::string::String>,
pub representations: ::std::vec::Vec<CVideo_GameClipRepresentation>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CVideo_GameClipComponent {
fn default() -> &'a CVideo_GameClipComponent {
<CVideo_GameClipComponent as ::protobuf::Message>::default_instance()
}
}
impl CVideo_GameClipComponent {
pub fn new() -> CVideo_GameClipComponent {
::std::default::Default::default()
}
pub fn component_name(&self) -> &str {
match self.component_name.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_component_name(&mut self) {
self.component_name = ::std::option::Option::None;
}
pub fn has_component_name(&self) -> bool {
self.component_name.is_some()
}
pub fn set_component_name(&mut self, v: ::std::string::String) {
self.component_name = ::std::option::Option::Some(v);
}
pub fn mut_component_name(&mut self) -> &mut ::std::string::String {
if self.component_name.is_none() {
self.component_name = ::std::option::Option::Some(::std::string::String::new());
}
self.component_name.as_mut().unwrap()
}
pub fn take_component_name(&mut self) -> ::std::string::String {
self.component_name.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn contents(&self) -> u32 {
self.contents.unwrap_or(0)
}
pub fn clear_contents(&mut self) {
self.contents = ::std::option::Option::None;
}
pub fn has_contents(&self) -> bool {
self.contents.is_some()
}
pub fn set_contents(&mut self, v: u32) {
self.contents = ::std::option::Option::Some(v);
}
pub fn segment_size(&self) -> u32 {
self.segment_size.unwrap_or(0)
}
pub fn clear_segment_size(&mut self) {
self.segment_size = ::std::option::Option::None;
}
pub fn has_segment_size(&self) -> bool {
self.segment_size.is_some()
}
pub fn set_segment_size(&mut self, v: u32) {
self.segment_size = ::std::option::Option::Some(v);
}
pub fn file_type(&self) -> &str {
match self.file_type.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_file_type(&mut self) {
self.file_type = ::std::option::Option::None;
}
pub fn has_file_type(&self) -> bool {
self.file_type.is_some()
}
pub fn set_file_type(&mut self, v: ::std::string::String) {
self.file_type = ::std::option::Option::Some(v);
}
pub fn mut_file_type(&mut self) -> &mut ::std::string::String {
if self.file_type.is_none() {
self.file_type = ::std::option::Option::Some(::std::string::String::new());
}
self.file_type.as_mut().unwrap()
}
pub fn take_file_type(&mut self) -> ::std::string::String {
self.file_type.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for CVideo_GameClipComponent {
const NAME: &'static str = "CVideo_GameClipComponent";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.component_name = ::std::option::Option::Some(is.read_string()?);
},
16 => {
self.contents = ::std::option::Option::Some(is.read_uint32()?);
},
24 => {
self.segment_size = ::std::option::Option::Some(is.read_uint32()?);
},
34 => {
self.file_type = ::std::option::Option::Some(is.read_string()?);
},
42 => {
self.representations.push(is.read_message()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.component_name.as_ref() {
my_size += ::protobuf::rt::string_size(1, &v);
}
if let Some(v) = self.contents {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.segment_size {
my_size += ::protobuf::rt::uint32_size(3, v);
}
if let Some(v) = self.file_type.as_ref() {
my_size += ::protobuf::rt::string_size(4, &v);
}
for value in &self.representations {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.component_name.as_ref() {
os.write_string(1, v)?;
}
if let Some(v) = self.contents {
os.write_uint32(2, v)?;
}
if let Some(v) = self.segment_size {
os.write_uint32(3, v)?;
}
if let Some(v) = self.file_type.as_ref() {
os.write_string(4, v)?;
}
for v in &self.representations {
::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
};
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CVideo_GameClipComponent {
CVideo_GameClipComponent::new()
}
fn clear(&mut self) {
self.component_name = ::std::option::Option::None;
self.contents = ::std::option::Option::None;
self.segment_size = ::std::option::Option::None;
self.file_type = ::std::option::Option::None;
self.representations.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CVideo_GameClipComponent {
static instance: CVideo_GameClipComponent = CVideo_GameClipComponent {
component_name: ::std::option::Option::None,
contents: ::std::option::Option::None,
segment_size: ::std::option::Option::None,
file_type: ::std::option::Option::None,
representations: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[doc = "Create a game recording clip video"]
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVideo_CreateGameClip_Request {
pub app_id: ::std::option::Option<u32>,
pub num_segments: ::std::option::Option<u32>,
pub length_milliseconds: ::std::option::Option<u32>,
pub segment_duration_timescale: ::std::option::Option<u32>,
pub segment_duration: ::std::option::Option<u32>,
pub components: ::std::vec::Vec<CVideo_GameClipComponent>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CVideo_CreateGameClip_Request {
fn default() -> &'a CVideo_CreateGameClip_Request {
<CVideo_CreateGameClip_Request as ::protobuf::Message>::default_instance()
}
}
impl CVideo_CreateGameClip_Request {
pub fn new() -> CVideo_CreateGameClip_Request {
::std::default::Default::default()
}
pub fn app_id(&self) -> u32 {
self.app_id.unwrap_or(0)
}
pub fn clear_app_id(&mut self) {
self.app_id = ::std::option::Option::None;
}
pub fn has_app_id(&self) -> bool {
self.app_id.is_some()
}
pub fn set_app_id(&mut self, v: u32) {
self.app_id = ::std::option::Option::Some(v);
}
pub fn num_segments(&self) -> u32 {
self.num_segments.unwrap_or(0)
}
pub fn clear_num_segments(&mut self) {
self.num_segments = ::std::option::Option::None;
}
pub fn has_num_segments(&self) -> bool {
self.num_segments.is_some()
}
pub fn set_num_segments(&mut self, v: u32) {
self.num_segments = ::std::option::Option::Some(v);
}
pub fn length_milliseconds(&self) -> u32 {
self.length_milliseconds.unwrap_or(0)
}
pub fn clear_length_milliseconds(&mut self) {
self.length_milliseconds = ::std::option::Option::None;
}
pub fn has_length_milliseconds(&self) -> bool {
self.length_milliseconds.is_some()
}
pub fn set_length_milliseconds(&mut self, v: u32) {
self.length_milliseconds = ::std::option::Option::Some(v);
}
pub fn segment_duration_timescale(&self) -> u32 {
self.segment_duration_timescale.unwrap_or(0)
}
pub fn clear_segment_duration_timescale(&mut self) {
self.segment_duration_timescale = ::std::option::Option::None;
}
pub fn has_segment_duration_timescale(&self) -> bool {
self.segment_duration_timescale.is_some()
}
pub fn set_segment_duration_timescale(&mut self, v: u32) {
self.segment_duration_timescale = ::std::option::Option::Some(v);
}
pub fn segment_duration(&self) -> u32 {
self.segment_duration.unwrap_or(0)
}
pub fn clear_segment_duration(&mut self) {
self.segment_duration = ::std::option::Option::None;
}
pub fn has_segment_duration(&self) -> bool {
self.segment_duration.is_some()
}
pub fn set_segment_duration(&mut self, v: u32) {
self.segment_duration = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CVideo_CreateGameClip_Request {
const NAME: &'static str = "CVideo_CreateGameClip_Request";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.app_id = ::std::option::Option::Some(is.read_uint32()?);
},
16 => {
self.num_segments = ::std::option::Option::Some(is.read_uint32()?);
},
24 => {
self.length_milliseconds = ::std::option::Option::Some(is.read_uint32()?);
},
32 => {
self.segment_duration_timescale = ::std::option::Option::Some(is.read_uint32()?);
},
40 => {
self.segment_duration = ::std::option::Option::Some(is.read_uint32()?);
},
50 => {
self.components.push(is.read_message()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.app_id {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.num_segments {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.length_milliseconds {
my_size += ::protobuf::rt::uint32_size(3, v);
}
if let Some(v) = self.segment_duration_timescale {
my_size += ::protobuf::rt::uint32_size(4, v);
}
if let Some(v) = self.segment_duration {
my_size += ::protobuf::rt::uint32_size(5, v);
}
for value in &self.components {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.app_id {
os.write_uint32(1, v)?;
}
if let Some(v) = self.num_segments {
os.write_uint32(2, v)?;
}
if let Some(v) = self.length_milliseconds {
os.write_uint32(3, v)?;
}
if let Some(v) = self.segment_duration_timescale {
os.write_uint32(4, v)?;
}
if let Some(v) = self.segment_duration {
os.write_uint32(5, v)?;
}
for v in &self.components {
::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
};
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CVideo_CreateGameClip_Request {
CVideo_CreateGameClip_Request::new()
}
fn clear(&mut self) {
self.app_id = ::std::option::Option::None;
self.num_segments = ::std::option::Option::None;
self.length_milliseconds = ::std::option::Option::None;
self.segment_duration_timescale = ::std::option::Option::None;
self.segment_duration = ::std::option::Option::None;
self.components.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CVideo_CreateGameClip_Request {
static instance: CVideo_CreateGameClip_Request = CVideo_CreateGameClip_Request {
app_id: ::std::option::Option::None,
num_segments: ::std::option::Option::None,
length_milliseconds: ::std::option::Option::None,
segment_duration_timescale: ::std::option::Option::None,
segment_duration: ::std::option::Option::None,
components: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVideo_CreateGameClip_Response {
pub clip_id: ::std::option::Option<u64>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CVideo_CreateGameClip_Response {
fn default() -> &'a CVideo_CreateGameClip_Response {
<CVideo_CreateGameClip_Response as ::protobuf::Message>::default_instance()
}
}
impl CVideo_CreateGameClip_Response {
pub fn new() -> CVideo_CreateGameClip_Response {
::std::default::Default::default()
}
pub fn clip_id(&self) -> u64 {
self.clip_id.unwrap_or(0)
}
pub fn clear_clip_id(&mut self) {
self.clip_id = ::std::option::Option::None;
}
pub fn has_clip_id(&self) -> bool {
self.clip_id.is_some()
}
pub fn set_clip_id(&mut self, v: u64) {
self.clip_id = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CVideo_CreateGameClip_Response {
const NAME: &'static str = "CVideo_CreateGameClip_Response";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.clip_id = ::std::option::Option::Some(is.read_uint64()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.clip_id {
my_size += ::protobuf::rt::uint64_size(1, v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.clip_id {
os.write_uint64(1, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CVideo_CreateGameClip_Response {
CVideo_CreateGameClip_Response::new()
}
fn clear(&mut self) {
self.clip_id = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CVideo_CreateGameClip_Response {
static instance: CVideo_CreateGameClip_Response = CVideo_CreateGameClip_Response {
clip_id: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVideo_GameClipSegmentInfo {
pub segment_number: ::std::option::Option<u32>,
pub segment_size_bytes: ::std::option::Option<u64>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CVideo_GameClipSegmentInfo {
fn default() -> &'a CVideo_GameClipSegmentInfo {
<CVideo_GameClipSegmentInfo as ::protobuf::Message>::default_instance()
}
}
impl CVideo_GameClipSegmentInfo {
pub fn new() -> CVideo_GameClipSegmentInfo {
::std::default::Default::default()
}
pub fn segment_number(&self) -> u32 {
self.segment_number.unwrap_or(0)
}
pub fn clear_segment_number(&mut self) {
self.segment_number = ::std::option::Option::None;
}
pub fn has_segment_number(&self) -> bool {
self.segment_number.is_some()
}
pub fn set_segment_number(&mut self, v: u32) {
self.segment_number = ::std::option::Option::Some(v);
}
pub fn segment_size_bytes(&self) -> u64 {
self.segment_size_bytes.unwrap_or(0)
}
pub fn clear_segment_size_bytes(&mut self) {
self.segment_size_bytes = ::std::option::Option::None;
}
pub fn has_segment_size_bytes(&self) -> bool {
self.segment_size_bytes.is_some()
}
pub fn set_segment_size_bytes(&mut self, v: u64) {
self.segment_size_bytes = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CVideo_GameClipSegmentInfo {
const NAME: &'static str = "CVideo_GameClipSegmentInfo";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
32 => {
self.segment_number = ::std::option::Option::Some(is.read_uint32()?);
},
40 => {
self.segment_size_bytes = ::std::option::Option::Some(is.read_uint64()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.segment_number {
my_size += ::protobuf::rt::uint32_size(4, v);
}
if let Some(v) = self.segment_size_bytes {
my_size += ::protobuf::rt::uint64_size(5, v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.segment_number {
os.write_uint32(4, v)?;
}
if let Some(v) = self.segment_size_bytes {
os.write_uint64(5, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CVideo_GameClipSegmentInfo {
CVideo_GameClipSegmentInfo::new()
}
fn clear(&mut self) {
self.segment_number = ::std::option::Option::None;
self.segment_size_bytes = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CVideo_GameClipSegmentInfo {
static instance: CVideo_GameClipSegmentInfo = CVideo_GameClipSegmentInfo {
segment_number: ::std::option::Option::None,
segment_size_bytes: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[doc = "Begin a batch of segment uploads for a GameClip"]
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVideo_BeginGameClipSegmentsUpload_Request {
pub clip_id: ::std::option::Option<u64>,
pub component_name: ::std::option::Option<::std::string::String>,
pub representation_name: ::std::option::Option<::std::string::String>,
pub segments_to_store: ::std::vec::Vec<CVideo_GameClipSegmentInfo>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CVideo_BeginGameClipSegmentsUpload_Request {
fn default() -> &'a CVideo_BeginGameClipSegmentsUpload_Request {
<CVideo_BeginGameClipSegmentsUpload_Request as ::protobuf::Message>::default_instance()
}
}
impl CVideo_BeginGameClipSegmentsUpload_Request {
pub fn new() -> CVideo_BeginGameClipSegmentsUpload_Request {
::std::default::Default::default()
}
pub fn clip_id(&self) -> u64 {
self.clip_id.unwrap_or(0)
}
pub fn clear_clip_id(&mut self) {
self.clip_id = ::std::option::Option::None;
}
pub fn has_clip_id(&self) -> bool {
self.clip_id.is_some()
}
pub fn set_clip_id(&mut self, v: u64) {
self.clip_id = ::std::option::Option::Some(v);
}
pub fn component_name(&self) -> &str {
match self.component_name.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_component_name(&mut self) {
self.component_name = ::std::option::Option::None;
}
pub fn has_component_name(&self) -> bool {
self.component_name.is_some()
}
pub fn set_component_name(&mut self, v: ::std::string::String) {
self.component_name = ::std::option::Option::Some(v);
}
pub fn mut_component_name(&mut self) -> &mut ::std::string::String {
if self.component_name.is_none() {
self.component_name = ::std::option::Option::Some(::std::string::String::new());
}
self.component_name.as_mut().unwrap()
}
pub fn take_component_name(&mut self) -> ::std::string::String {
self.component_name.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn representation_name(&self) -> &str {
match self.representation_name.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_representation_name(&mut self) {
self.representation_name = ::std::option::Option::None;
}
pub fn has_representation_name(&self) -> bool {
self.representation_name.is_some()
}
pub fn set_representation_name(&mut self, v: ::std::string::String) {
self.representation_name = ::std::option::Option::Some(v);
}
pub fn mut_representation_name(&mut self) -> &mut ::std::string::String {
if self.representation_name.is_none() {
self.representation_name = ::std::option::Option::Some(::std::string::String::new());
}
self.representation_name.as_mut().unwrap()
}
pub fn take_representation_name(&mut self) -> ::std::string::String {
self.representation_name.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for CVideo_BeginGameClipSegmentsUpload_Request {
const NAME: &'static str = "CVideo_BeginGameClipSegmentsUpload_Request";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.clip_id = ::std::option::Option::Some(is.read_uint64()?);
},
18 => {
self.component_name = ::std::option::Option::Some(is.read_string()?);
},
26 => {
self.representation_name = ::std::option::Option::Some(is.read_string()?);
},
34 => {
self.segments_to_store.push(is.read_message()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.clip_id {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.component_name.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
if let Some(v) = self.representation_name.as_ref() {
my_size += ::protobuf::rt::string_size(3, &v);
}
for value in &self.segments_to_store {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.clip_id {
os.write_uint64(1, v)?;
}
if let Some(v) = self.component_name.as_ref() {
os.write_string(2, v)?;
}
if let Some(v) = self.representation_name.as_ref() {
os.write_string(3, v)?;
}
for v in &self.segments_to_store {
::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
};
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CVideo_BeginGameClipSegmentsUpload_Request {
CVideo_BeginGameClipSegmentsUpload_Request::new()
}
fn clear(&mut self) {
self.clip_id = ::std::option::Option::None;
self.component_name = ::std::option::Option::None;
self.representation_name = ::std::option::Option::None;
self.segments_to_store.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CVideo_BeginGameClipSegmentsUpload_Request {
static instance: CVideo_BeginGameClipSegmentsUpload_Request = CVideo_BeginGameClipSegmentsUpload_Request {
clip_id: ::std::option::Option::None,
component_name: ::std::option::Option::None,
representation_name: ::std::option::Option::None,
segments_to_store: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVideo_GameClipSegmentUploadInfo {
pub segment_info: ::protobuf::MessageField<CVideo_GameClipSegmentInfo>,
pub url_host: ::std::option::Option<::std::string::String>,
pub url_path: ::std::option::Option<::std::string::String>,
pub use_https: ::std::option::Option<bool>,
pub request_headers: ::std::vec::Vec<cvideo_game_clip_segment_upload_info::HTTPHeaders>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CVideo_GameClipSegmentUploadInfo {
fn default() -> &'a CVideo_GameClipSegmentUploadInfo {
<CVideo_GameClipSegmentUploadInfo as ::protobuf::Message>::default_instance()
}
}
impl CVideo_GameClipSegmentUploadInfo {
pub fn new() -> CVideo_GameClipSegmentUploadInfo {
::std::default::Default::default()
}
pub fn url_host(&self) -> &str {
match self.url_host.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_url_host(&mut self) {
self.url_host = ::std::option::Option::None;
}
pub fn has_url_host(&self) -> bool {
self.url_host.is_some()
}
pub fn set_url_host(&mut self, v: ::std::string::String) {
self.url_host = ::std::option::Option::Some(v);
}
pub fn mut_url_host(&mut self) -> &mut ::std::string::String {
if self.url_host.is_none() {
self.url_host = ::std::option::Option::Some(::std::string::String::new());
}
self.url_host.as_mut().unwrap()
}
pub fn take_url_host(&mut self) -> ::std::string::String {
self.url_host.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn url_path(&self) -> &str {
match self.url_path.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_url_path(&mut self) {
self.url_path = ::std::option::Option::None;
}
pub fn has_url_path(&self) -> bool {
self.url_path.is_some()
}
pub fn set_url_path(&mut self, v: ::std::string::String) {
self.url_path = ::std::option::Option::Some(v);
}
pub fn mut_url_path(&mut self) -> &mut ::std::string::String {
if self.url_path.is_none() {
self.url_path = ::std::option::Option::Some(::std::string::String::new());
}
self.url_path.as_mut().unwrap()
}
pub fn take_url_path(&mut self) -> ::std::string::String {
self.url_path.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn use_https(&self) -> bool {
self.use_https.unwrap_or(false)
}
pub fn clear_use_https(&mut self) {
self.use_https = ::std::option::Option::None;
}
pub fn has_use_https(&self) -> bool {
self.use_https.is_some()
}
pub fn set_use_https(&mut self, v: bool) {
self.use_https = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CVideo_GameClipSegmentUploadInfo {
const NAME: &'static str = "CVideo_GameClipSegmentUploadInfo";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
::protobuf::rt::read_singular_message_into_field(is, &mut self.segment_info)?;
},
18 => {
self.url_host = ::std::option::Option::Some(is.read_string()?);
},
26 => {
self.url_path = ::std::option::Option::Some(is.read_string()?);
},
32 => {
self.use_https = ::std::option::Option::Some(is.read_bool()?);
},
42 => {
self.request_headers.push(is.read_message()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.segment_info.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
}
if let Some(v) = self.url_host.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
if let Some(v) = self.url_path.as_ref() {
my_size += ::protobuf::rt::string_size(3, &v);
}
if let Some(v) = self.use_https {
my_size += 1 + 1;
}
for value in &self.request_headers {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.segment_info.as_ref() {
::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
}
if let Some(v) = self.url_host.as_ref() {
os.write_string(2, v)?;
}
if let Some(v) = self.url_path.as_ref() {
os.write_string(3, v)?;
}
if let Some(v) = self.use_https {
os.write_bool(4, v)?;
}
for v in &self.request_headers {
::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
};
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CVideo_GameClipSegmentUploadInfo {
CVideo_GameClipSegmentUploadInfo::new()
}
fn clear(&mut self) {
self.segment_info.clear();
self.url_host = ::std::option::Option::None;
self.url_path = ::std::option::Option::None;
self.use_https = ::std::option::Option::None;
self.request_headers.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CVideo_GameClipSegmentUploadInfo {
static instance: CVideo_GameClipSegmentUploadInfo = CVideo_GameClipSegmentUploadInfo {
segment_info: ::protobuf::MessageField::none(),
url_host: ::std::option::Option::None,
url_path: ::std::option::Option::None,
use_https: ::std::option::Option::None,
request_headers: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
pub mod cvideo_game_clip_segment_upload_info {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct HTTPHeaders {
pub name: ::std::option::Option<::std::string::String>,
pub value: ::std::option::Option<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a HTTPHeaders {
fn default() -> &'a HTTPHeaders {
<HTTPHeaders as ::protobuf::Message>::default_instance()
}
}
impl HTTPHeaders {
pub fn new() -> HTTPHeaders {
::std::default::Default::default()
}
pub fn name(&self) -> &str {
match self.name.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_name(&mut self) {
self.name = ::std::option::Option::None;
}
pub fn has_name(&self) -> bool {
self.name.is_some()
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = ::std::option::Option::Some(v);
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
if self.name.is_none() {
self.name = ::std::option::Option::Some(::std::string::String::new());
}
self.name.as_mut().unwrap()
}
pub fn take_name(&mut self) -> ::std::string::String {
self.name.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn value(&self) -> &str {
match self.value.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_value(&mut self) {
self.value = ::std::option::Option::None;
}
pub fn has_value(&self) -> bool {
self.value.is_some()
}
pub fn set_value(&mut self, v: ::std::string::String) {
self.value = ::std::option::Option::Some(v);
}
pub fn mut_value(&mut self) -> &mut ::std::string::String {
if self.value.is_none() {
self.value = ::std::option::Option::Some(::std::string::String::new());
}
self.value.as_mut().unwrap()
}
pub fn take_value(&mut self) -> ::std::string::String {
self.value.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for HTTPHeaders {
const NAME: &'static str = "HTTPHeaders";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.name = ::std::option::Option::Some(is.read_string()?);
},
18 => {
self.value = ::std::option::Option::Some(is.read_string()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.name.as_ref() {
my_size += ::protobuf::rt::string_size(1, &v);
}
if let Some(v) = self.value.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.name.as_ref() {
os.write_string(1, v)?;
}
if let Some(v) = self.value.as_ref() {
os.write_string(2, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> HTTPHeaders {
HTTPHeaders::new()
}
fn clear(&mut self) {
self.name = ::std::option::Option::None;
self.value = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static HTTPHeaders {
static instance: HTTPHeaders = HTTPHeaders {
name: ::std::option::Option::None,
value: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVideo_BeginGameClipSegmentsUpload_Response {
pub segments_needed: ::std::vec::Vec<CVideo_GameClipSegmentUploadInfo>,
pub call_again: ::std::option::Option<bool>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CVideo_BeginGameClipSegmentsUpload_Response {
fn default() -> &'a CVideo_BeginGameClipSegmentsUpload_Response {
<CVideo_BeginGameClipSegmentsUpload_Response as ::protobuf::Message>::default_instance()
}
}
impl CVideo_BeginGameClipSegmentsUpload_Response {
pub fn new() -> CVideo_BeginGameClipSegmentsUpload_Response {
::std::default::Default::default()
}
pub fn call_again(&self) -> bool {
self.call_again.unwrap_or(false)
}
pub fn clear_call_again(&mut self) {
self.call_again = ::std::option::Option::None;
}
pub fn has_call_again(&self) -> bool {
self.call_again.is_some()
}
pub fn set_call_again(&mut self, v: bool) {
self.call_again = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CVideo_BeginGameClipSegmentsUpload_Response {
const NAME: &'static str = "CVideo_BeginGameClipSegmentsUpload_Response";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.segments_needed.push(is.read_message()?);
},
16 => {
self.call_again = ::std::option::Option::Some(is.read_bool()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
for value in &self.segments_needed {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
if let Some(v) = self.call_again {
my_size += 1 + 1;
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
for v in &self.segments_needed {
::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
};
if let Some(v) = self.call_again {
os.write_bool(2, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CVideo_BeginGameClipSegmentsUpload_Response {
CVideo_BeginGameClipSegmentsUpload_Response::new()
}
fn clear(&mut self) {
self.segments_needed.clear();
self.call_again = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CVideo_BeginGameClipSegmentsUpload_Response {
static instance: CVideo_BeginGameClipSegmentsUpload_Response = CVideo_BeginGameClipSegmentsUpload_Response {
segments_needed: ::std::vec::Vec::new(),
call_again: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[doc = "Note completion of a batch of GameClip segment uploads"]
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVideo_CommitGameClipSegmentsUpload_Request {
pub clip_id: ::std::option::Option<u64>,
pub component_name: ::std::option::Option<::std::string::String>,
pub representation_name: ::std::option::Option<::std::string::String>,
pub first_segment_number: ::std::option::Option<u32>,
pub num_segments: ::std::option::Option<u32>,
pub upload_result: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CVideo_CommitGameClipSegmentsUpload_Request {
fn default() -> &'a CVideo_CommitGameClipSegmentsUpload_Request {
<CVideo_CommitGameClipSegmentsUpload_Request as ::protobuf::Message>::default_instance()
}
}
impl CVideo_CommitGameClipSegmentsUpload_Request {
pub fn new() -> CVideo_CommitGameClipSegmentsUpload_Request {
::std::default::Default::default()
}
pub fn clip_id(&self) -> u64 {
self.clip_id.unwrap_or(0)
}
pub fn clear_clip_id(&mut self) {
self.clip_id = ::std::option::Option::None;
}
pub fn has_clip_id(&self) -> bool {
self.clip_id.is_some()
}
pub fn set_clip_id(&mut self, v: u64) {
self.clip_id = ::std::option::Option::Some(v);
}
pub fn component_name(&self) -> &str {
match self.component_name.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_component_name(&mut self) {
self.component_name = ::std::option::Option::None;
}
pub fn has_component_name(&self) -> bool {
self.component_name.is_some()
}
pub fn set_component_name(&mut self, v: ::std::string::String) {
self.component_name = ::std::option::Option::Some(v);
}
pub fn mut_component_name(&mut self) -> &mut ::std::string::String {
if self.component_name.is_none() {
self.component_name = ::std::option::Option::Some(::std::string::String::new());
}
self.component_name.as_mut().unwrap()
}
pub fn take_component_name(&mut self) -> ::std::string::String {
self.component_name.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn representation_name(&self) -> &str {
match self.representation_name.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_representation_name(&mut self) {
self.representation_name = ::std::option::Option::None;
}
pub fn has_representation_name(&self) -> bool {
self.representation_name.is_some()
}
pub fn set_representation_name(&mut self, v: ::std::string::String) {
self.representation_name = ::std::option::Option::Some(v);
}
pub fn mut_representation_name(&mut self) -> &mut ::std::string::String {
if self.representation_name.is_none() {
self.representation_name = ::std::option::Option::Some(::std::string::String::new());
}
self.representation_name.as_mut().unwrap()
}
pub fn take_representation_name(&mut self) -> ::std::string::String {
self.representation_name.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn first_segment_number(&self) -> u32 {
self.first_segment_number.unwrap_or(0)
}
pub fn clear_first_segment_number(&mut self) {
self.first_segment_number = ::std::option::Option::None;
}
pub fn has_first_segment_number(&self) -> bool {
self.first_segment_number.is_some()
}
pub fn set_first_segment_number(&mut self, v: u32) {
self.first_segment_number = ::std::option::Option::Some(v);
}
pub fn num_segments(&self) -> u32 {
self.num_segments.unwrap_or(0)
}
pub fn clear_num_segments(&mut self) {
self.num_segments = ::std::option::Option::None;
}
pub fn has_num_segments(&self) -> bool {
self.num_segments.is_some()
}
pub fn set_num_segments(&mut self, v: u32) {
self.num_segments = ::std::option::Option::Some(v);
}
pub fn upload_result(&self) -> u32 {
self.upload_result.unwrap_or(0)
}
pub fn clear_upload_result(&mut self) {
self.upload_result = ::std::option::Option::None;
}
pub fn has_upload_result(&self) -> bool {
self.upload_result.is_some()
}
pub fn set_upload_result(&mut self, v: u32) {
self.upload_result = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CVideo_CommitGameClipSegmentsUpload_Request {
const NAME: &'static str = "CVideo_CommitGameClipSegmentsUpload_Request";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.clip_id = ::std::option::Option::Some(is.read_uint64()?);
},
18 => {
self.component_name = ::std::option::Option::Some(is.read_string()?);
},
26 => {
self.representation_name = ::std::option::Option::Some(is.read_string()?);
},
32 => {
self.first_segment_number = ::std::option::Option::Some(is.read_uint32()?);
},
40 => {
self.num_segments = ::std::option::Option::Some(is.read_uint32()?);
},
48 => {
self.upload_result = ::std::option::Option::Some(is.read_uint32()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.clip_id {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.component_name.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
if let Some(v) = self.representation_name.as_ref() {
my_size += ::protobuf::rt::string_size(3, &v);
}
if let Some(v) = self.first_segment_number {
my_size += ::protobuf::rt::uint32_size(4, v);
}
if let Some(v) = self.num_segments {
my_size += ::protobuf::rt::uint32_size(5, v);
}
if let Some(v) = self.upload_result {
my_size += ::protobuf::rt::uint32_size(6, v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.clip_id {
os.write_uint64(1, v)?;
}
if let Some(v) = self.component_name.as_ref() {
os.write_string(2, v)?;
}
if let Some(v) = self.representation_name.as_ref() {
os.write_string(3, v)?;
}
if let Some(v) = self.first_segment_number {
os.write_uint32(4, v)?;
}
if let Some(v) = self.num_segments {
os.write_uint32(5, v)?;
}
if let Some(v) = self.upload_result {
os.write_uint32(6, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CVideo_CommitGameClipSegmentsUpload_Request {
CVideo_CommitGameClipSegmentsUpload_Request::new()
}
fn clear(&mut self) {
self.clip_id = ::std::option::Option::None;
self.component_name = ::std::option::Option::None;
self.representation_name = ::std::option::Option::None;
self.first_segment_number = ::std::option::Option::None;
self.num_segments = ::std::option::Option::None;
self.upload_result = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CVideo_CommitGameClipSegmentsUpload_Request {
static instance: CVideo_CommitGameClipSegmentsUpload_Request = CVideo_CommitGameClipSegmentsUpload_Request {
clip_id: ::std::option::Option::None,
component_name: ::std::option::Option::None,
representation_name: ::std::option::Option::None,
first_segment_number: ::std::option::Option::None,
num_segments: ::std::option::Option::None,
upload_result: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVideo_CommitGameClipSegmentsUpload_Response {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CVideo_CommitGameClipSegmentsUpload_Response {
fn default() -> &'a CVideo_CommitGameClipSegmentsUpload_Response {
<CVideo_CommitGameClipSegmentsUpload_Response as ::protobuf::Message>::default_instance()
}
}
impl CVideo_CommitGameClipSegmentsUpload_Response {
pub fn new() -> CVideo_CommitGameClipSegmentsUpload_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CVideo_CommitGameClipSegmentsUpload_Response {
const NAME: &'static str = "CVideo_CommitGameClipSegmentsUpload_Response";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CVideo_CommitGameClipSegmentsUpload_Response {
CVideo_CommitGameClipSegmentsUpload_Response::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static CVideo_CommitGameClipSegmentsUpload_Response {
static instance: CVideo_CommitGameClipSegmentsUpload_Response = CVideo_CommitGameClipSegmentsUpload_Response {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[doc = "Notification from server to client that h264 has been unlocked"]
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CVideo_UnlockedH264_Notification {
pub encryption_key: ::std::option::Option<::std::vec::Vec<u8>>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CVideo_UnlockedH264_Notification {
fn default() -> &'a CVideo_UnlockedH264_Notification {
<CVideo_UnlockedH264_Notification as ::protobuf::Message>::default_instance()
}
}
impl CVideo_UnlockedH264_Notification {
pub fn new() -> CVideo_UnlockedH264_Notification {
::std::default::Default::default()
}
pub fn encryption_key(&self) -> &[u8] {
match self.encryption_key.as_ref() {
Some(v) => v,
None => &[],
}
}
pub fn clear_encryption_key(&mut self) {
self.encryption_key = ::std::option::Option::None;
}
pub fn has_encryption_key(&self) -> bool {
self.encryption_key.is_some()
}
pub fn set_encryption_key(&mut self, v: ::std::vec::Vec<u8>) {
self.encryption_key = ::std::option::Option::Some(v);
}
pub fn mut_encryption_key(&mut self) -> &mut ::std::vec::Vec<u8> {
if self.encryption_key.is_none() {
self.encryption_key = ::std::option::Option::Some(::std::vec::Vec::new());
}
self.encryption_key.as_mut().unwrap()
}
pub fn take_encryption_key(&mut self) -> ::std::vec::Vec<u8> {
self.encryption_key.take().unwrap_or_else(|| ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for CVideo_UnlockedH264_Notification {
const NAME: &'static str = "CVideo_UnlockedH264_Notification";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.encryption_key = ::std::option::Option::Some(is.read_bytes()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.encryption_key.as_ref() {
my_size += ::protobuf::rt::bytes_size(1, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.encryption_key.as_ref() {
os.write_bytes(1, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CVideo_UnlockedH264_Notification {
CVideo_UnlockedH264_Notification::new()
}
fn clear(&mut self) {
self.encryption_key = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CVideo_UnlockedH264_Notification {
static instance: CVideo_UnlockedH264_Notification = CVideo_UnlockedH264_Notification {
encryption_key: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[doc = "Retrieve the OPF settings JSON blob. Available via the Client for 360 Player App"]
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CFovasVideo_ClientGetOPFSettings_Request {
pub app_id: ::std::option::Option<u32>,
pub client_cellid: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CFovasVideo_ClientGetOPFSettings_Request {
fn default() -> &'a CFovasVideo_ClientGetOPFSettings_Request {
<CFovasVideo_ClientGetOPFSettings_Request as ::protobuf::Message>::default_instance()
}
}
impl CFovasVideo_ClientGetOPFSettings_Request {
pub fn new() -> CFovasVideo_ClientGetOPFSettings_Request {
::std::default::Default::default()
}
pub fn app_id(&self) -> u32 {
self.app_id.unwrap_or(0)
}
pub fn clear_app_id(&mut self) {
self.app_id = ::std::option::Option::None;
}
pub fn has_app_id(&self) -> bool {
self.app_id.is_some()
}
pub fn set_app_id(&mut self, v: u32) {
self.app_id = ::std::option::Option::Some(v);
}
pub fn client_cellid(&self) -> u32 {
self.client_cellid.unwrap_or(0)
}
pub fn clear_client_cellid(&mut self) {
self.client_cellid = ::std::option::Option::None;
}
pub fn has_client_cellid(&self) -> bool {
self.client_cellid.is_some()
}
pub fn set_client_cellid(&mut self, v: u32) {
self.client_cellid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CFovasVideo_ClientGetOPFSettings_Request {
const NAME: &'static str = "CFovasVideo_ClientGetOPFSettings_Request";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.app_id = ::std::option::Option::Some(is.read_uint32()?);
},
16 => {
self.client_cellid = ::std::option::Option::Some(is.read_uint32()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.app_id {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.client_cellid {
my_size += ::protobuf::rt::uint32_size(2, v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.app_id {
os.write_uint32(1, v)?;
}
if let Some(v) = self.client_cellid {
os.write_uint32(2, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CFovasVideo_ClientGetOPFSettings_Request {
CFovasVideo_ClientGetOPFSettings_Request::new()
}
fn clear(&mut self) {
self.app_id = ::std::option::Option::None;
self.client_cellid = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CFovasVideo_ClientGetOPFSettings_Request {
static instance: CFovasVideo_ClientGetOPFSettings_Request = CFovasVideo_ClientGetOPFSettings_Request {
app_id: ::std::option::Option::None,
client_cellid: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CFovasVideo_ClientGetOPFSettings_Response {
pub app_id: ::std::option::Option<u32>,
pub opf_settings: ::std::option::Option<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CFovasVideo_ClientGetOPFSettings_Response {
fn default() -> &'a CFovasVideo_ClientGetOPFSettings_Response {
<CFovasVideo_ClientGetOPFSettings_Response as ::protobuf::Message>::default_instance()
}
}
impl CFovasVideo_ClientGetOPFSettings_Response {
pub fn new() -> CFovasVideo_ClientGetOPFSettings_Response {
::std::default::Default::default()
}
pub fn app_id(&self) -> u32 {
self.app_id.unwrap_or(0)
}
pub fn clear_app_id(&mut self) {
self.app_id = ::std::option::Option::None;
}
pub fn has_app_id(&self) -> bool {
self.app_id.is_some()
}
pub fn set_app_id(&mut self, v: u32) {
self.app_id = ::std::option::Option::Some(v);
}
pub fn opf_settings(&self) -> &str {
match self.opf_settings.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_opf_settings(&mut self) {
self.opf_settings = ::std::option::Option::None;
}
pub fn has_opf_settings(&self) -> bool {
self.opf_settings.is_some()
}
pub fn set_opf_settings(&mut self, v: ::std::string::String) {
self.opf_settings = ::std::option::Option::Some(v);
}
pub fn mut_opf_settings(&mut self) -> &mut ::std::string::String {
if self.opf_settings.is_none() {
self.opf_settings = ::std::option::Option::Some(::std::string::String::new());
}
self.opf_settings.as_mut().unwrap()
}
pub fn take_opf_settings(&mut self) -> ::std::string::String {
self.opf_settings.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for CFovasVideo_ClientGetOPFSettings_Response {
const NAME: &'static str = "CFovasVideo_ClientGetOPFSettings_Response";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.app_id = ::std::option::Option::Some(is.read_uint32()?);
},
18 => {
self.opf_settings = ::std::option::Option::Some(is.read_string()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.app_id {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.opf_settings.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.app_id {
os.write_uint32(1, v)?;
}
if let Some(v) = self.opf_settings.as_ref() {
os.write_string(2, v)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> CFovasVideo_ClientGetOPFSettings_Response {
CFovasVideo_ClientGetOPFSettings_Response::new()
}
fn clear(&mut self) {
self.app_id = ::std::option::Option::None;
self.opf_settings = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CFovasVideo_ClientGetOPFSettings_Response {
static instance: CFovasVideo_ClientGetOPFSettings_Response = CFovasVideo_ClientGetOPFSettings_Response {
app_id: ::std::option::Option::None,
opf_settings: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[allow(unused_imports)]
use crate::steammessages_base::*;
#[allow(unused_imports)]
use crate::steammessages_unified_base_steamclient::*;
impl crate::RpcMessage for CVideo_ClientGetVideoURL_Request {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for CVideo_ClientGetVideoURL_Response {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for VideoBookmark {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for CVideo_SetVideoBookmark_Notification {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for CVideo_GetVideoBookmarks_Request {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for CVideo_GetVideoBookmarks_Response {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for CVideo_GameClipRepresentation {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for CVideo_GameClipComponent {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for CVideo_CreateGameClip_Request {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for CVideo_CreateGameClip_Response {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for CVideo_GameClipSegmentInfo {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for CVideo_BeginGameClipSegmentsUpload_Request {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for CVideo_GameClipSegmentUploadInfo {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for CVideo_BeginGameClipSegmentsUpload_Response {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for CVideo_CommitGameClipSegmentsUpload_Request {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for CVideo_CommitGameClipSegmentsUpload_Response {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for CVideo_UnlockedH264_Notification {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for CFovasVideo_ClientGetOPFSettings_Request {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
impl crate::RpcMessage for CFovasVideo_ClientGetOPFSettings_Response {
fn parse(reader: &mut dyn std::io::Read) -> protobuf::Result<Self> {
<Self as protobuf::Message>::parse_from_reader(reader)
}
fn write(&self, writer: &mut dyn std::io::Write) -> protobuf::Result<()> {
use protobuf::Message;
self.write_to_writer(writer)
}
fn encode_size(&self) -> usize {
use protobuf::Message;
self.compute_size() as usize
}
}
struct Video {}
impl crate::RpcService for Video {
const SERVICE_NAME: &'static str = "Video";
}
struct VideoClient {}
impl crate::RpcService for VideoClient {
const SERVICE_NAME: &'static str = "VideoClient";
}
struct FovasVideo {}
impl crate::RpcService for FovasVideo {
const SERVICE_NAME: &'static str = "FovasVideo";
}
impl crate::RpcMethod for CFovasVideo_ClientGetOPFSettings_Request {
const METHOD_NAME: &'static str = "FovasVideo.ClientGetOPFSettings#1";
type Response = CFovasVideo_ClientGetOPFSettings_Response;
}
impl crate::RpcMethod for CVideo_BeginGameClipSegmentsUpload_Request {
const METHOD_NAME: &'static str = "Video.BeginGameClipSegmentsUpload#1";
type Response = CVideo_BeginGameClipSegmentsUpload_Response;
}
impl crate::RpcMethod for CVideo_ClientGetVideoURL_Request {
const METHOD_NAME: &'static str = "Video.ClientGetVideoURL#1";
type Response = CVideo_ClientGetVideoURL_Response;
}
impl crate::RpcMethod for CVideo_CommitGameClipSegmentsUpload_Request {
const METHOD_NAME: &'static str = "Video.CommitGameClipSegmentsUpload#1";
type Response = CVideo_CommitGameClipSegmentsUpload_Response;
}
impl crate::RpcMethod for CVideo_CreateGameClip_Request {
const METHOD_NAME: &'static str = "Video.CreateGameClip#1";
type Response = CVideo_CreateGameClip_Response;
}
impl crate::RpcMethod for CVideo_GetVideoBookmarks_Request {
const METHOD_NAME: &'static str = "Video.GetVideoBookmarks#1";
type Response = CVideo_GetVideoBookmarks_Response;
}
impl crate::RpcMethod for CVideo_SetVideoBookmark_Notification {
const METHOD_NAME: &'static str = "Video.SetVideoBookmark#1";
type Response = ();
}
impl crate::RpcMethod for CVideo_UnlockedH264_Notification {
const METHOD_NAME: &'static str = "VideoClient.NotifyUnlockedH264#1";
type Response = ();
}