#![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_2_0;
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "User wants to vote on the item"]
pub struct CPublishedFile_Vote_Request {
pub publishedfileid: ::std::option::Option<u64>,
pub vote_up: ::std::option::Option<bool>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_Vote_Request {
fn default() -> &'a CPublishedFile_Vote_Request {
<CPublishedFile_Vote_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_Vote_Request {
pub fn new() -> CPublishedFile_Vote_Request {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
pub fn vote_up(&self) -> bool {
self.vote_up.unwrap_or(false)
}
pub fn clear_vote_up(&mut self) {
self.vote_up = ::std::option::Option::None;
}
pub fn has_vote_up(&self) -> bool {
self.vote_up.is_some()
}
pub fn set_vote_up(&mut self, v: bool) {
self.vote_up = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_Vote_Request {
const NAME: &'static str = "CPublishedFile_Vote_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.publishedfileid = ::std::option::Option::Some(is.read_uint64()?);
},
16 => {
self.vote_up = ::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.publishedfileid {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.vote_up {
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.publishedfileid {
os.write_uint64(1, v)?;
}
if let Some(v) = self.vote_up {
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() -> CPublishedFile_Vote_Request {
CPublishedFile_Vote_Request::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.vote_up = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_Vote_Request {
static instance: CPublishedFile_Vote_Request = CPublishedFile_Vote_Request {
publishedfileid: ::std::option::Option::None,
vote_up: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_Vote_Response {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_Vote_Response {
fn default() -> &'a CPublishedFile_Vote_Response {
<CPublishedFile_Vote_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_Vote_Response {
pub fn new() -> CPublishedFile_Vote_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_Vote_Response {
const NAME: &'static str = "CPublishedFile_Vote_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() -> CPublishedFile_Vote_Response {
CPublishedFile_Vote_Response::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_Vote_Response {
static instance: CPublishedFile_Vote_Response = CPublishedFile_Vote_Response {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Subscribes the user to the published file"]
pub struct CPublishedFile_Subscribe_Request {
pub publishedfileid: ::std::option::Option<u64>,
pub list_type: ::std::option::Option<u32>,
pub appid: ::std::option::Option<i32>,
pub notify_client: ::std::option::Option<bool>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_Subscribe_Request {
fn default() -> &'a CPublishedFile_Subscribe_Request {
<CPublishedFile_Subscribe_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_Subscribe_Request {
pub fn new() -> CPublishedFile_Subscribe_Request {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
pub fn list_type(&self) -> u32 {
self.list_type.unwrap_or(0)
}
pub fn clear_list_type(&mut self) {
self.list_type = ::std::option::Option::None;
}
pub fn has_list_type(&self) -> bool {
self.list_type.is_some()
}
pub fn set_list_type(&mut self, v: u32) {
self.list_type = ::std::option::Option::Some(v);
}
pub fn appid(&self) -> i32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: i32) {
self.appid = ::std::option::Option::Some(v);
}
pub fn notify_client(&self) -> bool {
self.notify_client.unwrap_or(false)
}
pub fn clear_notify_client(&mut self) {
self.notify_client = ::std::option::Option::None;
}
pub fn has_notify_client(&self) -> bool {
self.notify_client.is_some()
}
pub fn set_notify_client(&mut self, v: bool) {
self.notify_client = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_Subscribe_Request {
const NAME: &'static str = "CPublishedFile_Subscribe_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.publishedfileid = ::std::option::Option::Some(is.read_uint64()?);
},
16 => {
self.list_type = ::std::option::Option::Some(is.read_uint32()?);
},
24 => {
self.appid = ::std::option::Option::Some(is.read_int32()?);
},
32 => {
self.notify_client = ::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.publishedfileid {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.list_type {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.appid {
my_size += ::protobuf::rt::int32_size(3, v);
}
if let Some(v) = self.notify_client {
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.publishedfileid {
os.write_uint64(1, v)?;
}
if let Some(v) = self.list_type {
os.write_uint32(2, v)?;
}
if let Some(v) = self.appid {
os.write_int32(3, v)?;
}
if let Some(v) = self.notify_client {
os.write_bool(4, 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() -> CPublishedFile_Subscribe_Request {
CPublishedFile_Subscribe_Request::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.list_type = ::std::option::Option::None;
self.appid = ::std::option::Option::None;
self.notify_client = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_Subscribe_Request {
static instance: CPublishedFile_Subscribe_Request = CPublishedFile_Subscribe_Request {
publishedfileid: ::std::option::Option::None,
list_type: ::std::option::Option::None,
appid: ::std::option::Option::None,
notify_client: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_Subscribe_Response {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_Subscribe_Response {
fn default() -> &'a CPublishedFile_Subscribe_Response {
<CPublishedFile_Subscribe_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_Subscribe_Response {
pub fn new() -> CPublishedFile_Subscribe_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_Subscribe_Response {
const NAME: &'static str = "CPublishedFile_Subscribe_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() -> CPublishedFile_Subscribe_Response {
CPublishedFile_Subscribe_Response::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_Subscribe_Response {
static instance: CPublishedFile_Subscribe_Response = CPublishedFile_Subscribe_Response {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Unsubscribes the user from the published file"]
pub struct CPublishedFile_Unsubscribe_Request {
pub publishedfileid: ::std::option::Option<u64>,
pub list_type: ::std::option::Option<u32>,
pub appid: ::std::option::Option<i32>,
pub notify_client: ::std::option::Option<bool>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_Unsubscribe_Request {
fn default() -> &'a CPublishedFile_Unsubscribe_Request {
<CPublishedFile_Unsubscribe_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_Unsubscribe_Request {
pub fn new() -> CPublishedFile_Unsubscribe_Request {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
pub fn list_type(&self) -> u32 {
self.list_type.unwrap_or(0)
}
pub fn clear_list_type(&mut self) {
self.list_type = ::std::option::Option::None;
}
pub fn has_list_type(&self) -> bool {
self.list_type.is_some()
}
pub fn set_list_type(&mut self, v: u32) {
self.list_type = ::std::option::Option::Some(v);
}
pub fn appid(&self) -> i32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: i32) {
self.appid = ::std::option::Option::Some(v);
}
pub fn notify_client(&self) -> bool {
self.notify_client.unwrap_or(false)
}
pub fn clear_notify_client(&mut self) {
self.notify_client = ::std::option::Option::None;
}
pub fn has_notify_client(&self) -> bool {
self.notify_client.is_some()
}
pub fn set_notify_client(&mut self, v: bool) {
self.notify_client = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_Unsubscribe_Request {
const NAME: &'static str = "CPublishedFile_Unsubscribe_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.publishedfileid = ::std::option::Option::Some(is.read_uint64()?);
},
16 => {
self.list_type = ::std::option::Option::Some(is.read_uint32()?);
},
24 => {
self.appid = ::std::option::Option::Some(is.read_int32()?);
},
32 => {
self.notify_client = ::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.publishedfileid {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.list_type {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.appid {
my_size += ::protobuf::rt::int32_size(3, v);
}
if let Some(v) = self.notify_client {
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.publishedfileid {
os.write_uint64(1, v)?;
}
if let Some(v) = self.list_type {
os.write_uint32(2, v)?;
}
if let Some(v) = self.appid {
os.write_int32(3, v)?;
}
if let Some(v) = self.notify_client {
os.write_bool(4, 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() -> CPublishedFile_Unsubscribe_Request {
CPublishedFile_Unsubscribe_Request::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.list_type = ::std::option::Option::None;
self.appid = ::std::option::Option::None;
self.notify_client = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_Unsubscribe_Request {
static instance: CPublishedFile_Unsubscribe_Request = CPublishedFile_Unsubscribe_Request {
publishedfileid: ::std::option::Option::None,
list_type: ::std::option::Option::None,
appid: ::std::option::Option::None,
notify_client: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_Unsubscribe_Response {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_Unsubscribe_Response {
fn default() -> &'a CPublishedFile_Unsubscribe_Response {
<CPublishedFile_Unsubscribe_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_Unsubscribe_Response {
pub fn new() -> CPublishedFile_Unsubscribe_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_Unsubscribe_Response {
const NAME: &'static str = "CPublishedFile_Unsubscribe_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() -> CPublishedFile_Unsubscribe_Response {
CPublishedFile_Unsubscribe_Response::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_Unsubscribe_Response {
static instance: CPublishedFile_Unsubscribe_Response = CPublishedFile_Unsubscribe_Response {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Check if the user can subscribe to the published file"]
pub struct CPublishedFile_CanSubscribe_Request {
pub publishedfileid: ::std::option::Option<u64>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_CanSubscribe_Request {
fn default() -> &'a CPublishedFile_CanSubscribe_Request {
<CPublishedFile_CanSubscribe_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_CanSubscribe_Request {
pub fn new() -> CPublishedFile_CanSubscribe_Request {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_CanSubscribe_Request {
const NAME: &'static str = "CPublishedFile_CanSubscribe_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.publishedfileid = ::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.publishedfileid {
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.publishedfileid {
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() -> CPublishedFile_CanSubscribe_Request {
CPublishedFile_CanSubscribe_Request::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_CanSubscribe_Request {
static instance: CPublishedFile_CanSubscribe_Request = CPublishedFile_CanSubscribe_Request {
publishedfileid: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_CanSubscribe_Response {
pub can_subscribe: ::std::option::Option<bool>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_CanSubscribe_Response {
fn default() -> &'a CPublishedFile_CanSubscribe_Response {
<CPublishedFile_CanSubscribe_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_CanSubscribe_Response {
pub fn new() -> CPublishedFile_CanSubscribe_Response {
::std::default::Default::default()
}
pub fn can_subscribe(&self) -> bool {
self.can_subscribe.unwrap_or(false)
}
pub fn clear_can_subscribe(&mut self) {
self.can_subscribe = ::std::option::Option::None;
}
pub fn has_can_subscribe(&self) -> bool {
self.can_subscribe.is_some()
}
pub fn set_can_subscribe(&mut self, v: bool) {
self.can_subscribe = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_CanSubscribe_Response {
const NAME: &'static str = "CPublishedFile_CanSubscribe_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.can_subscribe = ::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.can_subscribe {
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.can_subscribe {
os.write_bool(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() -> CPublishedFile_CanSubscribe_Response {
CPublishedFile_CanSubscribe_Response::new()
}
fn clear(&mut self) {
self.can_subscribe = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_CanSubscribe_Response {
static instance: CPublishedFile_CanSubscribe_Response = CPublishedFile_CanSubscribe_Response {
can_subscribe: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Get sub section data (for table of contents, a specific section, or all)"]
pub struct CPublishedFile_GetSubSectionData_Request {
pub publishedfileid: ::std::option::Option<u64>,
pub for_table_of_contents: ::std::option::Option<bool>,
pub specific_sectionid: ::std::option::Option<u64>,
pub desired_revision: ::std::option::Option<::protobuf::EnumOrUnknown<EPublishedFileRevision>>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetSubSectionData_Request {
fn default() -> &'a CPublishedFile_GetSubSectionData_Request {
<CPublishedFile_GetSubSectionData_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetSubSectionData_Request {
pub fn new() -> CPublishedFile_GetSubSectionData_Request {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
pub fn for_table_of_contents(&self) -> bool {
self.for_table_of_contents.unwrap_or(false)
}
pub fn clear_for_table_of_contents(&mut self) {
self.for_table_of_contents = ::std::option::Option::None;
}
pub fn has_for_table_of_contents(&self) -> bool {
self.for_table_of_contents.is_some()
}
pub fn set_for_table_of_contents(&mut self, v: bool) {
self.for_table_of_contents = ::std::option::Option::Some(v);
}
pub fn specific_sectionid(&self) -> u64 {
self.specific_sectionid.unwrap_or(0)
}
pub fn clear_specific_sectionid(&mut self) {
self.specific_sectionid = ::std::option::Option::None;
}
pub fn has_specific_sectionid(&self) -> bool {
self.specific_sectionid.is_some()
}
pub fn set_specific_sectionid(&mut self, v: u64) {
self.specific_sectionid = ::std::option::Option::Some(v);
}
pub fn desired_revision(&self) -> EPublishedFileRevision {
match self.desired_revision {
Some(e) => e.enum_value_or(EPublishedFileRevision::k_EPublishedFileRevision_Default),
None => EPublishedFileRevision::k_EPublishedFileRevision_Default,
}
}
pub fn clear_desired_revision(&mut self) {
self.desired_revision = ::std::option::Option::None;
}
pub fn has_desired_revision(&self) -> bool {
self.desired_revision.is_some()
}
pub fn set_desired_revision(&mut self, v: EPublishedFileRevision) {
self.desired_revision = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
}
}
impl ::protobuf::Message for CPublishedFile_GetSubSectionData_Request {
const NAME: &'static str = "CPublishedFile_GetSubSectionData_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.publishedfileid = ::std::option::Option::Some(is.read_uint64()?);
},
16 => {
self.for_table_of_contents = ::std::option::Option::Some(is.read_bool()?);
},
24 => {
self.specific_sectionid = ::std::option::Option::Some(is.read_uint64()?);
},
32 => {
self.desired_revision = ::std::option::Option::Some(is.read_enum_or_unknown()?);
},
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.publishedfileid {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.for_table_of_contents {
my_size += 1 + 1;
}
if let Some(v) = self.specific_sectionid {
my_size += ::protobuf::rt::uint64_size(3, v);
}
if let Some(v) = self.desired_revision {
my_size += ::protobuf::rt::int32_size(4, v.value());
}
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.publishedfileid {
os.write_uint64(1, v)?;
}
if let Some(v) = self.for_table_of_contents {
os.write_bool(2, v)?;
}
if let Some(v) = self.specific_sectionid {
os.write_uint64(3, v)?;
}
if let Some(v) = self.desired_revision {
os.write_enum(4, ::protobuf::EnumOrUnknown::value(&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() -> CPublishedFile_GetSubSectionData_Request {
CPublishedFile_GetSubSectionData_Request::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.for_table_of_contents = ::std::option::Option::None;
self.specific_sectionid = ::std::option::Option::None;
self.desired_revision = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetSubSectionData_Request {
static instance: CPublishedFile_GetSubSectionData_Request = CPublishedFile_GetSubSectionData_Request {
publishedfileid: ::std::option::Option::None,
for_table_of_contents: ::std::option::Option::None,
specific_sectionid: ::std::option::Option::None,
desired_revision: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PublishedFileSubSection {
pub sectionid: ::std::option::Option<u64>,
pub title: ::std::option::Option<::std::string::String>,
pub description_text: ::std::option::Option<::std::string::String>,
pub sort_order: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a PublishedFileSubSection {
fn default() -> &'a PublishedFileSubSection {
<PublishedFileSubSection as ::protobuf::Message>::default_instance()
}
}
impl PublishedFileSubSection {
pub fn new() -> PublishedFileSubSection {
::std::default::Default::default()
}
pub fn sectionid(&self) -> u64 {
self.sectionid.unwrap_or(0)
}
pub fn clear_sectionid(&mut self) {
self.sectionid = ::std::option::Option::None;
}
pub fn has_sectionid(&self) -> bool {
self.sectionid.is_some()
}
pub fn set_sectionid(&mut self, v: u64) {
self.sectionid = ::std::option::Option::Some(v);
}
pub fn title(&self) -> &str {
match self.title.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_title(&mut self) {
self.title = ::std::option::Option::None;
}
pub fn has_title(&self) -> bool {
self.title.is_some()
}
pub fn set_title(&mut self, v: ::std::string::String) {
self.title = ::std::option::Option::Some(v);
}
pub fn mut_title(&mut self) -> &mut ::std::string::String {
if self.title.is_none() {
self.title = ::std::option::Option::Some(::std::string::String::new());
}
self.title.as_mut().unwrap()
}
pub fn take_title(&mut self) -> ::std::string::String {
self.title.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn description_text(&self) -> &str {
match self.description_text.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_description_text(&mut self) {
self.description_text = ::std::option::Option::None;
}
pub fn has_description_text(&self) -> bool {
self.description_text.is_some()
}
pub fn set_description_text(&mut self, v: ::std::string::String) {
self.description_text = ::std::option::Option::Some(v);
}
pub fn mut_description_text(&mut self) -> &mut ::std::string::String {
if self.description_text.is_none() {
self.description_text = ::std::option::Option::Some(::std::string::String::new());
}
self.description_text.as_mut().unwrap()
}
pub fn take_description_text(&mut self) -> ::std::string::String {
self.description_text.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn sort_order(&self) -> u32 {
self.sort_order.unwrap_or(0)
}
pub fn clear_sort_order(&mut self) {
self.sort_order = ::std::option::Option::None;
}
pub fn has_sort_order(&self) -> bool {
self.sort_order.is_some()
}
pub fn set_sort_order(&mut self, v: u32) {
self.sort_order = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for PublishedFileSubSection {
const NAME: &'static str = "PublishedFileSubSection";
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.sectionid = ::std::option::Option::Some(is.read_uint64()?);
},
18 => {
self.title = ::std::option::Option::Some(is.read_string()?);
},
26 => {
self.description_text = ::std::option::Option::Some(is.read_string()?);
},
32 => {
self.sort_order = ::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.sectionid {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.title.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
if let Some(v) = self.description_text.as_ref() {
my_size += ::protobuf::rt::string_size(3, &v);
}
if let Some(v) = self.sort_order {
my_size += ::protobuf::rt::uint32_size(4, 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.sectionid {
os.write_uint64(1, v)?;
}
if let Some(v) = self.title.as_ref() {
os.write_string(2, v)?;
}
if let Some(v) = self.description_text.as_ref() {
os.write_string(3, v)?;
}
if let Some(v) = self.sort_order {
os.write_uint32(4, 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() -> PublishedFileSubSection {
PublishedFileSubSection::new()
}
fn clear(&mut self) {
self.sectionid = ::std::option::Option::None;
self.title = ::std::option::Option::None;
self.description_text = ::std::option::Option::None;
self.sort_order = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static PublishedFileSubSection {
static instance: PublishedFileSubSection = PublishedFileSubSection {
sectionid: ::std::option::Option::None,
title: ::std::option::Option::None,
description_text: ::std::option::Option::None,
sort_order: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_GetSubSectionData_Response {
pub sub_sections: ::std::vec::Vec<PublishedFileSubSection>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetSubSectionData_Response {
fn default() -> &'a CPublishedFile_GetSubSectionData_Response {
<CPublishedFile_GetSubSectionData_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetSubSectionData_Response {
pub fn new() -> CPublishedFile_GetSubSectionData_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_GetSubSectionData_Response {
const NAME: &'static str = "CPublishedFile_GetSubSectionData_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.sub_sections.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.sub_sections {
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.sub_sections {
::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() -> CPublishedFile_GetSubSectionData_Response {
CPublishedFile_GetSubSectionData_Response::new()
}
fn clear(&mut self) {
self.sub_sections.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetSubSectionData_Response {
static instance: CPublishedFile_GetSubSectionData_Response = CPublishedFile_GetSubSectionData_Response {
sub_sections: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Publishes a clouded user file to the Workshop."]
pub struct CPublishedFile_Publish_Request {
pub appid: ::std::option::Option<u32>,
pub consumer_appid: ::std::option::Option<u32>,
pub cloudfilename: ::std::option::Option<::std::string::String>,
pub preview_cloudfilename: ::std::option::Option<::std::string::String>,
pub title: ::std::option::Option<::std::string::String>,
pub file_description: ::std::option::Option<::std::string::String>,
pub file_type: ::std::option::Option<u32>,
pub consumer_shortcut_name: ::std::option::Option<::std::string::String>,
pub youtube_username: ::std::option::Option<::std::string::String>,
pub youtube_videoid: ::std::option::Option<::std::string::String>,
pub visibility: ::std::option::Option<u32>,
pub redirect_uri: ::std::option::Option<::std::string::String>,
pub tags: ::std::vec::Vec<::std::string::String>,
pub collection_type: ::std::option::Option<::std::string::String>,
pub game_type: ::std::option::Option<::std::string::String>,
pub url: ::std::option::Option<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_Publish_Request {
fn default() -> &'a CPublishedFile_Publish_Request {
<CPublishedFile_Publish_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_Publish_Request {
pub fn new() -> CPublishedFile_Publish_Request {
::std::default::Default::default()
}
pub fn appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
pub fn consumer_appid(&self) -> u32 {
self.consumer_appid.unwrap_or(0)
}
pub fn clear_consumer_appid(&mut self) {
self.consumer_appid = ::std::option::Option::None;
}
pub fn has_consumer_appid(&self) -> bool {
self.consumer_appid.is_some()
}
pub fn set_consumer_appid(&mut self, v: u32) {
self.consumer_appid = ::std::option::Option::Some(v);
}
pub fn cloudfilename(&self) -> &str {
match self.cloudfilename.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_cloudfilename(&mut self) {
self.cloudfilename = ::std::option::Option::None;
}
pub fn has_cloudfilename(&self) -> bool {
self.cloudfilename.is_some()
}
pub fn set_cloudfilename(&mut self, v: ::std::string::String) {
self.cloudfilename = ::std::option::Option::Some(v);
}
pub fn mut_cloudfilename(&mut self) -> &mut ::std::string::String {
if self.cloudfilename.is_none() {
self.cloudfilename = ::std::option::Option::Some(::std::string::String::new());
}
self.cloudfilename.as_mut().unwrap()
}
pub fn take_cloudfilename(&mut self) -> ::std::string::String {
self.cloudfilename.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn preview_cloudfilename(&self) -> &str {
match self.preview_cloudfilename.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_preview_cloudfilename(&mut self) {
self.preview_cloudfilename = ::std::option::Option::None;
}
pub fn has_preview_cloudfilename(&self) -> bool {
self.preview_cloudfilename.is_some()
}
pub fn set_preview_cloudfilename(&mut self, v: ::std::string::String) {
self.preview_cloudfilename = ::std::option::Option::Some(v);
}
pub fn mut_preview_cloudfilename(&mut self) -> &mut ::std::string::String {
if self.preview_cloudfilename.is_none() {
self.preview_cloudfilename = ::std::option::Option::Some(::std::string::String::new());
}
self.preview_cloudfilename.as_mut().unwrap()
}
pub fn take_preview_cloudfilename(&mut self) -> ::std::string::String {
self.preview_cloudfilename.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn title(&self) -> &str {
match self.title.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_title(&mut self) {
self.title = ::std::option::Option::None;
}
pub fn has_title(&self) -> bool {
self.title.is_some()
}
pub fn set_title(&mut self, v: ::std::string::String) {
self.title = ::std::option::Option::Some(v);
}
pub fn mut_title(&mut self) -> &mut ::std::string::String {
if self.title.is_none() {
self.title = ::std::option::Option::Some(::std::string::String::new());
}
self.title.as_mut().unwrap()
}
pub fn take_title(&mut self) -> ::std::string::String {
self.title.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn file_description(&self) -> &str {
match self.file_description.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_file_description(&mut self) {
self.file_description = ::std::option::Option::None;
}
pub fn has_file_description(&self) -> bool {
self.file_description.is_some()
}
pub fn set_file_description(&mut self, v: ::std::string::String) {
self.file_description = ::std::option::Option::Some(v);
}
pub fn mut_file_description(&mut self) -> &mut ::std::string::String {
if self.file_description.is_none() {
self.file_description = ::std::option::Option::Some(::std::string::String::new());
}
self.file_description.as_mut().unwrap()
}
pub fn take_file_description(&mut self) -> ::std::string::String {
self.file_description.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn file_type(&self) -> u32 {
self.file_type.unwrap_or(0)
}
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: u32) {
self.file_type = ::std::option::Option::Some(v);
}
pub fn consumer_shortcut_name(&self) -> &str {
match self.consumer_shortcut_name.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_consumer_shortcut_name(&mut self) {
self.consumer_shortcut_name = ::std::option::Option::None;
}
pub fn has_consumer_shortcut_name(&self) -> bool {
self.consumer_shortcut_name.is_some()
}
pub fn set_consumer_shortcut_name(&mut self, v: ::std::string::String) {
self.consumer_shortcut_name = ::std::option::Option::Some(v);
}
pub fn mut_consumer_shortcut_name(&mut self) -> &mut ::std::string::String {
if self.consumer_shortcut_name.is_none() {
self.consumer_shortcut_name = ::std::option::Option::Some(::std::string::String::new());
}
self.consumer_shortcut_name.as_mut().unwrap()
}
pub fn take_consumer_shortcut_name(&mut self) -> ::std::string::String {
self.consumer_shortcut_name.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn youtube_username(&self) -> &str {
match self.youtube_username.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_youtube_username(&mut self) {
self.youtube_username = ::std::option::Option::None;
}
pub fn has_youtube_username(&self) -> bool {
self.youtube_username.is_some()
}
pub fn set_youtube_username(&mut self, v: ::std::string::String) {
self.youtube_username = ::std::option::Option::Some(v);
}
pub fn mut_youtube_username(&mut self) -> &mut ::std::string::String {
if self.youtube_username.is_none() {
self.youtube_username = ::std::option::Option::Some(::std::string::String::new());
}
self.youtube_username.as_mut().unwrap()
}
pub fn take_youtube_username(&mut self) -> ::std::string::String {
self.youtube_username.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn youtube_videoid(&self) -> &str {
match self.youtube_videoid.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_youtube_videoid(&mut self) {
self.youtube_videoid = ::std::option::Option::None;
}
pub fn has_youtube_videoid(&self) -> bool {
self.youtube_videoid.is_some()
}
pub fn set_youtube_videoid(&mut self, v: ::std::string::String) {
self.youtube_videoid = ::std::option::Option::Some(v);
}
pub fn mut_youtube_videoid(&mut self) -> &mut ::std::string::String {
if self.youtube_videoid.is_none() {
self.youtube_videoid = ::std::option::Option::Some(::std::string::String::new());
}
self.youtube_videoid.as_mut().unwrap()
}
pub fn take_youtube_videoid(&mut self) -> ::std::string::String {
self.youtube_videoid.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn visibility(&self) -> u32 {
self.visibility.unwrap_or(0)
}
pub fn clear_visibility(&mut self) {
self.visibility = ::std::option::Option::None;
}
pub fn has_visibility(&self) -> bool {
self.visibility.is_some()
}
pub fn set_visibility(&mut self, v: u32) {
self.visibility = ::std::option::Option::Some(v);
}
pub fn redirect_uri(&self) -> &str {
match self.redirect_uri.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_redirect_uri(&mut self) {
self.redirect_uri = ::std::option::Option::None;
}
pub fn has_redirect_uri(&self) -> bool {
self.redirect_uri.is_some()
}
pub fn set_redirect_uri(&mut self, v: ::std::string::String) {
self.redirect_uri = ::std::option::Option::Some(v);
}
pub fn mut_redirect_uri(&mut self) -> &mut ::std::string::String {
if self.redirect_uri.is_none() {
self.redirect_uri = ::std::option::Option::Some(::std::string::String::new());
}
self.redirect_uri.as_mut().unwrap()
}
pub fn take_redirect_uri(&mut self) -> ::std::string::String {
self.redirect_uri.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn collection_type(&self) -> &str {
match self.collection_type.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_collection_type(&mut self) {
self.collection_type = ::std::option::Option::None;
}
pub fn has_collection_type(&self) -> bool {
self.collection_type.is_some()
}
pub fn set_collection_type(&mut self, v: ::std::string::String) {
self.collection_type = ::std::option::Option::Some(v);
}
pub fn mut_collection_type(&mut self) -> &mut ::std::string::String {
if self.collection_type.is_none() {
self.collection_type = ::std::option::Option::Some(::std::string::String::new());
}
self.collection_type.as_mut().unwrap()
}
pub fn take_collection_type(&mut self) -> ::std::string::String {
self.collection_type.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn game_type(&self) -> &str {
match self.game_type.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_game_type(&mut self) {
self.game_type = ::std::option::Option::None;
}
pub fn has_game_type(&self) -> bool {
self.game_type.is_some()
}
pub fn set_game_type(&mut self, v: ::std::string::String) {
self.game_type = ::std::option::Option::Some(v);
}
pub fn mut_game_type(&mut self) -> &mut ::std::string::String {
if self.game_type.is_none() {
self.game_type = ::std::option::Option::Some(::std::string::String::new());
}
self.game_type.as_mut().unwrap()
}
pub fn take_game_type(&mut self) -> ::std::string::String {
self.game_type.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn url(&self) -> &str {
match self.url.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_url(&mut self) {
self.url = ::std::option::Option::None;
}
pub fn has_url(&self) -> bool {
self.url.is_some()
}
pub fn set_url(&mut self, v: ::std::string::String) {
self.url = ::std::option::Option::Some(v);
}
pub fn mut_url(&mut self) -> &mut ::std::string::String {
if self.url.is_none() {
self.url = ::std::option::Option::Some(::std::string::String::new());
}
self.url.as_mut().unwrap()
}
pub fn take_url(&mut self) -> ::std::string::String {
self.url.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for CPublishedFile_Publish_Request {
const NAME: &'static str = "CPublishedFile_Publish_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.appid = ::std::option::Option::Some(is.read_uint32()?);
},
16 => {
self.consumer_appid = ::std::option::Option::Some(is.read_uint32()?);
},
26 => {
self.cloudfilename = ::std::option::Option::Some(is.read_string()?);
},
34 => {
self.preview_cloudfilename = ::std::option::Option::Some(is.read_string()?);
},
42 => {
self.title = ::std::option::Option::Some(is.read_string()?);
},
50 => {
self.file_description = ::std::option::Option::Some(is.read_string()?);
},
56 => {
self.file_type = ::std::option::Option::Some(is.read_uint32()?);
},
66 => {
self.consumer_shortcut_name = ::std::option::Option::Some(is.read_string()?);
},
74 => {
self.youtube_username = ::std::option::Option::Some(is.read_string()?);
},
82 => {
self.youtube_videoid = ::std::option::Option::Some(is.read_string()?);
},
88 => {
self.visibility = ::std::option::Option::Some(is.read_uint32()?);
},
98 => {
self.redirect_uri = ::std::option::Option::Some(is.read_string()?);
},
106 => {
self.tags.push(is.read_string()?);
},
114 => {
self.collection_type = ::std::option::Option::Some(is.read_string()?);
},
122 => {
self.game_type = ::std::option::Option::Some(is.read_string()?);
},
130 => {
self.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.appid {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.consumer_appid {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.cloudfilename.as_ref() {
my_size += ::protobuf::rt::string_size(3, &v);
}
if let Some(v) = self.preview_cloudfilename.as_ref() {
my_size += ::protobuf::rt::string_size(4, &v);
}
if let Some(v) = self.title.as_ref() {
my_size += ::protobuf::rt::string_size(5, &v);
}
if let Some(v) = self.file_description.as_ref() {
my_size += ::protobuf::rt::string_size(6, &v);
}
if let Some(v) = self.file_type {
my_size += ::protobuf::rt::uint32_size(7, v);
}
if let Some(v) = self.consumer_shortcut_name.as_ref() {
my_size += ::protobuf::rt::string_size(8, &v);
}
if let Some(v) = self.youtube_username.as_ref() {
my_size += ::protobuf::rt::string_size(9, &v);
}
if let Some(v) = self.youtube_videoid.as_ref() {
my_size += ::protobuf::rt::string_size(10, &v);
}
if let Some(v) = self.visibility {
my_size += ::protobuf::rt::uint32_size(11, v);
}
if let Some(v) = self.redirect_uri.as_ref() {
my_size += ::protobuf::rt::string_size(12, &v);
}
for value in &self.tags {
my_size += ::protobuf::rt::string_size(13, &value);
};
if let Some(v) = self.collection_type.as_ref() {
my_size += ::protobuf::rt::string_size(14, &v);
}
if let Some(v) = self.game_type.as_ref() {
my_size += ::protobuf::rt::string_size(15, &v);
}
if let Some(v) = self.url.as_ref() {
my_size += ::protobuf::rt::string_size(16, &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.appid {
os.write_uint32(1, v)?;
}
if let Some(v) = self.consumer_appid {
os.write_uint32(2, v)?;
}
if let Some(v) = self.cloudfilename.as_ref() {
os.write_string(3, v)?;
}
if let Some(v) = self.preview_cloudfilename.as_ref() {
os.write_string(4, v)?;
}
if let Some(v) = self.title.as_ref() {
os.write_string(5, v)?;
}
if let Some(v) = self.file_description.as_ref() {
os.write_string(6, v)?;
}
if let Some(v) = self.file_type {
os.write_uint32(7, v)?;
}
if let Some(v) = self.consumer_shortcut_name.as_ref() {
os.write_string(8, v)?;
}
if let Some(v) = self.youtube_username.as_ref() {
os.write_string(9, v)?;
}
if let Some(v) = self.youtube_videoid.as_ref() {
os.write_string(10, v)?;
}
if let Some(v) = self.visibility {
os.write_uint32(11, v)?;
}
if let Some(v) = self.redirect_uri.as_ref() {
os.write_string(12, v)?;
}
for v in &self.tags {
os.write_string(13, &v)?;
};
if let Some(v) = self.collection_type.as_ref() {
os.write_string(14, v)?;
}
if let Some(v) = self.game_type.as_ref() {
os.write_string(15, v)?;
}
if let Some(v) = self.url.as_ref() {
os.write_string(16, 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() -> CPublishedFile_Publish_Request {
CPublishedFile_Publish_Request::new()
}
fn clear(&mut self) {
self.appid = ::std::option::Option::None;
self.consumer_appid = ::std::option::Option::None;
self.cloudfilename = ::std::option::Option::None;
self.preview_cloudfilename = ::std::option::Option::None;
self.title = ::std::option::Option::None;
self.file_description = ::std::option::Option::None;
self.file_type = ::std::option::Option::None;
self.consumer_shortcut_name = ::std::option::Option::None;
self.youtube_username = ::std::option::Option::None;
self.youtube_videoid = ::std::option::Option::None;
self.visibility = ::std::option::Option::None;
self.redirect_uri = ::std::option::Option::None;
self.tags.clear();
self.collection_type = ::std::option::Option::None;
self.game_type = ::std::option::Option::None;
self.url = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_Publish_Request {
static instance: CPublishedFile_Publish_Request = CPublishedFile_Publish_Request {
appid: ::std::option::Option::None,
consumer_appid: ::std::option::Option::None,
cloudfilename: ::std::option::Option::None,
preview_cloudfilename: ::std::option::Option::None,
title: ::std::option::Option::None,
file_description: ::std::option::Option::None,
file_type: ::std::option::Option::None,
consumer_shortcut_name: ::std::option::Option::None,
youtube_username: ::std::option::Option::None,
youtube_videoid: ::std::option::Option::None,
visibility: ::std::option::Option::None,
redirect_uri: ::std::option::Option::None,
tags: ::std::vec::Vec::new(),
collection_type: ::std::option::Option::None,
game_type: ::std::option::Option::None,
url: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_Publish_Response {
pub publishedfileid: ::std::option::Option<u64>,
pub redirect_uri: ::std::option::Option<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_Publish_Response {
fn default() -> &'a CPublishedFile_Publish_Response {
<CPublishedFile_Publish_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_Publish_Response {
pub fn new() -> CPublishedFile_Publish_Response {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
pub fn redirect_uri(&self) -> &str {
match self.redirect_uri.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_redirect_uri(&mut self) {
self.redirect_uri = ::std::option::Option::None;
}
pub fn has_redirect_uri(&self) -> bool {
self.redirect_uri.is_some()
}
pub fn set_redirect_uri(&mut self, v: ::std::string::String) {
self.redirect_uri = ::std::option::Option::Some(v);
}
pub fn mut_redirect_uri(&mut self) -> &mut ::std::string::String {
if self.redirect_uri.is_none() {
self.redirect_uri = ::std::option::Option::Some(::std::string::String::new());
}
self.redirect_uri.as_mut().unwrap()
}
pub fn take_redirect_uri(&mut self) -> ::std::string::String {
self.redirect_uri.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for CPublishedFile_Publish_Response {
const NAME: &'static str = "CPublishedFile_Publish_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.publishedfileid = ::std::option::Option::Some(is.read_uint64()?);
},
18 => {
self.redirect_uri = ::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.publishedfileid {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.redirect_uri.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.publishedfileid {
os.write_uint64(1, v)?;
}
if let Some(v) = self.redirect_uri.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() -> CPublishedFile_Publish_Response {
CPublishedFile_Publish_Response::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.redirect_uri = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_Publish_Response {
static instance: CPublishedFile_Publish_Response = CPublishedFile_Publish_Response {
publishedfileid: ::std::option::Option::None,
redirect_uri: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Retrieves information about a set of published files."]
pub struct CPublishedFile_GetDetails_Request {
pub publishedfileids: ::std::vec::Vec<u64>,
pub includetags: ::std::option::Option<bool>,
pub includeadditionalpreviews: ::std::option::Option<bool>,
pub includechildren: ::std::option::Option<bool>,
pub includekvtags: ::std::option::Option<bool>,
pub includevotes: ::std::option::Option<bool>,
pub short_description: ::std::option::Option<bool>,
pub includeforsaledata: ::std::option::Option<bool>,
pub includemetadata: ::std::option::Option<bool>,
pub language: ::std::option::Option<i32>,
pub return_playtime_stats: ::std::option::Option<u32>,
pub appid: ::std::option::Option<u32>,
pub strip_description_bbcode: ::std::option::Option<bool>,
pub desired_revision: ::std::option::Option<::protobuf::EnumOrUnknown<EPublishedFileRevision>>,
pub includereactions: ::std::option::Option<bool>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetDetails_Request {
fn default() -> &'a CPublishedFile_GetDetails_Request {
<CPublishedFile_GetDetails_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetDetails_Request {
pub fn new() -> CPublishedFile_GetDetails_Request {
::std::default::Default::default()
}
pub fn includetags(&self) -> bool {
self.includetags.unwrap_or(false)
}
pub fn clear_includetags(&mut self) {
self.includetags = ::std::option::Option::None;
}
pub fn has_includetags(&self) -> bool {
self.includetags.is_some()
}
pub fn set_includetags(&mut self, v: bool) {
self.includetags = ::std::option::Option::Some(v);
}
pub fn includeadditionalpreviews(&self) -> bool {
self.includeadditionalpreviews.unwrap_or(false)
}
pub fn clear_includeadditionalpreviews(&mut self) {
self.includeadditionalpreviews = ::std::option::Option::None;
}
pub fn has_includeadditionalpreviews(&self) -> bool {
self.includeadditionalpreviews.is_some()
}
pub fn set_includeadditionalpreviews(&mut self, v: bool) {
self.includeadditionalpreviews = ::std::option::Option::Some(v);
}
pub fn includechildren(&self) -> bool {
self.includechildren.unwrap_or(false)
}
pub fn clear_includechildren(&mut self) {
self.includechildren = ::std::option::Option::None;
}
pub fn has_includechildren(&self) -> bool {
self.includechildren.is_some()
}
pub fn set_includechildren(&mut self, v: bool) {
self.includechildren = ::std::option::Option::Some(v);
}
pub fn includekvtags(&self) -> bool {
self.includekvtags.unwrap_or(false)
}
pub fn clear_includekvtags(&mut self) {
self.includekvtags = ::std::option::Option::None;
}
pub fn has_includekvtags(&self) -> bool {
self.includekvtags.is_some()
}
pub fn set_includekvtags(&mut self, v: bool) {
self.includekvtags = ::std::option::Option::Some(v);
}
pub fn includevotes(&self) -> bool {
self.includevotes.unwrap_or(false)
}
pub fn clear_includevotes(&mut self) {
self.includevotes = ::std::option::Option::None;
}
pub fn has_includevotes(&self) -> bool {
self.includevotes.is_some()
}
pub fn set_includevotes(&mut self, v: bool) {
self.includevotes = ::std::option::Option::Some(v);
}
pub fn short_description(&self) -> bool {
self.short_description.unwrap_or(false)
}
pub fn clear_short_description(&mut self) {
self.short_description = ::std::option::Option::None;
}
pub fn has_short_description(&self) -> bool {
self.short_description.is_some()
}
pub fn set_short_description(&mut self, v: bool) {
self.short_description = ::std::option::Option::Some(v);
}
pub fn includeforsaledata(&self) -> bool {
self.includeforsaledata.unwrap_or(false)
}
pub fn clear_includeforsaledata(&mut self) {
self.includeforsaledata = ::std::option::Option::None;
}
pub fn has_includeforsaledata(&self) -> bool {
self.includeforsaledata.is_some()
}
pub fn set_includeforsaledata(&mut self, v: bool) {
self.includeforsaledata = ::std::option::Option::Some(v);
}
pub fn includemetadata(&self) -> bool {
self.includemetadata.unwrap_or(false)
}
pub fn clear_includemetadata(&mut self) {
self.includemetadata = ::std::option::Option::None;
}
pub fn has_includemetadata(&self) -> bool {
self.includemetadata.is_some()
}
pub fn set_includemetadata(&mut self, v: bool) {
self.includemetadata = ::std::option::Option::Some(v);
}
pub fn language(&self) -> i32 {
self.language.unwrap_or(0i32)
}
pub fn clear_language(&mut self) {
self.language = ::std::option::Option::None;
}
pub fn has_language(&self) -> bool {
self.language.is_some()
}
pub fn set_language(&mut self, v: i32) {
self.language = ::std::option::Option::Some(v);
}
pub fn return_playtime_stats(&self) -> u32 {
self.return_playtime_stats.unwrap_or(0)
}
pub fn clear_return_playtime_stats(&mut self) {
self.return_playtime_stats = ::std::option::Option::None;
}
pub fn has_return_playtime_stats(&self) -> bool {
self.return_playtime_stats.is_some()
}
pub fn set_return_playtime_stats(&mut self, v: u32) {
self.return_playtime_stats = ::std::option::Option::Some(v);
}
pub fn appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
pub fn strip_description_bbcode(&self) -> bool {
self.strip_description_bbcode.unwrap_or(false)
}
pub fn clear_strip_description_bbcode(&mut self) {
self.strip_description_bbcode = ::std::option::Option::None;
}
pub fn has_strip_description_bbcode(&self) -> bool {
self.strip_description_bbcode.is_some()
}
pub fn set_strip_description_bbcode(&mut self, v: bool) {
self.strip_description_bbcode = ::std::option::Option::Some(v);
}
pub fn desired_revision(&self) -> EPublishedFileRevision {
match self.desired_revision {
Some(e) => e.enum_value_or(EPublishedFileRevision::k_EPublishedFileRevision_Default),
None => EPublishedFileRevision::k_EPublishedFileRevision_Default,
}
}
pub fn clear_desired_revision(&mut self) {
self.desired_revision = ::std::option::Option::None;
}
pub fn has_desired_revision(&self) -> bool {
self.desired_revision.is_some()
}
pub fn set_desired_revision(&mut self, v: EPublishedFileRevision) {
self.desired_revision = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
}
pub fn includereactions(&self) -> bool {
self.includereactions.unwrap_or(false)
}
pub fn clear_includereactions(&mut self) {
self.includereactions = ::std::option::Option::None;
}
pub fn has_includereactions(&self) -> bool {
self.includereactions.is_some()
}
pub fn set_includereactions(&mut self, v: bool) {
self.includereactions = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_GetDetails_Request {
const NAME: &'static str = "CPublishedFile_GetDetails_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_fixed64_into(&mut self.publishedfileids)?;
},
9 => {
self.publishedfileids.push(is.read_fixed64()?);
},
16 => {
self.includetags = ::std::option::Option::Some(is.read_bool()?);
},
24 => {
self.includeadditionalpreviews = ::std::option::Option::Some(is.read_bool()?);
},
32 => {
self.includechildren = ::std::option::Option::Some(is.read_bool()?);
},
40 => {
self.includekvtags = ::std::option::Option::Some(is.read_bool()?);
},
48 => {
self.includevotes = ::std::option::Option::Some(is.read_bool()?);
},
64 => {
self.short_description = ::std::option::Option::Some(is.read_bool()?);
},
80 => {
self.includeforsaledata = ::std::option::Option::Some(is.read_bool()?);
},
88 => {
self.includemetadata = ::std::option::Option::Some(is.read_bool()?);
},
96 => {
self.language = ::std::option::Option::Some(is.read_int32()?);
},
104 => {
self.return_playtime_stats = ::std::option::Option::Some(is.read_uint32()?);
},
112 => {
self.appid = ::std::option::Option::Some(is.read_uint32()?);
},
120 => {
self.strip_description_bbcode = ::std::option::Option::Some(is.read_bool()?);
},
128 => {
self.desired_revision = ::std::option::Option::Some(is.read_enum_or_unknown()?);
},
136 => {
self.includereactions = ::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;
my_size += 9 * self.publishedfileids.len() as u64;
if let Some(v) = self.includetags {
my_size += 1 + 1;
}
if let Some(v) = self.includeadditionalpreviews {
my_size += 1 + 1;
}
if let Some(v) = self.includechildren {
my_size += 1 + 1;
}
if let Some(v) = self.includekvtags {
my_size += 1 + 1;
}
if let Some(v) = self.includevotes {
my_size += 1 + 1;
}
if let Some(v) = self.short_description {
my_size += 1 + 1;
}
if let Some(v) = self.includeforsaledata {
my_size += 1 + 1;
}
if let Some(v) = self.includemetadata {
my_size += 1 + 1;
}
if let Some(v) = self.language {
my_size += ::protobuf::rt::int32_size(12, v);
}
if let Some(v) = self.return_playtime_stats {
my_size += ::protobuf::rt::uint32_size(13, v);
}
if let Some(v) = self.appid {
my_size += ::protobuf::rt::uint32_size(14, v);
}
if let Some(v) = self.strip_description_bbcode {
my_size += 1 + 1;
}
if let Some(v) = self.desired_revision {
my_size += ::protobuf::rt::int32_size(16, v.value());
}
if let Some(v) = self.includereactions {
my_size += 2 + 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.publishedfileids {
os.write_fixed64(1, *v)?;
};
if let Some(v) = self.includetags {
os.write_bool(2, v)?;
}
if let Some(v) = self.includeadditionalpreviews {
os.write_bool(3, v)?;
}
if let Some(v) = self.includechildren {
os.write_bool(4, v)?;
}
if let Some(v) = self.includekvtags {
os.write_bool(5, v)?;
}
if let Some(v) = self.includevotes {
os.write_bool(6, v)?;
}
if let Some(v) = self.short_description {
os.write_bool(8, v)?;
}
if let Some(v) = self.includeforsaledata {
os.write_bool(10, v)?;
}
if let Some(v) = self.includemetadata {
os.write_bool(11, v)?;
}
if let Some(v) = self.language {
os.write_int32(12, v)?;
}
if let Some(v) = self.return_playtime_stats {
os.write_uint32(13, v)?;
}
if let Some(v) = self.appid {
os.write_uint32(14, v)?;
}
if let Some(v) = self.strip_description_bbcode {
os.write_bool(15, v)?;
}
if let Some(v) = self.desired_revision {
os.write_enum(16, ::protobuf::EnumOrUnknown::value(&v))?;
}
if let Some(v) = self.includereactions {
os.write_bool(17, 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() -> CPublishedFile_GetDetails_Request {
CPublishedFile_GetDetails_Request::new()
}
fn clear(&mut self) {
self.publishedfileids.clear();
self.includetags = ::std::option::Option::None;
self.includeadditionalpreviews = ::std::option::Option::None;
self.includechildren = ::std::option::Option::None;
self.includekvtags = ::std::option::Option::None;
self.includevotes = ::std::option::Option::None;
self.short_description = ::std::option::Option::None;
self.includeforsaledata = ::std::option::Option::None;
self.includemetadata = ::std::option::Option::None;
self.language = ::std::option::Option::None;
self.return_playtime_stats = ::std::option::Option::None;
self.appid = ::std::option::Option::None;
self.strip_description_bbcode = ::std::option::Option::None;
self.desired_revision = ::std::option::Option::None;
self.includereactions = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetDetails_Request {
static instance: CPublishedFile_GetDetails_Request = CPublishedFile_GetDetails_Request {
publishedfileids: ::std::vec::Vec::new(),
includetags: ::std::option::Option::None,
includeadditionalpreviews: ::std::option::Option::None,
includechildren: ::std::option::Option::None,
includekvtags: ::std::option::Option::None,
includevotes: ::std::option::Option::None,
short_description: ::std::option::Option::None,
includeforsaledata: ::std::option::Option::None,
includemetadata: ::std::option::Option::None,
language: ::std::option::Option::None,
return_playtime_stats: ::std::option::Option::None,
appid: ::std::option::Option::None,
strip_description_bbcode: ::std::option::Option::None,
desired_revision: ::std::option::Option::None,
includereactions: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PublishedFileDetails {
pub result: ::std::option::Option<u32>,
pub publishedfileid: ::std::option::Option<u64>,
pub creator: ::std::option::Option<u64>,
pub creator_appid: ::std::option::Option<u32>,
pub consumer_appid: ::std::option::Option<u32>,
pub consumer_shortcutid: ::std::option::Option<u32>,
pub filename: ::std::option::Option<::std::string::String>,
pub file_size: ::std::option::Option<u64>,
pub preview_file_size: ::std::option::Option<u64>,
pub file_url: ::std::option::Option<::std::string::String>,
pub preview_url: ::std::option::Option<::std::string::String>,
pub youtubevideoid: ::std::option::Option<::std::string::String>,
pub url: ::std::option::Option<::std::string::String>,
pub hcontent_file: ::std::option::Option<u64>,
pub hcontent_preview: ::std::option::Option<u64>,
pub title: ::std::option::Option<::std::string::String>,
pub file_description: ::std::option::Option<::std::string::String>,
pub short_description: ::std::option::Option<::std::string::String>,
pub time_created: ::std::option::Option<u32>,
pub time_updated: ::std::option::Option<u32>,
pub visibility: ::std::option::Option<u32>,
pub flags: ::std::option::Option<u32>,
pub workshop_file: ::std::option::Option<bool>,
pub workshop_accepted: ::std::option::Option<bool>,
pub show_subscribe_all: ::std::option::Option<bool>,
pub num_comments_developer: ::std::option::Option<i32>,
pub num_comments_public: ::std::option::Option<i32>,
pub banned: ::std::option::Option<bool>,
pub ban_reason: ::std::option::Option<::std::string::String>,
pub banner: ::std::option::Option<u64>,
pub can_be_deleted: ::std::option::Option<bool>,
pub incompatible: ::std::option::Option<bool>,
pub app_name: ::std::option::Option<::std::string::String>,
pub file_type: ::std::option::Option<u32>,
pub can_subscribe: ::std::option::Option<bool>,
pub subscriptions: ::std::option::Option<u32>,
pub favorited: ::std::option::Option<u32>,
pub followers: ::std::option::Option<u32>,
pub lifetime_subscriptions: ::std::option::Option<u32>,
pub lifetime_favorited: ::std::option::Option<u32>,
pub lifetime_followers: ::std::option::Option<u32>,
pub lifetime_playtime: ::std::option::Option<u64>,
pub lifetime_playtime_sessions: ::std::option::Option<u64>,
pub views: ::std::option::Option<u32>,
pub image_width: ::std::option::Option<u32>,
pub image_height: ::std::option::Option<u32>,
pub image_url: ::std::option::Option<::std::string::String>,
pub spoiler_tag: ::std::option::Option<bool>,
pub shortcutid: ::std::option::Option<u32>,
pub shortcutname: ::std::option::Option<::std::string::String>,
pub num_children: ::std::option::Option<u32>,
pub num_reports: ::std::option::Option<u32>,
pub previews: ::std::vec::Vec<published_file_details::Preview>,
pub tags: ::std::vec::Vec<published_file_details::Tag>,
pub children: ::std::vec::Vec<published_file_details::Child>,
pub kvtags: ::std::vec::Vec<published_file_details::KVTag>,
pub vote_data: ::protobuf::MessageField<published_file_details::VoteData>,
pub playtime_stats: ::protobuf::MessageField<published_file_details::PlaytimeStats>,
pub time_subscribed: ::std::option::Option<u32>,
pub for_sale_data: ::protobuf::MessageField<published_file_details::ForSaleData>,
pub metadata: ::std::option::Option<::std::string::String>,
pub language: ::std::option::Option<i32>,
pub maybe_inappropriate_sex: ::std::option::Option<bool>,
pub maybe_inappropriate_violence: ::std::option::Option<bool>,
pub content_descriptorids: ::std::vec::Vec<::protobuf::EnumOrUnknown<super::enums_productinfo::EContentDescriptorID>>,
pub revision_change_number: ::std::option::Option<u64>,
pub revision: ::std::option::Option<::protobuf::EnumOrUnknown<EPublishedFileRevision>>,
pub available_revisions: ::std::vec::Vec<::protobuf::EnumOrUnknown<EPublishedFileRevision>>,
pub reactions: ::std::vec::Vec<published_file_details::Reaction>,
pub ban_text_check_result: ::std::option::Option<::protobuf::EnumOrUnknown<super::steammessages_base::EBanContentCheckResult>>,
pub search_score: ::std::option::Option<f32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a PublishedFileDetails {
fn default() -> &'a PublishedFileDetails {
<PublishedFileDetails as ::protobuf::Message>::default_instance()
}
}
impl PublishedFileDetails {
pub fn new() -> PublishedFileDetails {
::std::default::Default::default()
}
pub fn result(&self) -> u32 {
self.result.unwrap_or(0)
}
pub fn clear_result(&mut self) {
self.result = ::std::option::Option::None;
}
pub fn has_result(&self) -> bool {
self.result.is_some()
}
pub fn set_result(&mut self, v: u32) {
self.result = ::std::option::Option::Some(v);
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
pub fn creator(&self) -> u64 {
self.creator.unwrap_or(0)
}
pub fn clear_creator(&mut self) {
self.creator = ::std::option::Option::None;
}
pub fn has_creator(&self) -> bool {
self.creator.is_some()
}
pub fn set_creator(&mut self, v: u64) {
self.creator = ::std::option::Option::Some(v);
}
pub fn creator_appid(&self) -> u32 {
self.creator_appid.unwrap_or(0)
}
pub fn clear_creator_appid(&mut self) {
self.creator_appid = ::std::option::Option::None;
}
pub fn has_creator_appid(&self) -> bool {
self.creator_appid.is_some()
}
pub fn set_creator_appid(&mut self, v: u32) {
self.creator_appid = ::std::option::Option::Some(v);
}
pub fn consumer_appid(&self) -> u32 {
self.consumer_appid.unwrap_or(0)
}
pub fn clear_consumer_appid(&mut self) {
self.consumer_appid = ::std::option::Option::None;
}
pub fn has_consumer_appid(&self) -> bool {
self.consumer_appid.is_some()
}
pub fn set_consumer_appid(&mut self, v: u32) {
self.consumer_appid = ::std::option::Option::Some(v);
}
pub fn consumer_shortcutid(&self) -> u32 {
self.consumer_shortcutid.unwrap_or(0)
}
pub fn clear_consumer_shortcutid(&mut self) {
self.consumer_shortcutid = ::std::option::Option::None;
}
pub fn has_consumer_shortcutid(&self) -> bool {
self.consumer_shortcutid.is_some()
}
pub fn set_consumer_shortcutid(&mut self, v: u32) {
self.consumer_shortcutid = ::std::option::Option::Some(v);
}
pub fn filename(&self) -> &str {
match self.filename.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_filename(&mut self) {
self.filename = ::std::option::Option::None;
}
pub fn has_filename(&self) -> bool {
self.filename.is_some()
}
pub fn set_filename(&mut self, v: ::std::string::String) {
self.filename = ::std::option::Option::Some(v);
}
pub fn mut_filename(&mut self) -> &mut ::std::string::String {
if self.filename.is_none() {
self.filename = ::std::option::Option::Some(::std::string::String::new());
}
self.filename.as_mut().unwrap()
}
pub fn take_filename(&mut self) -> ::std::string::String {
self.filename.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn file_size(&self) -> u64 {
self.file_size.unwrap_or(0)
}
pub fn clear_file_size(&mut self) {
self.file_size = ::std::option::Option::None;
}
pub fn has_file_size(&self) -> bool {
self.file_size.is_some()
}
pub fn set_file_size(&mut self, v: u64) {
self.file_size = ::std::option::Option::Some(v);
}
pub fn preview_file_size(&self) -> u64 {
self.preview_file_size.unwrap_or(0)
}
pub fn clear_preview_file_size(&mut self) {
self.preview_file_size = ::std::option::Option::None;
}
pub fn has_preview_file_size(&self) -> bool {
self.preview_file_size.is_some()
}
pub fn set_preview_file_size(&mut self, v: u64) {
self.preview_file_size = ::std::option::Option::Some(v);
}
pub fn file_url(&self) -> &str {
match self.file_url.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_file_url(&mut self) {
self.file_url = ::std::option::Option::None;
}
pub fn has_file_url(&self) -> bool {
self.file_url.is_some()
}
pub fn set_file_url(&mut self, v: ::std::string::String) {
self.file_url = ::std::option::Option::Some(v);
}
pub fn mut_file_url(&mut self) -> &mut ::std::string::String {
if self.file_url.is_none() {
self.file_url = ::std::option::Option::Some(::std::string::String::new());
}
self.file_url.as_mut().unwrap()
}
pub fn take_file_url(&mut self) -> ::std::string::String {
self.file_url.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn preview_url(&self) -> &str {
match self.preview_url.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_preview_url(&mut self) {
self.preview_url = ::std::option::Option::None;
}
pub fn has_preview_url(&self) -> bool {
self.preview_url.is_some()
}
pub fn set_preview_url(&mut self, v: ::std::string::String) {
self.preview_url = ::std::option::Option::Some(v);
}
pub fn mut_preview_url(&mut self) -> &mut ::std::string::String {
if self.preview_url.is_none() {
self.preview_url = ::std::option::Option::Some(::std::string::String::new());
}
self.preview_url.as_mut().unwrap()
}
pub fn take_preview_url(&mut self) -> ::std::string::String {
self.preview_url.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn youtubevideoid(&self) -> &str {
match self.youtubevideoid.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_youtubevideoid(&mut self) {
self.youtubevideoid = ::std::option::Option::None;
}
pub fn has_youtubevideoid(&self) -> bool {
self.youtubevideoid.is_some()
}
pub fn set_youtubevideoid(&mut self, v: ::std::string::String) {
self.youtubevideoid = ::std::option::Option::Some(v);
}
pub fn mut_youtubevideoid(&mut self) -> &mut ::std::string::String {
if self.youtubevideoid.is_none() {
self.youtubevideoid = ::std::option::Option::Some(::std::string::String::new());
}
self.youtubevideoid.as_mut().unwrap()
}
pub fn take_youtubevideoid(&mut self) -> ::std::string::String {
self.youtubevideoid.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn url(&self) -> &str {
match self.url.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_url(&mut self) {
self.url = ::std::option::Option::None;
}
pub fn has_url(&self) -> bool {
self.url.is_some()
}
pub fn set_url(&mut self, v: ::std::string::String) {
self.url = ::std::option::Option::Some(v);
}
pub fn mut_url(&mut self) -> &mut ::std::string::String {
if self.url.is_none() {
self.url = ::std::option::Option::Some(::std::string::String::new());
}
self.url.as_mut().unwrap()
}
pub fn take_url(&mut self) -> ::std::string::String {
self.url.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn hcontent_file(&self) -> u64 {
self.hcontent_file.unwrap_or(0)
}
pub fn clear_hcontent_file(&mut self) {
self.hcontent_file = ::std::option::Option::None;
}
pub fn has_hcontent_file(&self) -> bool {
self.hcontent_file.is_some()
}
pub fn set_hcontent_file(&mut self, v: u64) {
self.hcontent_file = ::std::option::Option::Some(v);
}
pub fn hcontent_preview(&self) -> u64 {
self.hcontent_preview.unwrap_or(0)
}
pub fn clear_hcontent_preview(&mut self) {
self.hcontent_preview = ::std::option::Option::None;
}
pub fn has_hcontent_preview(&self) -> bool {
self.hcontent_preview.is_some()
}
pub fn set_hcontent_preview(&mut self, v: u64) {
self.hcontent_preview = ::std::option::Option::Some(v);
}
pub fn title(&self) -> &str {
match self.title.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_title(&mut self) {
self.title = ::std::option::Option::None;
}
pub fn has_title(&self) -> bool {
self.title.is_some()
}
pub fn set_title(&mut self, v: ::std::string::String) {
self.title = ::std::option::Option::Some(v);
}
pub fn mut_title(&mut self) -> &mut ::std::string::String {
if self.title.is_none() {
self.title = ::std::option::Option::Some(::std::string::String::new());
}
self.title.as_mut().unwrap()
}
pub fn take_title(&mut self) -> ::std::string::String {
self.title.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn file_description(&self) -> &str {
match self.file_description.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_file_description(&mut self) {
self.file_description = ::std::option::Option::None;
}
pub fn has_file_description(&self) -> bool {
self.file_description.is_some()
}
pub fn set_file_description(&mut self, v: ::std::string::String) {
self.file_description = ::std::option::Option::Some(v);
}
pub fn mut_file_description(&mut self) -> &mut ::std::string::String {
if self.file_description.is_none() {
self.file_description = ::std::option::Option::Some(::std::string::String::new());
}
self.file_description.as_mut().unwrap()
}
pub fn take_file_description(&mut self) -> ::std::string::String {
self.file_description.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn short_description(&self) -> &str {
match self.short_description.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_short_description(&mut self) {
self.short_description = ::std::option::Option::None;
}
pub fn has_short_description(&self) -> bool {
self.short_description.is_some()
}
pub fn set_short_description(&mut self, v: ::std::string::String) {
self.short_description = ::std::option::Option::Some(v);
}
pub fn mut_short_description(&mut self) -> &mut ::std::string::String {
if self.short_description.is_none() {
self.short_description = ::std::option::Option::Some(::std::string::String::new());
}
self.short_description.as_mut().unwrap()
}
pub fn take_short_description(&mut self) -> ::std::string::String {
self.short_description.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn time_created(&self) -> u32 {
self.time_created.unwrap_or(0)
}
pub fn clear_time_created(&mut self) {
self.time_created = ::std::option::Option::None;
}
pub fn has_time_created(&self) -> bool {
self.time_created.is_some()
}
pub fn set_time_created(&mut self, v: u32) {
self.time_created = ::std::option::Option::Some(v);
}
pub fn time_updated(&self) -> u32 {
self.time_updated.unwrap_or(0)
}
pub fn clear_time_updated(&mut self) {
self.time_updated = ::std::option::Option::None;
}
pub fn has_time_updated(&self) -> bool {
self.time_updated.is_some()
}
pub fn set_time_updated(&mut self, v: u32) {
self.time_updated = ::std::option::Option::Some(v);
}
pub fn visibility(&self) -> u32 {
self.visibility.unwrap_or(0)
}
pub fn clear_visibility(&mut self) {
self.visibility = ::std::option::Option::None;
}
pub fn has_visibility(&self) -> bool {
self.visibility.is_some()
}
pub fn set_visibility(&mut self, v: u32) {
self.visibility = ::std::option::Option::Some(v);
}
pub fn flags(&self) -> u32 {
self.flags.unwrap_or(0)
}
pub fn clear_flags(&mut self) {
self.flags = ::std::option::Option::None;
}
pub fn has_flags(&self) -> bool {
self.flags.is_some()
}
pub fn set_flags(&mut self, v: u32) {
self.flags = ::std::option::Option::Some(v);
}
pub fn workshop_file(&self) -> bool {
self.workshop_file.unwrap_or(false)
}
pub fn clear_workshop_file(&mut self) {
self.workshop_file = ::std::option::Option::None;
}
pub fn has_workshop_file(&self) -> bool {
self.workshop_file.is_some()
}
pub fn set_workshop_file(&mut self, v: bool) {
self.workshop_file = ::std::option::Option::Some(v);
}
pub fn workshop_accepted(&self) -> bool {
self.workshop_accepted.unwrap_or(false)
}
pub fn clear_workshop_accepted(&mut self) {
self.workshop_accepted = ::std::option::Option::None;
}
pub fn has_workshop_accepted(&self) -> bool {
self.workshop_accepted.is_some()
}
pub fn set_workshop_accepted(&mut self, v: bool) {
self.workshop_accepted = ::std::option::Option::Some(v);
}
pub fn show_subscribe_all(&self) -> bool {
self.show_subscribe_all.unwrap_or(false)
}
pub fn clear_show_subscribe_all(&mut self) {
self.show_subscribe_all = ::std::option::Option::None;
}
pub fn has_show_subscribe_all(&self) -> bool {
self.show_subscribe_all.is_some()
}
pub fn set_show_subscribe_all(&mut self, v: bool) {
self.show_subscribe_all = ::std::option::Option::Some(v);
}
pub fn num_comments_developer(&self) -> i32 {
self.num_comments_developer.unwrap_or(0)
}
pub fn clear_num_comments_developer(&mut self) {
self.num_comments_developer = ::std::option::Option::None;
}
pub fn has_num_comments_developer(&self) -> bool {
self.num_comments_developer.is_some()
}
pub fn set_num_comments_developer(&mut self, v: i32) {
self.num_comments_developer = ::std::option::Option::Some(v);
}
pub fn num_comments_public(&self) -> i32 {
self.num_comments_public.unwrap_or(0)
}
pub fn clear_num_comments_public(&mut self) {
self.num_comments_public = ::std::option::Option::None;
}
pub fn has_num_comments_public(&self) -> bool {
self.num_comments_public.is_some()
}
pub fn set_num_comments_public(&mut self, v: i32) {
self.num_comments_public = ::std::option::Option::Some(v);
}
pub fn banned(&self) -> bool {
self.banned.unwrap_or(false)
}
pub fn clear_banned(&mut self) {
self.banned = ::std::option::Option::None;
}
pub fn has_banned(&self) -> bool {
self.banned.is_some()
}
pub fn set_banned(&mut self, v: bool) {
self.banned = ::std::option::Option::Some(v);
}
pub fn ban_reason(&self) -> &str {
match self.ban_reason.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_ban_reason(&mut self) {
self.ban_reason = ::std::option::Option::None;
}
pub fn has_ban_reason(&self) -> bool {
self.ban_reason.is_some()
}
pub fn set_ban_reason(&mut self, v: ::std::string::String) {
self.ban_reason = ::std::option::Option::Some(v);
}
pub fn mut_ban_reason(&mut self) -> &mut ::std::string::String {
if self.ban_reason.is_none() {
self.ban_reason = ::std::option::Option::Some(::std::string::String::new());
}
self.ban_reason.as_mut().unwrap()
}
pub fn take_ban_reason(&mut self) -> ::std::string::String {
self.ban_reason.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn banner(&self) -> u64 {
self.banner.unwrap_or(0)
}
pub fn clear_banner(&mut self) {
self.banner = ::std::option::Option::None;
}
pub fn has_banner(&self) -> bool {
self.banner.is_some()
}
pub fn set_banner(&mut self, v: u64) {
self.banner = ::std::option::Option::Some(v);
}
pub fn can_be_deleted(&self) -> bool {
self.can_be_deleted.unwrap_or(false)
}
pub fn clear_can_be_deleted(&mut self) {
self.can_be_deleted = ::std::option::Option::None;
}
pub fn has_can_be_deleted(&self) -> bool {
self.can_be_deleted.is_some()
}
pub fn set_can_be_deleted(&mut self, v: bool) {
self.can_be_deleted = ::std::option::Option::Some(v);
}
pub fn incompatible(&self) -> bool {
self.incompatible.unwrap_or(false)
}
pub fn clear_incompatible(&mut self) {
self.incompatible = ::std::option::Option::None;
}
pub fn has_incompatible(&self) -> bool {
self.incompatible.is_some()
}
pub fn set_incompatible(&mut self, v: bool) {
self.incompatible = ::std::option::Option::Some(v);
}
pub fn app_name(&self) -> &str {
match self.app_name.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_app_name(&mut self) {
self.app_name = ::std::option::Option::None;
}
pub fn has_app_name(&self) -> bool {
self.app_name.is_some()
}
pub fn set_app_name(&mut self, v: ::std::string::String) {
self.app_name = ::std::option::Option::Some(v);
}
pub fn mut_app_name(&mut self) -> &mut ::std::string::String {
if self.app_name.is_none() {
self.app_name = ::std::option::Option::Some(::std::string::String::new());
}
self.app_name.as_mut().unwrap()
}
pub fn take_app_name(&mut self) -> ::std::string::String {
self.app_name.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn file_type(&self) -> u32 {
self.file_type.unwrap_or(0)
}
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: u32) {
self.file_type = ::std::option::Option::Some(v);
}
pub fn can_subscribe(&self) -> bool {
self.can_subscribe.unwrap_or(false)
}
pub fn clear_can_subscribe(&mut self) {
self.can_subscribe = ::std::option::Option::None;
}
pub fn has_can_subscribe(&self) -> bool {
self.can_subscribe.is_some()
}
pub fn set_can_subscribe(&mut self, v: bool) {
self.can_subscribe = ::std::option::Option::Some(v);
}
pub fn subscriptions(&self) -> u32 {
self.subscriptions.unwrap_or(0)
}
pub fn clear_subscriptions(&mut self) {
self.subscriptions = ::std::option::Option::None;
}
pub fn has_subscriptions(&self) -> bool {
self.subscriptions.is_some()
}
pub fn set_subscriptions(&mut self, v: u32) {
self.subscriptions = ::std::option::Option::Some(v);
}
pub fn favorited(&self) -> u32 {
self.favorited.unwrap_or(0)
}
pub fn clear_favorited(&mut self) {
self.favorited = ::std::option::Option::None;
}
pub fn has_favorited(&self) -> bool {
self.favorited.is_some()
}
pub fn set_favorited(&mut self, v: u32) {
self.favorited = ::std::option::Option::Some(v);
}
pub fn followers(&self) -> u32 {
self.followers.unwrap_or(0)
}
pub fn clear_followers(&mut self) {
self.followers = ::std::option::Option::None;
}
pub fn has_followers(&self) -> bool {
self.followers.is_some()
}
pub fn set_followers(&mut self, v: u32) {
self.followers = ::std::option::Option::Some(v);
}
pub fn lifetime_subscriptions(&self) -> u32 {
self.lifetime_subscriptions.unwrap_or(0)
}
pub fn clear_lifetime_subscriptions(&mut self) {
self.lifetime_subscriptions = ::std::option::Option::None;
}
pub fn has_lifetime_subscriptions(&self) -> bool {
self.lifetime_subscriptions.is_some()
}
pub fn set_lifetime_subscriptions(&mut self, v: u32) {
self.lifetime_subscriptions = ::std::option::Option::Some(v);
}
pub fn lifetime_favorited(&self) -> u32 {
self.lifetime_favorited.unwrap_or(0)
}
pub fn clear_lifetime_favorited(&mut self) {
self.lifetime_favorited = ::std::option::Option::None;
}
pub fn has_lifetime_favorited(&self) -> bool {
self.lifetime_favorited.is_some()
}
pub fn set_lifetime_favorited(&mut self, v: u32) {
self.lifetime_favorited = ::std::option::Option::Some(v);
}
pub fn lifetime_followers(&self) -> u32 {
self.lifetime_followers.unwrap_or(0)
}
pub fn clear_lifetime_followers(&mut self) {
self.lifetime_followers = ::std::option::Option::None;
}
pub fn has_lifetime_followers(&self) -> bool {
self.lifetime_followers.is_some()
}
pub fn set_lifetime_followers(&mut self, v: u32) {
self.lifetime_followers = ::std::option::Option::Some(v);
}
pub fn lifetime_playtime(&self) -> u64 {
self.lifetime_playtime.unwrap_or(0)
}
pub fn clear_lifetime_playtime(&mut self) {
self.lifetime_playtime = ::std::option::Option::None;
}
pub fn has_lifetime_playtime(&self) -> bool {
self.lifetime_playtime.is_some()
}
pub fn set_lifetime_playtime(&mut self, v: u64) {
self.lifetime_playtime = ::std::option::Option::Some(v);
}
pub fn lifetime_playtime_sessions(&self) -> u64 {
self.lifetime_playtime_sessions.unwrap_or(0)
}
pub fn clear_lifetime_playtime_sessions(&mut self) {
self.lifetime_playtime_sessions = ::std::option::Option::None;
}
pub fn has_lifetime_playtime_sessions(&self) -> bool {
self.lifetime_playtime_sessions.is_some()
}
pub fn set_lifetime_playtime_sessions(&mut self, v: u64) {
self.lifetime_playtime_sessions = ::std::option::Option::Some(v);
}
pub fn views(&self) -> u32 {
self.views.unwrap_or(0)
}
pub fn clear_views(&mut self) {
self.views = ::std::option::Option::None;
}
pub fn has_views(&self) -> bool {
self.views.is_some()
}
pub fn set_views(&mut self, v: u32) {
self.views = ::std::option::Option::Some(v);
}
pub fn image_width(&self) -> u32 {
self.image_width.unwrap_or(0)
}
pub fn clear_image_width(&mut self) {
self.image_width = ::std::option::Option::None;
}
pub fn has_image_width(&self) -> bool {
self.image_width.is_some()
}
pub fn set_image_width(&mut self, v: u32) {
self.image_width = ::std::option::Option::Some(v);
}
pub fn image_height(&self) -> u32 {
self.image_height.unwrap_or(0)
}
pub fn clear_image_height(&mut self) {
self.image_height = ::std::option::Option::None;
}
pub fn has_image_height(&self) -> bool {
self.image_height.is_some()
}
pub fn set_image_height(&mut self, v: u32) {
self.image_height = ::std::option::Option::Some(v);
}
pub fn image_url(&self) -> &str {
match self.image_url.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_image_url(&mut self) {
self.image_url = ::std::option::Option::None;
}
pub fn has_image_url(&self) -> bool {
self.image_url.is_some()
}
pub fn set_image_url(&mut self, v: ::std::string::String) {
self.image_url = ::std::option::Option::Some(v);
}
pub fn mut_image_url(&mut self) -> &mut ::std::string::String {
if self.image_url.is_none() {
self.image_url = ::std::option::Option::Some(::std::string::String::new());
}
self.image_url.as_mut().unwrap()
}
pub fn take_image_url(&mut self) -> ::std::string::String {
self.image_url.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn spoiler_tag(&self) -> bool {
self.spoiler_tag.unwrap_or(false)
}
pub fn clear_spoiler_tag(&mut self) {
self.spoiler_tag = ::std::option::Option::None;
}
pub fn has_spoiler_tag(&self) -> bool {
self.spoiler_tag.is_some()
}
pub fn set_spoiler_tag(&mut self, v: bool) {
self.spoiler_tag = ::std::option::Option::Some(v);
}
pub fn shortcutid(&self) -> u32 {
self.shortcutid.unwrap_or(0)
}
pub fn clear_shortcutid(&mut self) {
self.shortcutid = ::std::option::Option::None;
}
pub fn has_shortcutid(&self) -> bool {
self.shortcutid.is_some()
}
pub fn set_shortcutid(&mut self, v: u32) {
self.shortcutid = ::std::option::Option::Some(v);
}
pub fn shortcutname(&self) -> &str {
match self.shortcutname.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_shortcutname(&mut self) {
self.shortcutname = ::std::option::Option::None;
}
pub fn has_shortcutname(&self) -> bool {
self.shortcutname.is_some()
}
pub fn set_shortcutname(&mut self, v: ::std::string::String) {
self.shortcutname = ::std::option::Option::Some(v);
}
pub fn mut_shortcutname(&mut self) -> &mut ::std::string::String {
if self.shortcutname.is_none() {
self.shortcutname = ::std::option::Option::Some(::std::string::String::new());
}
self.shortcutname.as_mut().unwrap()
}
pub fn take_shortcutname(&mut self) -> ::std::string::String {
self.shortcutname.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn num_children(&self) -> u32 {
self.num_children.unwrap_or(0)
}
pub fn clear_num_children(&mut self) {
self.num_children = ::std::option::Option::None;
}
pub fn has_num_children(&self) -> bool {
self.num_children.is_some()
}
pub fn set_num_children(&mut self, v: u32) {
self.num_children = ::std::option::Option::Some(v);
}
pub fn num_reports(&self) -> u32 {
self.num_reports.unwrap_or(0)
}
pub fn clear_num_reports(&mut self) {
self.num_reports = ::std::option::Option::None;
}
pub fn has_num_reports(&self) -> bool {
self.num_reports.is_some()
}
pub fn set_num_reports(&mut self, v: u32) {
self.num_reports = ::std::option::Option::Some(v);
}
pub fn time_subscribed(&self) -> u32 {
self.time_subscribed.unwrap_or(0)
}
pub fn clear_time_subscribed(&mut self) {
self.time_subscribed = ::std::option::Option::None;
}
pub fn has_time_subscribed(&self) -> bool {
self.time_subscribed.is_some()
}
pub fn set_time_subscribed(&mut self, v: u32) {
self.time_subscribed = ::std::option::Option::Some(v);
}
pub fn metadata(&self) -> &str {
match self.metadata.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_metadata(&mut self) {
self.metadata = ::std::option::Option::None;
}
pub fn has_metadata(&self) -> bool {
self.metadata.is_some()
}
pub fn set_metadata(&mut self, v: ::std::string::String) {
self.metadata = ::std::option::Option::Some(v);
}
pub fn mut_metadata(&mut self) -> &mut ::std::string::String {
if self.metadata.is_none() {
self.metadata = ::std::option::Option::Some(::std::string::String::new());
}
self.metadata.as_mut().unwrap()
}
pub fn take_metadata(&mut self) -> ::std::string::String {
self.metadata.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn language(&self) -> i32 {
self.language.unwrap_or(0i32)
}
pub fn clear_language(&mut self) {
self.language = ::std::option::Option::None;
}
pub fn has_language(&self) -> bool {
self.language.is_some()
}
pub fn set_language(&mut self, v: i32) {
self.language = ::std::option::Option::Some(v);
}
pub fn maybe_inappropriate_sex(&self) -> bool {
self.maybe_inappropriate_sex.unwrap_or(false)
}
pub fn clear_maybe_inappropriate_sex(&mut self) {
self.maybe_inappropriate_sex = ::std::option::Option::None;
}
pub fn has_maybe_inappropriate_sex(&self) -> bool {
self.maybe_inappropriate_sex.is_some()
}
pub fn set_maybe_inappropriate_sex(&mut self, v: bool) {
self.maybe_inappropriate_sex = ::std::option::Option::Some(v);
}
pub fn maybe_inappropriate_violence(&self) -> bool {
self.maybe_inappropriate_violence.unwrap_or(false)
}
pub fn clear_maybe_inappropriate_violence(&mut self) {
self.maybe_inappropriate_violence = ::std::option::Option::None;
}
pub fn has_maybe_inappropriate_violence(&self) -> bool {
self.maybe_inappropriate_violence.is_some()
}
pub fn set_maybe_inappropriate_violence(&mut self, v: bool) {
self.maybe_inappropriate_violence = ::std::option::Option::Some(v);
}
pub fn revision_change_number(&self) -> u64 {
self.revision_change_number.unwrap_or(0)
}
pub fn clear_revision_change_number(&mut self) {
self.revision_change_number = ::std::option::Option::None;
}
pub fn has_revision_change_number(&self) -> bool {
self.revision_change_number.is_some()
}
pub fn set_revision_change_number(&mut self, v: u64) {
self.revision_change_number = ::std::option::Option::Some(v);
}
pub fn revision(&self) -> EPublishedFileRevision {
match self.revision {
Some(e) => e.enum_value_or(EPublishedFileRevision::k_EPublishedFileRevision_Default),
None => EPublishedFileRevision::k_EPublishedFileRevision_Default,
}
}
pub fn clear_revision(&mut self) {
self.revision = ::std::option::Option::None;
}
pub fn has_revision(&self) -> bool {
self.revision.is_some()
}
pub fn set_revision(&mut self, v: EPublishedFileRevision) {
self.revision = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
}
pub fn ban_text_check_result(&self) -> super::steammessages_base::EBanContentCheckResult {
match self.ban_text_check_result {
Some(e) => e.enum_value_or(super::steammessages_base::EBanContentCheckResult::k_EBanContentCheckResult_NotScanned),
None => super::steammessages_base::EBanContentCheckResult::k_EBanContentCheckResult_NotScanned,
}
}
pub fn clear_ban_text_check_result(&mut self) {
self.ban_text_check_result = ::std::option::Option::None;
}
pub fn has_ban_text_check_result(&self) -> bool {
self.ban_text_check_result.is_some()
}
pub fn set_ban_text_check_result(&mut self, v: super::steammessages_base::EBanContentCheckResult) {
self.ban_text_check_result = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
}
pub fn search_score(&self) -> f32 {
self.search_score.unwrap_or(0.)
}
pub fn clear_search_score(&mut self) {
self.search_score = ::std::option::Option::None;
}
pub fn has_search_score(&self) -> bool {
self.search_score.is_some()
}
pub fn set_search_score(&mut self, v: f32) {
self.search_score = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for PublishedFileDetails {
const NAME: &'static str = "PublishedFileDetails";
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.result = ::std::option::Option::Some(is.read_uint32()?);
},
16 => {
self.publishedfileid = ::std::option::Option::Some(is.read_uint64()?);
},
25 => {
self.creator = ::std::option::Option::Some(is.read_fixed64()?);
},
32 => {
self.creator_appid = ::std::option::Option::Some(is.read_uint32()?);
},
40 => {
self.consumer_appid = ::std::option::Option::Some(is.read_uint32()?);
},
48 => {
self.consumer_shortcutid = ::std::option::Option::Some(is.read_uint32()?);
},
58 => {
self.filename = ::std::option::Option::Some(is.read_string()?);
},
64 => {
self.file_size = ::std::option::Option::Some(is.read_uint64()?);
},
72 => {
self.preview_file_size = ::std::option::Option::Some(is.read_uint64()?);
},
82 => {
self.file_url = ::std::option::Option::Some(is.read_string()?);
},
90 => {
self.preview_url = ::std::option::Option::Some(is.read_string()?);
},
98 => {
self.youtubevideoid = ::std::option::Option::Some(is.read_string()?);
},
106 => {
self.url = ::std::option::Option::Some(is.read_string()?);
},
113 => {
self.hcontent_file = ::std::option::Option::Some(is.read_fixed64()?);
},
121 => {
self.hcontent_preview = ::std::option::Option::Some(is.read_fixed64()?);
},
130 => {
self.title = ::std::option::Option::Some(is.read_string()?);
},
138 => {
self.file_description = ::std::option::Option::Some(is.read_string()?);
},
146 => {
self.short_description = ::std::option::Option::Some(is.read_string()?);
},
152 => {
self.time_created = ::std::option::Option::Some(is.read_uint32()?);
},
160 => {
self.time_updated = ::std::option::Option::Some(is.read_uint32()?);
},
168 => {
self.visibility = ::std::option::Option::Some(is.read_uint32()?);
},
176 => {
self.flags = ::std::option::Option::Some(is.read_uint32()?);
},
184 => {
self.workshop_file = ::std::option::Option::Some(is.read_bool()?);
},
192 => {
self.workshop_accepted = ::std::option::Option::Some(is.read_bool()?);
},
200 => {
self.show_subscribe_all = ::std::option::Option::Some(is.read_bool()?);
},
208 => {
self.num_comments_developer = ::std::option::Option::Some(is.read_int32()?);
},
216 => {
self.num_comments_public = ::std::option::Option::Some(is.read_int32()?);
},
224 => {
self.banned = ::std::option::Option::Some(is.read_bool()?);
},
234 => {
self.ban_reason = ::std::option::Option::Some(is.read_string()?);
},
241 => {
self.banner = ::std::option::Option::Some(is.read_fixed64()?);
},
248 => {
self.can_be_deleted = ::std::option::Option::Some(is.read_bool()?);
},
256 => {
self.incompatible = ::std::option::Option::Some(is.read_bool()?);
},
266 => {
self.app_name = ::std::option::Option::Some(is.read_string()?);
},
272 => {
self.file_type = ::std::option::Option::Some(is.read_uint32()?);
},
280 => {
self.can_subscribe = ::std::option::Option::Some(is.read_bool()?);
},
288 => {
self.subscriptions = ::std::option::Option::Some(is.read_uint32()?);
},
296 => {
self.favorited = ::std::option::Option::Some(is.read_uint32()?);
},
304 => {
self.followers = ::std::option::Option::Some(is.read_uint32()?);
},
312 => {
self.lifetime_subscriptions = ::std::option::Option::Some(is.read_uint32()?);
},
320 => {
self.lifetime_favorited = ::std::option::Option::Some(is.read_uint32()?);
},
328 => {
self.lifetime_followers = ::std::option::Option::Some(is.read_uint32()?);
},
496 => {
self.lifetime_playtime = ::std::option::Option::Some(is.read_uint64()?);
},
504 => {
self.lifetime_playtime_sessions = ::std::option::Option::Some(is.read_uint64()?);
},
336 => {
self.views = ::std::option::Option::Some(is.read_uint32()?);
},
344 => {
self.image_width = ::std::option::Option::Some(is.read_uint32()?);
},
352 => {
self.image_height = ::std::option::Option::Some(is.read_uint32()?);
},
362 => {
self.image_url = ::std::option::Option::Some(is.read_string()?);
},
368 => {
self.spoiler_tag = ::std::option::Option::Some(is.read_bool()?);
},
376 => {
self.shortcutid = ::std::option::Option::Some(is.read_uint32()?);
},
386 => {
self.shortcutname = ::std::option::Option::Some(is.read_string()?);
},
392 => {
self.num_children = ::std::option::Option::Some(is.read_uint32()?);
},
400 => {
self.num_reports = ::std::option::Option::Some(is.read_uint32()?);
},
410 => {
self.previews.push(is.read_message()?);
},
418 => {
self.tags.push(is.read_message()?);
},
426 => {
self.children.push(is.read_message()?);
},
434 => {
self.kvtags.push(is.read_message()?);
},
442 => {
::protobuf::rt::read_singular_message_into_field(is, &mut self.vote_data)?;
},
514 => {
::protobuf::rt::read_singular_message_into_field(is, &mut self.playtime_stats)?;
},
448 => {
self.time_subscribed = ::std::option::Option::Some(is.read_uint32()?);
},
458 => {
::protobuf::rt::read_singular_message_into_field(is, &mut self.for_sale_data)?;
},
466 => {
self.metadata = ::std::option::Option::Some(is.read_string()?);
},
488 => {
self.language = ::std::option::Option::Some(is.read_int32()?);
},
520 => {
self.maybe_inappropriate_sex = ::std::option::Option::Some(is.read_bool()?);
},
528 => {
self.maybe_inappropriate_violence = ::std::option::Option::Some(is.read_bool()?);
},
576 => {
self.content_descriptorids.push(is.read_enum_or_unknown()?);
},
578 => {
::protobuf::rt::read_repeated_packed_enum_or_unknown_into(is, &mut self.content_descriptorids)?
},
536 => {
self.revision_change_number = ::std::option::Option::Some(is.read_uint64()?);
},
544 => {
self.revision = ::std::option::Option::Some(is.read_enum_or_unknown()?);
},
552 => {
self.available_revisions.push(is.read_enum_or_unknown()?);
},
554 => {
::protobuf::rt::read_repeated_packed_enum_or_unknown_into(is, &mut self.available_revisions)?
},
562 => {
self.reactions.push(is.read_message()?);
},
568 => {
self.ban_text_check_result = ::std::option::Option::Some(is.read_enum_or_unknown()?);
},
589 => {
self.search_score = ::std::option::Option::Some(is.read_float()?);
},
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.result {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.publishedfileid {
my_size += ::protobuf::rt::uint64_size(2, v);
}
if let Some(v) = self.creator {
my_size += 1 + 8;
}
if let Some(v) = self.creator_appid {
my_size += ::protobuf::rt::uint32_size(4, v);
}
if let Some(v) = self.consumer_appid {
my_size += ::protobuf::rt::uint32_size(5, v);
}
if let Some(v) = self.consumer_shortcutid {
my_size += ::protobuf::rt::uint32_size(6, v);
}
if let Some(v) = self.filename.as_ref() {
my_size += ::protobuf::rt::string_size(7, &v);
}
if let Some(v) = self.file_size {
my_size += ::protobuf::rt::uint64_size(8, v);
}
if let Some(v) = self.preview_file_size {
my_size += ::protobuf::rt::uint64_size(9, v);
}
if let Some(v) = self.file_url.as_ref() {
my_size += ::protobuf::rt::string_size(10, &v);
}
if let Some(v) = self.preview_url.as_ref() {
my_size += ::protobuf::rt::string_size(11, &v);
}
if let Some(v) = self.youtubevideoid.as_ref() {
my_size += ::protobuf::rt::string_size(12, &v);
}
if let Some(v) = self.url.as_ref() {
my_size += ::protobuf::rt::string_size(13, &v);
}
if let Some(v) = self.hcontent_file {
my_size += 1 + 8;
}
if let Some(v) = self.hcontent_preview {
my_size += 1 + 8;
}
if let Some(v) = self.title.as_ref() {
my_size += ::protobuf::rt::string_size(16, &v);
}
if let Some(v) = self.file_description.as_ref() {
my_size += ::protobuf::rt::string_size(17, &v);
}
if let Some(v) = self.short_description.as_ref() {
my_size += ::protobuf::rt::string_size(18, &v);
}
if let Some(v) = self.time_created {
my_size += ::protobuf::rt::uint32_size(19, v);
}
if let Some(v) = self.time_updated {
my_size += ::protobuf::rt::uint32_size(20, v);
}
if let Some(v) = self.visibility {
my_size += ::protobuf::rt::uint32_size(21, v);
}
if let Some(v) = self.flags {
my_size += ::protobuf::rt::uint32_size(22, v);
}
if let Some(v) = self.workshop_file {
my_size += 2 + 1;
}
if let Some(v) = self.workshop_accepted {
my_size += 2 + 1;
}
if let Some(v) = self.show_subscribe_all {
my_size += 2 + 1;
}
if let Some(v) = self.num_comments_developer {
my_size += ::protobuf::rt::int32_size(26, v);
}
if let Some(v) = self.num_comments_public {
my_size += ::protobuf::rt::int32_size(27, v);
}
if let Some(v) = self.banned {
my_size += 2 + 1;
}
if let Some(v) = self.ban_reason.as_ref() {
my_size += ::protobuf::rt::string_size(29, &v);
}
if let Some(v) = self.banner {
my_size += 2 + 8;
}
if let Some(v) = self.can_be_deleted {
my_size += 2 + 1;
}
if let Some(v) = self.incompatible {
my_size += 2 + 1;
}
if let Some(v) = self.app_name.as_ref() {
my_size += ::protobuf::rt::string_size(33, &v);
}
if let Some(v) = self.file_type {
my_size += ::protobuf::rt::uint32_size(34, v);
}
if let Some(v) = self.can_subscribe {
my_size += 2 + 1;
}
if let Some(v) = self.subscriptions {
my_size += ::protobuf::rt::uint32_size(36, v);
}
if let Some(v) = self.favorited {
my_size += ::protobuf::rt::uint32_size(37, v);
}
if let Some(v) = self.followers {
my_size += ::protobuf::rt::uint32_size(38, v);
}
if let Some(v) = self.lifetime_subscriptions {
my_size += ::protobuf::rt::uint32_size(39, v);
}
if let Some(v) = self.lifetime_favorited {
my_size += ::protobuf::rt::uint32_size(40, v);
}
if let Some(v) = self.lifetime_followers {
my_size += ::protobuf::rt::uint32_size(41, v);
}
if let Some(v) = self.lifetime_playtime {
my_size += ::protobuf::rt::uint64_size(62, v);
}
if let Some(v) = self.lifetime_playtime_sessions {
my_size += ::protobuf::rt::uint64_size(63, v);
}
if let Some(v) = self.views {
my_size += ::protobuf::rt::uint32_size(42, v);
}
if let Some(v) = self.image_width {
my_size += ::protobuf::rt::uint32_size(43, v);
}
if let Some(v) = self.image_height {
my_size += ::protobuf::rt::uint32_size(44, v);
}
if let Some(v) = self.image_url.as_ref() {
my_size += ::protobuf::rt::string_size(45, &v);
}
if let Some(v) = self.spoiler_tag {
my_size += 2 + 1;
}
if let Some(v) = self.shortcutid {
my_size += ::protobuf::rt::uint32_size(47, v);
}
if let Some(v) = self.shortcutname.as_ref() {
my_size += ::protobuf::rt::string_size(48, &v);
}
if let Some(v) = self.num_children {
my_size += ::protobuf::rt::uint32_size(49, v);
}
if let Some(v) = self.num_reports {
my_size += ::protobuf::rt::uint32_size(50, v);
}
for value in &self.previews {
let len = value.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
for value in &self.tags {
let len = value.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
for value in &self.children {
let len = value.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
for value in &self.kvtags {
let len = value.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
if let Some(v) = self.vote_data.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
}
if let Some(v) = self.playtime_stats.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
}
if let Some(v) = self.time_subscribed {
my_size += ::protobuf::rt::uint32_size(56, v);
}
if let Some(v) = self.for_sale_data.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
}
if let Some(v) = self.metadata.as_ref() {
my_size += ::protobuf::rt::string_size(58, &v);
}
if let Some(v) = self.language {
my_size += ::protobuf::rt::int32_size(61, v);
}
if let Some(v) = self.maybe_inappropriate_sex {
my_size += 2 + 1;
}
if let Some(v) = self.maybe_inappropriate_violence {
my_size += 2 + 1;
}
for value in &self.content_descriptorids {
my_size += ::protobuf::rt::int32_size(72, value.value());
};
if let Some(v) = self.revision_change_number {
my_size += ::protobuf::rt::uint64_size(67, v);
}
if let Some(v) = self.revision {
my_size += ::protobuf::rt::int32_size(68, v.value());
}
for value in &self.available_revisions {
my_size += ::protobuf::rt::int32_size(69, value.value());
};
for value in &self.reactions {
let len = value.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
if let Some(v) = self.ban_text_check_result {
my_size += ::protobuf::rt::int32_size(71, v.value());
}
if let Some(v) = self.search_score {
my_size += 2 + 4;
}
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.result {
os.write_uint32(1, v)?;
}
if let Some(v) = self.publishedfileid {
os.write_uint64(2, v)?;
}
if let Some(v) = self.creator {
os.write_fixed64(3, v)?;
}
if let Some(v) = self.creator_appid {
os.write_uint32(4, v)?;
}
if let Some(v) = self.consumer_appid {
os.write_uint32(5, v)?;
}
if let Some(v) = self.consumer_shortcutid {
os.write_uint32(6, v)?;
}
if let Some(v) = self.filename.as_ref() {
os.write_string(7, v)?;
}
if let Some(v) = self.file_size {
os.write_uint64(8, v)?;
}
if let Some(v) = self.preview_file_size {
os.write_uint64(9, v)?;
}
if let Some(v) = self.file_url.as_ref() {
os.write_string(10, v)?;
}
if let Some(v) = self.preview_url.as_ref() {
os.write_string(11, v)?;
}
if let Some(v) = self.youtubevideoid.as_ref() {
os.write_string(12, v)?;
}
if let Some(v) = self.url.as_ref() {
os.write_string(13, v)?;
}
if let Some(v) = self.hcontent_file {
os.write_fixed64(14, v)?;
}
if let Some(v) = self.hcontent_preview {
os.write_fixed64(15, v)?;
}
if let Some(v) = self.title.as_ref() {
os.write_string(16, v)?;
}
if let Some(v) = self.file_description.as_ref() {
os.write_string(17, v)?;
}
if let Some(v) = self.short_description.as_ref() {
os.write_string(18, v)?;
}
if let Some(v) = self.time_created {
os.write_uint32(19, v)?;
}
if let Some(v) = self.time_updated {
os.write_uint32(20, v)?;
}
if let Some(v) = self.visibility {
os.write_uint32(21, v)?;
}
if let Some(v) = self.flags {
os.write_uint32(22, v)?;
}
if let Some(v) = self.workshop_file {
os.write_bool(23, v)?;
}
if let Some(v) = self.workshop_accepted {
os.write_bool(24, v)?;
}
if let Some(v) = self.show_subscribe_all {
os.write_bool(25, v)?;
}
if let Some(v) = self.num_comments_developer {
os.write_int32(26, v)?;
}
if let Some(v) = self.num_comments_public {
os.write_int32(27, v)?;
}
if let Some(v) = self.banned {
os.write_bool(28, v)?;
}
if let Some(v) = self.ban_reason.as_ref() {
os.write_string(29, v)?;
}
if let Some(v) = self.banner {
os.write_fixed64(30, v)?;
}
if let Some(v) = self.can_be_deleted {
os.write_bool(31, v)?;
}
if let Some(v) = self.incompatible {
os.write_bool(32, v)?;
}
if let Some(v) = self.app_name.as_ref() {
os.write_string(33, v)?;
}
if let Some(v) = self.file_type {
os.write_uint32(34, v)?;
}
if let Some(v) = self.can_subscribe {
os.write_bool(35, v)?;
}
if let Some(v) = self.subscriptions {
os.write_uint32(36, v)?;
}
if let Some(v) = self.favorited {
os.write_uint32(37, v)?;
}
if let Some(v) = self.followers {
os.write_uint32(38, v)?;
}
if let Some(v) = self.lifetime_subscriptions {
os.write_uint32(39, v)?;
}
if let Some(v) = self.lifetime_favorited {
os.write_uint32(40, v)?;
}
if let Some(v) = self.lifetime_followers {
os.write_uint32(41, v)?;
}
if let Some(v) = self.lifetime_playtime {
os.write_uint64(62, v)?;
}
if let Some(v) = self.lifetime_playtime_sessions {
os.write_uint64(63, v)?;
}
if let Some(v) = self.views {
os.write_uint32(42, v)?;
}
if let Some(v) = self.image_width {
os.write_uint32(43, v)?;
}
if let Some(v) = self.image_height {
os.write_uint32(44, v)?;
}
if let Some(v) = self.image_url.as_ref() {
os.write_string(45, v)?;
}
if let Some(v) = self.spoiler_tag {
os.write_bool(46, v)?;
}
if let Some(v) = self.shortcutid {
os.write_uint32(47, v)?;
}
if let Some(v) = self.shortcutname.as_ref() {
os.write_string(48, v)?;
}
if let Some(v) = self.num_children {
os.write_uint32(49, v)?;
}
if let Some(v) = self.num_reports {
os.write_uint32(50, v)?;
}
for v in &self.previews {
::protobuf::rt::write_message_field_with_cached_size(51, v, os)?;
};
for v in &self.tags {
::protobuf::rt::write_message_field_with_cached_size(52, v, os)?;
};
for v in &self.children {
::protobuf::rt::write_message_field_with_cached_size(53, v, os)?;
};
for v in &self.kvtags {
::protobuf::rt::write_message_field_with_cached_size(54, v, os)?;
};
if let Some(v) = self.vote_data.as_ref() {
::protobuf::rt::write_message_field_with_cached_size(55, v, os)?;
}
if let Some(v) = self.playtime_stats.as_ref() {
::protobuf::rt::write_message_field_with_cached_size(64, v, os)?;
}
if let Some(v) = self.time_subscribed {
os.write_uint32(56, v)?;
}
if let Some(v) = self.for_sale_data.as_ref() {
::protobuf::rt::write_message_field_with_cached_size(57, v, os)?;
}
if let Some(v) = self.metadata.as_ref() {
os.write_string(58, v)?;
}
if let Some(v) = self.language {
os.write_int32(61, v)?;
}
if let Some(v) = self.maybe_inappropriate_sex {
os.write_bool(65, v)?;
}
if let Some(v) = self.maybe_inappropriate_violence {
os.write_bool(66, v)?;
}
for v in &self.content_descriptorids {
os.write_enum(72, ::protobuf::EnumOrUnknown::value(v))?;
};
if let Some(v) = self.revision_change_number {
os.write_uint64(67, v)?;
}
if let Some(v) = self.revision {
os.write_enum(68, ::protobuf::EnumOrUnknown::value(&v))?;
}
for v in &self.available_revisions {
os.write_enum(69, ::protobuf::EnumOrUnknown::value(v))?;
};
for v in &self.reactions {
::protobuf::rt::write_message_field_with_cached_size(70, v, os)?;
};
if let Some(v) = self.ban_text_check_result {
os.write_enum(71, ::protobuf::EnumOrUnknown::value(&v))?;
}
if let Some(v) = self.search_score {
os.write_float(73, 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() -> PublishedFileDetails {
PublishedFileDetails::new()
}
fn clear(&mut self) {
self.result = ::std::option::Option::None;
self.publishedfileid = ::std::option::Option::None;
self.creator = ::std::option::Option::None;
self.creator_appid = ::std::option::Option::None;
self.consumer_appid = ::std::option::Option::None;
self.consumer_shortcutid = ::std::option::Option::None;
self.filename = ::std::option::Option::None;
self.file_size = ::std::option::Option::None;
self.preview_file_size = ::std::option::Option::None;
self.file_url = ::std::option::Option::None;
self.preview_url = ::std::option::Option::None;
self.youtubevideoid = ::std::option::Option::None;
self.url = ::std::option::Option::None;
self.hcontent_file = ::std::option::Option::None;
self.hcontent_preview = ::std::option::Option::None;
self.title = ::std::option::Option::None;
self.file_description = ::std::option::Option::None;
self.short_description = ::std::option::Option::None;
self.time_created = ::std::option::Option::None;
self.time_updated = ::std::option::Option::None;
self.visibility = ::std::option::Option::None;
self.flags = ::std::option::Option::None;
self.workshop_file = ::std::option::Option::None;
self.workshop_accepted = ::std::option::Option::None;
self.show_subscribe_all = ::std::option::Option::None;
self.num_comments_developer = ::std::option::Option::None;
self.num_comments_public = ::std::option::Option::None;
self.banned = ::std::option::Option::None;
self.ban_reason = ::std::option::Option::None;
self.banner = ::std::option::Option::None;
self.can_be_deleted = ::std::option::Option::None;
self.incompatible = ::std::option::Option::None;
self.app_name = ::std::option::Option::None;
self.file_type = ::std::option::Option::None;
self.can_subscribe = ::std::option::Option::None;
self.subscriptions = ::std::option::Option::None;
self.favorited = ::std::option::Option::None;
self.followers = ::std::option::Option::None;
self.lifetime_subscriptions = ::std::option::Option::None;
self.lifetime_favorited = ::std::option::Option::None;
self.lifetime_followers = ::std::option::Option::None;
self.lifetime_playtime = ::std::option::Option::None;
self.lifetime_playtime_sessions = ::std::option::Option::None;
self.views = ::std::option::Option::None;
self.image_width = ::std::option::Option::None;
self.image_height = ::std::option::Option::None;
self.image_url = ::std::option::Option::None;
self.spoiler_tag = ::std::option::Option::None;
self.shortcutid = ::std::option::Option::None;
self.shortcutname = ::std::option::Option::None;
self.num_children = ::std::option::Option::None;
self.num_reports = ::std::option::Option::None;
self.previews.clear();
self.tags.clear();
self.children.clear();
self.kvtags.clear();
self.vote_data.clear();
self.playtime_stats.clear();
self.time_subscribed = ::std::option::Option::None;
self.for_sale_data.clear();
self.metadata = ::std::option::Option::None;
self.language = ::std::option::Option::None;
self.maybe_inappropriate_sex = ::std::option::Option::None;
self.maybe_inappropriate_violence = ::std::option::Option::None;
self.content_descriptorids.clear();
self.revision_change_number = ::std::option::Option::None;
self.revision = ::std::option::Option::None;
self.available_revisions.clear();
self.reactions.clear();
self.ban_text_check_result = ::std::option::Option::None;
self.search_score = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static PublishedFileDetails {
static instance: PublishedFileDetails = PublishedFileDetails {
result: ::std::option::Option::None,
publishedfileid: ::std::option::Option::None,
creator: ::std::option::Option::None,
creator_appid: ::std::option::Option::None,
consumer_appid: ::std::option::Option::None,
consumer_shortcutid: ::std::option::Option::None,
filename: ::std::option::Option::None,
file_size: ::std::option::Option::None,
preview_file_size: ::std::option::Option::None,
file_url: ::std::option::Option::None,
preview_url: ::std::option::Option::None,
youtubevideoid: ::std::option::Option::None,
url: ::std::option::Option::None,
hcontent_file: ::std::option::Option::None,
hcontent_preview: ::std::option::Option::None,
title: ::std::option::Option::None,
file_description: ::std::option::Option::None,
short_description: ::std::option::Option::None,
time_created: ::std::option::Option::None,
time_updated: ::std::option::Option::None,
visibility: ::std::option::Option::None,
flags: ::std::option::Option::None,
workshop_file: ::std::option::Option::None,
workshop_accepted: ::std::option::Option::None,
show_subscribe_all: ::std::option::Option::None,
num_comments_developer: ::std::option::Option::None,
num_comments_public: ::std::option::Option::None,
banned: ::std::option::Option::None,
ban_reason: ::std::option::Option::None,
banner: ::std::option::Option::None,
can_be_deleted: ::std::option::Option::None,
incompatible: ::std::option::Option::None,
app_name: ::std::option::Option::None,
file_type: ::std::option::Option::None,
can_subscribe: ::std::option::Option::None,
subscriptions: ::std::option::Option::None,
favorited: ::std::option::Option::None,
followers: ::std::option::Option::None,
lifetime_subscriptions: ::std::option::Option::None,
lifetime_favorited: ::std::option::Option::None,
lifetime_followers: ::std::option::Option::None,
lifetime_playtime: ::std::option::Option::None,
lifetime_playtime_sessions: ::std::option::Option::None,
views: ::std::option::Option::None,
image_width: ::std::option::Option::None,
image_height: ::std::option::Option::None,
image_url: ::std::option::Option::None,
spoiler_tag: ::std::option::Option::None,
shortcutid: ::std::option::Option::None,
shortcutname: ::std::option::Option::None,
num_children: ::std::option::Option::None,
num_reports: ::std::option::Option::None,
previews: ::std::vec::Vec::new(),
tags: ::std::vec::Vec::new(),
children: ::std::vec::Vec::new(),
kvtags: ::std::vec::Vec::new(),
vote_data: ::protobuf::MessageField::none(),
playtime_stats: ::protobuf::MessageField::none(),
time_subscribed: ::std::option::Option::None,
for_sale_data: ::protobuf::MessageField::none(),
metadata: ::std::option::Option::None,
language: ::std::option::Option::None,
maybe_inappropriate_sex: ::std::option::Option::None,
maybe_inappropriate_violence: ::std::option::Option::None,
content_descriptorids: ::std::vec::Vec::new(),
revision_change_number: ::std::option::Option::None,
revision: ::std::option::Option::None,
available_revisions: ::std::vec::Vec::new(),
reactions: ::std::vec::Vec::new(),
ban_text_check_result: ::std::option::Option::None,
search_score: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
pub mod published_file_details {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Tag {
pub tag: ::std::option::Option<::std::string::String>,
pub adminonly: ::std::option::Option<bool>,
pub display_name: ::std::option::Option<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Tag {
fn default() -> &'a Tag {
<Tag as ::protobuf::Message>::default_instance()
}
}
impl Tag {
pub fn new() -> Tag {
::std::default::Default::default()
}
pub fn tag(&self) -> &str {
match self.tag.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_tag(&mut self) {
self.tag = ::std::option::Option::None;
}
pub fn has_tag(&self) -> bool {
self.tag.is_some()
}
pub fn set_tag(&mut self, v: ::std::string::String) {
self.tag = ::std::option::Option::Some(v);
}
pub fn mut_tag(&mut self) -> &mut ::std::string::String {
if self.tag.is_none() {
self.tag = ::std::option::Option::Some(::std::string::String::new());
}
self.tag.as_mut().unwrap()
}
pub fn take_tag(&mut self) -> ::std::string::String {
self.tag.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn adminonly(&self) -> bool {
self.adminonly.unwrap_or(false)
}
pub fn clear_adminonly(&mut self) {
self.adminonly = ::std::option::Option::None;
}
pub fn has_adminonly(&self) -> bool {
self.adminonly.is_some()
}
pub fn set_adminonly(&mut self, v: bool) {
self.adminonly = ::std::option::Option::Some(v);
}
pub fn display_name(&self) -> &str {
match self.display_name.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_display_name(&mut self) {
self.display_name = ::std::option::Option::None;
}
pub fn has_display_name(&self) -> bool {
self.display_name.is_some()
}
pub fn set_display_name(&mut self, v: ::std::string::String) {
self.display_name = ::std::option::Option::Some(v);
}
pub fn mut_display_name(&mut self) -> &mut ::std::string::String {
if self.display_name.is_none() {
self.display_name = ::std::option::Option::Some(::std::string::String::new());
}
self.display_name.as_mut().unwrap()
}
pub fn take_display_name(&mut self) -> ::std::string::String {
self.display_name.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for Tag {
const NAME: &'static str = "Tag";
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.tag = ::std::option::Option::Some(is.read_string()?);
},
16 => {
self.adminonly = ::std::option::Option::Some(is.read_bool()?);
},
26 => {
self.display_name = ::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.tag.as_ref() {
my_size += ::protobuf::rt::string_size(1, &v);
}
if let Some(v) = self.adminonly {
my_size += 1 + 1;
}
if let Some(v) = self.display_name.as_ref() {
my_size += ::protobuf::rt::string_size(3, &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.tag.as_ref() {
os.write_string(1, v)?;
}
if let Some(v) = self.adminonly {
os.write_bool(2, v)?;
}
if let Some(v) = self.display_name.as_ref() {
os.write_string(3, 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() -> Tag {
Tag::new()
}
fn clear(&mut self) {
self.tag = ::std::option::Option::None;
self.adminonly = ::std::option::Option::None;
self.display_name = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static Tag {
static instance: Tag = Tag {
tag: ::std::option::Option::None,
adminonly: ::std::option::Option::None,
display_name: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Preview {
pub previewid: ::std::option::Option<u64>,
pub sortorder: ::std::option::Option<u32>,
pub url: ::std::option::Option<::std::string::String>,
pub size: ::std::option::Option<u32>,
pub filename: ::std::option::Option<::std::string::String>,
pub youtubevideoid: ::std::option::Option<::std::string::String>,
pub preview_type: ::std::option::Option<u32>,
pub external_reference: ::std::option::Option<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Preview {
fn default() -> &'a Preview {
<Preview as ::protobuf::Message>::default_instance()
}
}
impl Preview {
pub fn new() -> Preview {
::std::default::Default::default()
}
pub fn previewid(&self) -> u64 {
self.previewid.unwrap_or(0)
}
pub fn clear_previewid(&mut self) {
self.previewid = ::std::option::Option::None;
}
pub fn has_previewid(&self) -> bool {
self.previewid.is_some()
}
pub fn set_previewid(&mut self, v: u64) {
self.previewid = ::std::option::Option::Some(v);
}
pub fn sortorder(&self) -> u32 {
self.sortorder.unwrap_or(0)
}
pub fn clear_sortorder(&mut self) {
self.sortorder = ::std::option::Option::None;
}
pub fn has_sortorder(&self) -> bool {
self.sortorder.is_some()
}
pub fn set_sortorder(&mut self, v: u32) {
self.sortorder = ::std::option::Option::Some(v);
}
pub fn url(&self) -> &str {
match self.url.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_url(&mut self) {
self.url = ::std::option::Option::None;
}
pub fn has_url(&self) -> bool {
self.url.is_some()
}
pub fn set_url(&mut self, v: ::std::string::String) {
self.url = ::std::option::Option::Some(v);
}
pub fn mut_url(&mut self) -> &mut ::std::string::String {
if self.url.is_none() {
self.url = ::std::option::Option::Some(::std::string::String::new());
}
self.url.as_mut().unwrap()
}
pub fn take_url(&mut self) -> ::std::string::String {
self.url.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn size(&self) -> u32 {
self.size.unwrap_or(0)
}
pub fn clear_size(&mut self) {
self.size = ::std::option::Option::None;
}
pub fn has_size(&self) -> bool {
self.size.is_some()
}
pub fn set_size(&mut self, v: u32) {
self.size = ::std::option::Option::Some(v);
}
pub fn filename(&self) -> &str {
match self.filename.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_filename(&mut self) {
self.filename = ::std::option::Option::None;
}
pub fn has_filename(&self) -> bool {
self.filename.is_some()
}
pub fn set_filename(&mut self, v: ::std::string::String) {
self.filename = ::std::option::Option::Some(v);
}
pub fn mut_filename(&mut self) -> &mut ::std::string::String {
if self.filename.is_none() {
self.filename = ::std::option::Option::Some(::std::string::String::new());
}
self.filename.as_mut().unwrap()
}
pub fn take_filename(&mut self) -> ::std::string::String {
self.filename.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn youtubevideoid(&self) -> &str {
match self.youtubevideoid.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_youtubevideoid(&mut self) {
self.youtubevideoid = ::std::option::Option::None;
}
pub fn has_youtubevideoid(&self) -> bool {
self.youtubevideoid.is_some()
}
pub fn set_youtubevideoid(&mut self, v: ::std::string::String) {
self.youtubevideoid = ::std::option::Option::Some(v);
}
pub fn mut_youtubevideoid(&mut self) -> &mut ::std::string::String {
if self.youtubevideoid.is_none() {
self.youtubevideoid = ::std::option::Option::Some(::std::string::String::new());
}
self.youtubevideoid.as_mut().unwrap()
}
pub fn take_youtubevideoid(&mut self) -> ::std::string::String {
self.youtubevideoid.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn preview_type(&self) -> u32 {
self.preview_type.unwrap_or(0)
}
pub fn clear_preview_type(&mut self) {
self.preview_type = ::std::option::Option::None;
}
pub fn has_preview_type(&self) -> bool {
self.preview_type.is_some()
}
pub fn set_preview_type(&mut self, v: u32) {
self.preview_type = ::std::option::Option::Some(v);
}
pub fn external_reference(&self) -> &str {
match self.external_reference.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_external_reference(&mut self) {
self.external_reference = ::std::option::Option::None;
}
pub fn has_external_reference(&self) -> bool {
self.external_reference.is_some()
}
pub fn set_external_reference(&mut self, v: ::std::string::String) {
self.external_reference = ::std::option::Option::Some(v);
}
pub fn mut_external_reference(&mut self) -> &mut ::std::string::String {
if self.external_reference.is_none() {
self.external_reference = ::std::option::Option::Some(::std::string::String::new());
}
self.external_reference.as_mut().unwrap()
}
pub fn take_external_reference(&mut self) -> ::std::string::String {
self.external_reference.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for Preview {
const NAME: &'static str = "Preview";
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.previewid = ::std::option::Option::Some(is.read_uint64()?);
},
16 => {
self.sortorder = ::std::option::Option::Some(is.read_uint32()?);
},
26 => {
self.url = ::std::option::Option::Some(is.read_string()?);
},
32 => {
self.size = ::std::option::Option::Some(is.read_uint32()?);
},
42 => {
self.filename = ::std::option::Option::Some(is.read_string()?);
},
50 => {
self.youtubevideoid = ::std::option::Option::Some(is.read_string()?);
},
56 => {
self.preview_type = ::std::option::Option::Some(is.read_uint32()?);
},
66 => {
self.external_reference = ::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.previewid {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.sortorder {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.url.as_ref() {
my_size += ::protobuf::rt::string_size(3, &v);
}
if let Some(v) = self.size {
my_size += ::protobuf::rt::uint32_size(4, v);
}
if let Some(v) = self.filename.as_ref() {
my_size += ::protobuf::rt::string_size(5, &v);
}
if let Some(v) = self.youtubevideoid.as_ref() {
my_size += ::protobuf::rt::string_size(6, &v);
}
if let Some(v) = self.preview_type {
my_size += ::protobuf::rt::uint32_size(7, v);
}
if let Some(v) = self.external_reference.as_ref() {
my_size += ::protobuf::rt::string_size(8, &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.previewid {
os.write_uint64(1, v)?;
}
if let Some(v) = self.sortorder {
os.write_uint32(2, v)?;
}
if let Some(v) = self.url.as_ref() {
os.write_string(3, v)?;
}
if let Some(v) = self.size {
os.write_uint32(4, v)?;
}
if let Some(v) = self.filename.as_ref() {
os.write_string(5, v)?;
}
if let Some(v) = self.youtubevideoid.as_ref() {
os.write_string(6, v)?;
}
if let Some(v) = self.preview_type {
os.write_uint32(7, v)?;
}
if let Some(v) = self.external_reference.as_ref() {
os.write_string(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() -> Preview {
Preview::new()
}
fn clear(&mut self) {
self.previewid = ::std::option::Option::None;
self.sortorder = ::std::option::Option::None;
self.url = ::std::option::Option::None;
self.size = ::std::option::Option::None;
self.filename = ::std::option::Option::None;
self.youtubevideoid = ::std::option::Option::None;
self.preview_type = ::std::option::Option::None;
self.external_reference = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static Preview {
static instance: Preview = Preview {
previewid: ::std::option::Option::None,
sortorder: ::std::option::Option::None,
url: ::std::option::Option::None,
size: ::std::option::Option::None,
filename: ::std::option::Option::None,
youtubevideoid: ::std::option::Option::None,
preview_type: ::std::option::Option::None,
external_reference: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Child {
pub publishedfileid: ::std::option::Option<u64>,
pub sortorder: ::std::option::Option<u32>,
pub file_type: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Child {
fn default() -> &'a Child {
<Child as ::protobuf::Message>::default_instance()
}
}
impl Child {
pub fn new() -> Child {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
pub fn sortorder(&self) -> u32 {
self.sortorder.unwrap_or(0)
}
pub fn clear_sortorder(&mut self) {
self.sortorder = ::std::option::Option::None;
}
pub fn has_sortorder(&self) -> bool {
self.sortorder.is_some()
}
pub fn set_sortorder(&mut self, v: u32) {
self.sortorder = ::std::option::Option::Some(v);
}
pub fn file_type(&self) -> u32 {
self.file_type.unwrap_or(0)
}
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: u32) {
self.file_type = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for Child {
const NAME: &'static str = "Child";
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.publishedfileid = ::std::option::Option::Some(is.read_uint64()?);
},
16 => {
self.sortorder = ::std::option::Option::Some(is.read_uint32()?);
},
24 => {
self.file_type = ::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.publishedfileid {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.sortorder {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.file_type {
my_size += ::protobuf::rt::uint32_size(3, 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.publishedfileid {
os.write_uint64(1, v)?;
}
if let Some(v) = self.sortorder {
os.write_uint32(2, v)?;
}
if let Some(v) = self.file_type {
os.write_uint32(3, 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() -> Child {
Child::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.sortorder = ::std::option::Option::None;
self.file_type = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static Child {
static instance: Child = Child {
publishedfileid: ::std::option::Option::None,
sortorder: ::std::option::Option::None,
file_type: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct KVTag {
pub key: ::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 KVTag {
fn default() -> &'a KVTag {
<KVTag as ::protobuf::Message>::default_instance()
}
}
impl KVTag {
pub fn new() -> KVTag {
::std::default::Default::default()
}
pub fn key(&self) -> &str {
match self.key.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_key(&mut self) {
self.key = ::std::option::Option::None;
}
pub fn has_key(&self) -> bool {
self.key.is_some()
}
pub fn set_key(&mut self, v: ::std::string::String) {
self.key = ::std::option::Option::Some(v);
}
pub fn mut_key(&mut self) -> &mut ::std::string::String {
if self.key.is_none() {
self.key = ::std::option::Option::Some(::std::string::String::new());
}
self.key.as_mut().unwrap()
}
pub fn take_key(&mut self) -> ::std::string::String {
self.key.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 KVTag {
const NAME: &'static str = "KVTag";
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.key = ::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.key.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.key.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() -> KVTag {
KVTag::new()
}
fn clear(&mut self) {
self.key = ::std::option::Option::None;
self.value = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static KVTag {
static instance: KVTag = KVTag {
key: ::std::option::Option::None,
value: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct VoteData {
pub score: ::std::option::Option<f32>,
pub votes_up: ::std::option::Option<u32>,
pub votes_down: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a VoteData {
fn default() -> &'a VoteData {
<VoteData as ::protobuf::Message>::default_instance()
}
}
impl VoteData {
pub fn new() -> VoteData {
::std::default::Default::default()
}
pub fn score(&self) -> f32 {
self.score.unwrap_or(0.)
}
pub fn clear_score(&mut self) {
self.score = ::std::option::Option::None;
}
pub fn has_score(&self) -> bool {
self.score.is_some()
}
pub fn set_score(&mut self, v: f32) {
self.score = ::std::option::Option::Some(v);
}
pub fn votes_up(&self) -> u32 {
self.votes_up.unwrap_or(0)
}
pub fn clear_votes_up(&mut self) {
self.votes_up = ::std::option::Option::None;
}
pub fn has_votes_up(&self) -> bool {
self.votes_up.is_some()
}
pub fn set_votes_up(&mut self, v: u32) {
self.votes_up = ::std::option::Option::Some(v);
}
pub fn votes_down(&self) -> u32 {
self.votes_down.unwrap_or(0)
}
pub fn clear_votes_down(&mut self) {
self.votes_down = ::std::option::Option::None;
}
pub fn has_votes_down(&self) -> bool {
self.votes_down.is_some()
}
pub fn set_votes_down(&mut self, v: u32) {
self.votes_down = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for VoteData {
const NAME: &'static str = "VoteData";
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 {
13 => {
self.score = ::std::option::Option::Some(is.read_float()?);
},
16 => {
self.votes_up = ::std::option::Option::Some(is.read_uint32()?);
},
24 => {
self.votes_down = ::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.score {
my_size += 1 + 4;
}
if let Some(v) = self.votes_up {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.votes_down {
my_size += ::protobuf::rt::uint32_size(3, 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.score {
os.write_float(1, v)?;
}
if let Some(v) = self.votes_up {
os.write_uint32(2, v)?;
}
if let Some(v) = self.votes_down {
os.write_uint32(3, 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() -> VoteData {
VoteData::new()
}
fn clear(&mut self) {
self.score = ::std::option::Option::None;
self.votes_up = ::std::option::Option::None;
self.votes_down = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static VoteData {
static instance: VoteData = VoteData {
score: ::std::option::Option::None,
votes_up: ::std::option::Option::None,
votes_down: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ForSaleData {
pub is_for_sale: ::std::option::Option<bool>,
pub price_category: ::std::option::Option<u32>,
pub estatus: ::std::option::Option<::protobuf::EnumOrUnknown<super::EPublishedFileForSaleStatus>>,
pub price_category_floor: ::std::option::Option<u32>,
pub price_is_pay_what_you_want: ::std::option::Option<bool>,
pub discount_percentage: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a ForSaleData {
fn default() -> &'a ForSaleData {
<ForSaleData as ::protobuf::Message>::default_instance()
}
}
impl ForSaleData {
pub fn new() -> ForSaleData {
::std::default::Default::default()
}
pub fn is_for_sale(&self) -> bool {
self.is_for_sale.unwrap_or(false)
}
pub fn clear_is_for_sale(&mut self) {
self.is_for_sale = ::std::option::Option::None;
}
pub fn has_is_for_sale(&self) -> bool {
self.is_for_sale.is_some()
}
pub fn set_is_for_sale(&mut self, v: bool) {
self.is_for_sale = ::std::option::Option::Some(v);
}
pub fn price_category(&self) -> u32 {
self.price_category.unwrap_or(0)
}
pub fn clear_price_category(&mut self) {
self.price_category = ::std::option::Option::None;
}
pub fn has_price_category(&self) -> bool {
self.price_category.is_some()
}
pub fn set_price_category(&mut self, v: u32) {
self.price_category = ::std::option::Option::Some(v);
}
pub fn estatus(&self) -> super::EPublishedFileForSaleStatus {
match self.estatus {
Some(e) => e.enum_value_or(super::EPublishedFileForSaleStatus::k_PFFSS_NotForSale),
None => super::EPublishedFileForSaleStatus::k_PFFSS_NotForSale,
}
}
pub fn clear_estatus(&mut self) {
self.estatus = ::std::option::Option::None;
}
pub fn has_estatus(&self) -> bool {
self.estatus.is_some()
}
pub fn set_estatus(&mut self, v: super::EPublishedFileForSaleStatus) {
self.estatus = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
}
pub fn price_category_floor(&self) -> u32 {
self.price_category_floor.unwrap_or(0)
}
pub fn clear_price_category_floor(&mut self) {
self.price_category_floor = ::std::option::Option::None;
}
pub fn has_price_category_floor(&self) -> bool {
self.price_category_floor.is_some()
}
pub fn set_price_category_floor(&mut self, v: u32) {
self.price_category_floor = ::std::option::Option::Some(v);
}
pub fn price_is_pay_what_you_want(&self) -> bool {
self.price_is_pay_what_you_want.unwrap_or(false)
}
pub fn clear_price_is_pay_what_you_want(&mut self) {
self.price_is_pay_what_you_want = ::std::option::Option::None;
}
pub fn has_price_is_pay_what_you_want(&self) -> bool {
self.price_is_pay_what_you_want.is_some()
}
pub fn set_price_is_pay_what_you_want(&mut self, v: bool) {
self.price_is_pay_what_you_want = ::std::option::Option::Some(v);
}
pub fn discount_percentage(&self) -> u32 {
self.discount_percentage.unwrap_or(0)
}
pub fn clear_discount_percentage(&mut self) {
self.discount_percentage = ::std::option::Option::None;
}
pub fn has_discount_percentage(&self) -> bool {
self.discount_percentage.is_some()
}
pub fn set_discount_percentage(&mut self, v: u32) {
self.discount_percentage = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for ForSaleData {
const NAME: &'static str = "ForSaleData";
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.is_for_sale = ::std::option::Option::Some(is.read_bool()?);
},
16 => {
self.price_category = ::std::option::Option::Some(is.read_uint32()?);
},
24 => {
self.estatus = ::std::option::Option::Some(is.read_enum_or_unknown()?);
},
32 => {
self.price_category_floor = ::std::option::Option::Some(is.read_uint32()?);
},
40 => {
self.price_is_pay_what_you_want = ::std::option::Option::Some(is.read_bool()?);
},
48 => {
self.discount_percentage = ::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.is_for_sale {
my_size += 1 + 1;
}
if let Some(v) = self.price_category {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.estatus {
my_size += ::protobuf::rt::int32_size(3, v.value());
}
if let Some(v) = self.price_category_floor {
my_size += ::protobuf::rt::uint32_size(4, v);
}
if let Some(v) = self.price_is_pay_what_you_want {
my_size += 1 + 1;
}
if let Some(v) = self.discount_percentage {
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.is_for_sale {
os.write_bool(1, v)?;
}
if let Some(v) = self.price_category {
os.write_uint32(2, v)?;
}
if let Some(v) = self.estatus {
os.write_enum(3, ::protobuf::EnumOrUnknown::value(&v))?;
}
if let Some(v) = self.price_category_floor {
os.write_uint32(4, v)?;
}
if let Some(v) = self.price_is_pay_what_you_want {
os.write_bool(5, v)?;
}
if let Some(v) = self.discount_percentage {
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() -> ForSaleData {
ForSaleData::new()
}
fn clear(&mut self) {
self.is_for_sale = ::std::option::Option::None;
self.price_category = ::std::option::Option::None;
self.estatus = ::std::option::Option::None;
self.price_category_floor = ::std::option::Option::None;
self.price_is_pay_what_you_want = ::std::option::Option::None;
self.discount_percentage = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static ForSaleData {
static instance: ForSaleData = ForSaleData {
is_for_sale: ::std::option::Option::None,
price_category: ::std::option::Option::None,
estatus: ::std::option::Option::None,
price_category_floor: ::std::option::Option::None,
price_is_pay_what_you_want: ::std::option::Option::None,
discount_percentage: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PlaytimeStats {
pub playtime_seconds: ::std::option::Option<u64>,
pub num_sessions: ::std::option::Option<u64>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a PlaytimeStats {
fn default() -> &'a PlaytimeStats {
<PlaytimeStats as ::protobuf::Message>::default_instance()
}
}
impl PlaytimeStats {
pub fn new() -> PlaytimeStats {
::std::default::Default::default()
}
pub fn playtime_seconds(&self) -> u64 {
self.playtime_seconds.unwrap_or(0)
}
pub fn clear_playtime_seconds(&mut self) {
self.playtime_seconds = ::std::option::Option::None;
}
pub fn has_playtime_seconds(&self) -> bool {
self.playtime_seconds.is_some()
}
pub fn set_playtime_seconds(&mut self, v: u64) {
self.playtime_seconds = ::std::option::Option::Some(v);
}
pub fn num_sessions(&self) -> u64 {
self.num_sessions.unwrap_or(0)
}
pub fn clear_num_sessions(&mut self) {
self.num_sessions = ::std::option::Option::None;
}
pub fn has_num_sessions(&self) -> bool {
self.num_sessions.is_some()
}
pub fn set_num_sessions(&mut self, v: u64) {
self.num_sessions = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for PlaytimeStats {
const NAME: &'static str = "PlaytimeStats";
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.playtime_seconds = ::std::option::Option::Some(is.read_uint64()?);
},
16 => {
self.num_sessions = ::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.playtime_seconds {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.num_sessions {
my_size += ::protobuf::rt::uint64_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.playtime_seconds {
os.write_uint64(1, v)?;
}
if let Some(v) = self.num_sessions {
os.write_uint64(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() -> PlaytimeStats {
PlaytimeStats::new()
}
fn clear(&mut self) {
self.playtime_seconds = ::std::option::Option::None;
self.num_sessions = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static PlaytimeStats {
static instance: PlaytimeStats = PlaytimeStats {
playtime_seconds: ::std::option::Option::None,
num_sessions: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Reaction {
pub reactionid: ::std::option::Option<u32>,
pub count: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Reaction {
fn default() -> &'a Reaction {
<Reaction as ::protobuf::Message>::default_instance()
}
}
impl Reaction {
pub fn new() -> Reaction {
::std::default::Default::default()
}
pub fn reactionid(&self) -> u32 {
self.reactionid.unwrap_or(0)
}
pub fn clear_reactionid(&mut self) {
self.reactionid = ::std::option::Option::None;
}
pub fn has_reactionid(&self) -> bool {
self.reactionid.is_some()
}
pub fn set_reactionid(&mut self, v: u32) {
self.reactionid = ::std::option::Option::Some(v);
}
pub fn count(&self) -> u32 {
self.count.unwrap_or(0)
}
pub fn clear_count(&mut self) {
self.count = ::std::option::Option::None;
}
pub fn has_count(&self) -> bool {
self.count.is_some()
}
pub fn set_count(&mut self, v: u32) {
self.count = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for Reaction {
const NAME: &'static str = "Reaction";
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.reactionid = ::std::option::Option::Some(is.read_uint32()?);
},
16 => {
self.count = ::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.reactionid {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.count {
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.reactionid {
os.write_uint32(1, v)?;
}
if let Some(v) = self.count {
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() -> Reaction {
Reaction::new()
}
fn clear(&mut self) {
self.reactionid = ::std::option::Option::None;
self.count = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static Reaction {
static instance: Reaction = Reaction {
reactionid: ::std::option::Option::None,
count: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_GetDetails_Response {
pub publishedfiledetails: ::std::vec::Vec<PublishedFileDetails>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetDetails_Response {
fn default() -> &'a CPublishedFile_GetDetails_Response {
<CPublishedFile_GetDetails_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetDetails_Response {
pub fn new() -> CPublishedFile_GetDetails_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_GetDetails_Response {
const NAME: &'static str = "CPublishedFile_GetDetails_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.publishedfiledetails.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.publishedfiledetails {
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.publishedfiledetails {
::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() -> CPublishedFile_GetDetails_Response {
CPublishedFile_GetDetails_Response::new()
}
fn clear(&mut self) {
self.publishedfiledetails.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetDetails_Response {
static instance: CPublishedFile_GetDetails_Response = CPublishedFile_GetDetails_Response {
publishedfiledetails: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Retrieves information about a set of published files."]
pub struct CPublishedFile_GetItemInfo_Request {
pub appid: ::std::option::Option<u32>,
pub last_time_updated: ::std::option::Option<u32>,
pub workshop_items: ::std::vec::Vec<cpublished_file_get_item_info_request::WorkshopItem>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetItemInfo_Request {
fn default() -> &'a CPublishedFile_GetItemInfo_Request {
<CPublishedFile_GetItemInfo_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetItemInfo_Request {
pub fn new() -> CPublishedFile_GetItemInfo_Request {
::std::default::Default::default()
}
pub fn appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
pub fn last_time_updated(&self) -> u32 {
self.last_time_updated.unwrap_or(0)
}
pub fn clear_last_time_updated(&mut self) {
self.last_time_updated = ::std::option::Option::None;
}
pub fn has_last_time_updated(&self) -> bool {
self.last_time_updated.is_some()
}
pub fn set_last_time_updated(&mut self, v: u32) {
self.last_time_updated = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_GetItemInfo_Request {
const NAME: &'static str = "CPublishedFile_GetItemInfo_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.appid = ::std::option::Option::Some(is.read_uint32()?);
},
16 => {
self.last_time_updated = ::std::option::Option::Some(is.read_uint32()?);
},
26 => {
self.workshop_items.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.appid {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.last_time_updated {
my_size += ::protobuf::rt::uint32_size(2, v);
}
for value in &self.workshop_items {
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.appid {
os.write_uint32(1, v)?;
}
if let Some(v) = self.last_time_updated {
os.write_uint32(2, v)?;
}
for v in &self.workshop_items {
::protobuf::rt::write_message_field_with_cached_size(3, 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() -> CPublishedFile_GetItemInfo_Request {
CPublishedFile_GetItemInfo_Request::new()
}
fn clear(&mut self) {
self.appid = ::std::option::Option::None;
self.last_time_updated = ::std::option::Option::None;
self.workshop_items.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetItemInfo_Request {
static instance: CPublishedFile_GetItemInfo_Request = CPublishedFile_GetItemInfo_Request {
appid: ::std::option::Option::None,
last_time_updated: ::std::option::Option::None,
workshop_items: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
pub mod cpublished_file_get_item_info_request {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct WorkshopItem {
pub published_file_id: ::std::option::Option<u64>,
pub time_updated: ::std::option::Option<u32>,
pub desired_revision: ::std::option::Option<::protobuf::EnumOrUnknown<super::EPublishedFileRevision>>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a WorkshopItem {
fn default() -> &'a WorkshopItem {
<WorkshopItem as ::protobuf::Message>::default_instance()
}
}
impl WorkshopItem {
pub fn new() -> WorkshopItem {
::std::default::Default::default()
}
pub fn published_file_id(&self) -> u64 {
self.published_file_id.unwrap_or(0)
}
pub fn clear_published_file_id(&mut self) {
self.published_file_id = ::std::option::Option::None;
}
pub fn has_published_file_id(&self) -> bool {
self.published_file_id.is_some()
}
pub fn set_published_file_id(&mut self, v: u64) {
self.published_file_id = ::std::option::Option::Some(v);
}
pub fn time_updated(&self) -> u32 {
self.time_updated.unwrap_or(0)
}
pub fn clear_time_updated(&mut self) {
self.time_updated = ::std::option::Option::None;
}
pub fn has_time_updated(&self) -> bool {
self.time_updated.is_some()
}
pub fn set_time_updated(&mut self, v: u32) {
self.time_updated = ::std::option::Option::Some(v);
}
pub fn desired_revision(&self) -> super::EPublishedFileRevision {
match self.desired_revision {
Some(e) => e.enum_value_or(super::EPublishedFileRevision::k_EPublishedFileRevision_Default),
None => super::EPublishedFileRevision::k_EPublishedFileRevision_Default,
}
}
pub fn clear_desired_revision(&mut self) {
self.desired_revision = ::std::option::Option::None;
}
pub fn has_desired_revision(&self) -> bool {
self.desired_revision.is_some()
}
pub fn set_desired_revision(&mut self, v: super::EPublishedFileRevision) {
self.desired_revision = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
}
}
impl ::protobuf::Message for WorkshopItem {
const NAME: &'static str = "WorkshopItem";
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 {
9 => {
self.published_file_id = ::std::option::Option::Some(is.read_fixed64()?);
},
16 => {
self.time_updated = ::std::option::Option::Some(is.read_uint32()?);
},
24 => {
self.desired_revision = ::std::option::Option::Some(is.read_enum_or_unknown()?);
},
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.published_file_id {
my_size += 1 + 8;
}
if let Some(v) = self.time_updated {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.desired_revision {
my_size += ::protobuf::rt::int32_size(3, v.value());
}
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.published_file_id {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.time_updated {
os.write_uint32(2, v)?;
}
if let Some(v) = self.desired_revision {
os.write_enum(3, ::protobuf::EnumOrUnknown::value(&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() -> WorkshopItem {
WorkshopItem::new()
}
fn clear(&mut self) {
self.published_file_id = ::std::option::Option::None;
self.time_updated = ::std::option::Option::None;
self.desired_revision = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static WorkshopItem {
static instance: WorkshopItem = WorkshopItem {
published_file_id: ::std::option::Option::None,
time_updated: ::std::option::Option::None,
desired_revision: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_GetItemInfo_Response {
pub update_time: ::std::option::Option<u32>,
pub workshop_items: ::std::vec::Vec<cpublished_file_get_item_info_response::WorkshopItemInfo>,
pub private_items: ::std::vec::Vec<u64>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetItemInfo_Response {
fn default() -> &'a CPublishedFile_GetItemInfo_Response {
<CPublishedFile_GetItemInfo_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetItemInfo_Response {
pub fn new() -> CPublishedFile_GetItemInfo_Response {
::std::default::Default::default()
}
pub fn update_time(&self) -> u32 {
self.update_time.unwrap_or(0)
}
pub fn clear_update_time(&mut self) {
self.update_time = ::std::option::Option::None;
}
pub fn has_update_time(&self) -> bool {
self.update_time.is_some()
}
pub fn set_update_time(&mut self, v: u32) {
self.update_time = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_GetItemInfo_Response {
const NAME: &'static str = "CPublishedFile_GetItemInfo_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.update_time = ::std::option::Option::Some(is.read_uint32()?);
},
18 => {
self.workshop_items.push(is.read_message()?);
},
26 => {
is.read_repeated_packed_fixed64_into(&mut self.private_items)?;
},
25 => {
self.private_items.push(is.read_fixed64()?);
},
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.update_time {
my_size += ::protobuf::rt::uint32_size(1, v);
}
for value in &self.workshop_items {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
my_size += 9 * self.private_items.len() as u64;
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.update_time {
os.write_uint32(1, v)?;
}
for v in &self.workshop_items {
::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
};
for v in &self.private_items {
os.write_fixed64(3, *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() -> CPublishedFile_GetItemInfo_Response {
CPublishedFile_GetItemInfo_Response::new()
}
fn clear(&mut self) {
self.update_time = ::std::option::Option::None;
self.workshop_items.clear();
self.private_items.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetItemInfo_Response {
static instance: CPublishedFile_GetItemInfo_Response = CPublishedFile_GetItemInfo_Response {
update_time: ::std::option::Option::None,
workshop_items: ::std::vec::Vec::new(),
private_items: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
pub mod cpublished_file_get_item_info_response {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct WorkshopItemInfo {
pub published_file_id: ::std::option::Option<u64>,
pub time_updated: ::std::option::Option<u32>,
pub manifest_id: ::std::option::Option<u64>,
pub flags: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a WorkshopItemInfo {
fn default() -> &'a WorkshopItemInfo {
<WorkshopItemInfo as ::protobuf::Message>::default_instance()
}
}
impl WorkshopItemInfo {
pub fn new() -> WorkshopItemInfo {
::std::default::Default::default()
}
pub fn published_file_id(&self) -> u64 {
self.published_file_id.unwrap_or(0)
}
pub fn clear_published_file_id(&mut self) {
self.published_file_id = ::std::option::Option::None;
}
pub fn has_published_file_id(&self) -> bool {
self.published_file_id.is_some()
}
pub fn set_published_file_id(&mut self, v: u64) {
self.published_file_id = ::std::option::Option::Some(v);
}
pub fn time_updated(&self) -> u32 {
self.time_updated.unwrap_or(0)
}
pub fn clear_time_updated(&mut self) {
self.time_updated = ::std::option::Option::None;
}
pub fn has_time_updated(&self) -> bool {
self.time_updated.is_some()
}
pub fn set_time_updated(&mut self, v: u32) {
self.time_updated = ::std::option::Option::Some(v);
}
pub fn manifest_id(&self) -> u64 {
self.manifest_id.unwrap_or(0)
}
pub fn clear_manifest_id(&mut self) {
self.manifest_id = ::std::option::Option::None;
}
pub fn has_manifest_id(&self) -> bool {
self.manifest_id.is_some()
}
pub fn set_manifest_id(&mut self, v: u64) {
self.manifest_id = ::std::option::Option::Some(v);
}
pub fn flags(&self) -> u32 {
self.flags.unwrap_or(0)
}
pub fn clear_flags(&mut self) {
self.flags = ::std::option::Option::None;
}
pub fn has_flags(&self) -> bool {
self.flags.is_some()
}
pub fn set_flags(&mut self, v: u32) {
self.flags = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for WorkshopItemInfo {
const NAME: &'static str = "WorkshopItemInfo";
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 {
9 => {
self.published_file_id = ::std::option::Option::Some(is.read_fixed64()?);
},
16 => {
self.time_updated = ::std::option::Option::Some(is.read_uint32()?);
},
25 => {
self.manifest_id = ::std::option::Option::Some(is.read_fixed64()?);
},
32 => {
self.flags = ::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.published_file_id {
my_size += 1 + 8;
}
if let Some(v) = self.time_updated {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.manifest_id {
my_size += 1 + 8;
}
if let Some(v) = self.flags {
my_size += ::protobuf::rt::uint32_size(4, 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.published_file_id {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.time_updated {
os.write_uint32(2, v)?;
}
if let Some(v) = self.manifest_id {
os.write_fixed64(3, v)?;
}
if let Some(v) = self.flags {
os.write_uint32(4, 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() -> WorkshopItemInfo {
WorkshopItemInfo::new()
}
fn clear(&mut self) {
self.published_file_id = ::std::option::Option::None;
self.time_updated = ::std::option::Option::None;
self.manifest_id = ::std::option::Option::None;
self.flags = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static WorkshopItemInfo {
static instance: WorkshopItemInfo = WorkshopItemInfo {
published_file_id: ::std::option::Option::None,
time_updated: ::std::option::Option::None,
manifest_id: ::std::option::Option::None,
flags: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Retrieves a count of files published by a user. Uses the same messages as GetUserFiles but totalonly must be true."]
pub struct CPublishedFile_GetUserFiles_Request {
pub steamid: ::std::option::Option<u64>,
pub appid: ::std::option::Option<u32>,
pub shortcutid: ::std::option::Option<u32>,
pub page: ::std::option::Option<u32>,
pub numperpage: ::std::option::Option<u32>,
pub type_: ::std::option::Option<::std::string::String>,
pub sortmethod: ::std::option::Option<::std::string::String>,
pub privacy: ::std::option::Option<u32>,
pub requiredtags: ::std::vec::Vec<::std::string::String>,
pub excludedtags: ::std::vec::Vec<::std::string::String>,
pub required_kv_tags: ::std::vec::Vec<cpublished_file_get_user_files_request::KVTag>,
pub filetype: ::std::option::Option<u32>,
pub creator_appid: ::std::option::Option<u32>,
pub match_cloud_filename: ::std::option::Option<::std::string::String>,
pub cache_max_age_seconds: ::std::option::Option<u32>,
pub language: ::std::option::Option<i32>,
pub taggroups: ::std::vec::Vec<cpublished_file_get_user_files_request::TagGroup>,
pub excluded_content_descriptors: ::std::vec::Vec<::protobuf::EnumOrUnknown<super::enums_productinfo::EContentDescriptorID>>,
pub totalonly: ::std::option::Option<bool>,
pub ids_only: ::std::option::Option<bool>,
pub return_vote_data: ::std::option::Option<bool>,
pub return_tags: ::std::option::Option<bool>,
pub return_kv_tags: ::std::option::Option<bool>,
pub return_previews: ::std::option::Option<bool>,
pub return_children: ::std::option::Option<bool>,
pub return_short_description: ::std::option::Option<bool>,
pub return_for_sale_data: ::std::option::Option<bool>,
pub return_metadata: ::std::option::Option<bool>,
pub return_playtime_stats: ::std::option::Option<u32>,
pub strip_description_bbcode: ::std::option::Option<bool>,
pub return_reactions: ::std::option::Option<bool>,
pub startindex_override: ::std::option::Option<u32>,
pub desired_revision: ::std::option::Option<::protobuf::EnumOrUnknown<EPublishedFileRevision>>,
pub return_apps: ::std::option::Option<bool>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetUserFiles_Request {
fn default() -> &'a CPublishedFile_GetUserFiles_Request {
<CPublishedFile_GetUserFiles_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetUserFiles_Request {
pub fn new() -> CPublishedFile_GetUserFiles_Request {
::std::default::Default::default()
}
pub fn steamid(&self) -> u64 {
self.steamid.unwrap_or(0)
}
pub fn clear_steamid(&mut self) {
self.steamid = ::std::option::Option::None;
}
pub fn has_steamid(&self) -> bool {
self.steamid.is_some()
}
pub fn set_steamid(&mut self, v: u64) {
self.steamid = ::std::option::Option::Some(v);
}
pub fn appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
pub fn shortcutid(&self) -> u32 {
self.shortcutid.unwrap_or(0)
}
pub fn clear_shortcutid(&mut self) {
self.shortcutid = ::std::option::Option::None;
}
pub fn has_shortcutid(&self) -> bool {
self.shortcutid.is_some()
}
pub fn set_shortcutid(&mut self, v: u32) {
self.shortcutid = ::std::option::Option::Some(v);
}
pub fn page(&self) -> u32 {
self.page.unwrap_or(1u32)
}
pub fn clear_page(&mut self) {
self.page = ::std::option::Option::None;
}
pub fn has_page(&self) -> bool {
self.page.is_some()
}
pub fn set_page(&mut self, v: u32) {
self.page = ::std::option::Option::Some(v);
}
pub fn numperpage(&self) -> u32 {
self.numperpage.unwrap_or(1u32)
}
pub fn clear_numperpage(&mut self) {
self.numperpage = ::std::option::Option::None;
}
pub fn has_numperpage(&self) -> bool {
self.numperpage.is_some()
}
pub fn set_numperpage(&mut self, v: u32) {
self.numperpage = ::std::option::Option::Some(v);
}
pub fn type_(&self) -> &str {
match self.type_.as_ref() {
Some(v) => v,
None => "myfiles",
}
}
pub fn clear_type_(&mut self) {
self.type_ = ::std::option::Option::None;
}
pub fn has_type(&self) -> bool {
self.type_.is_some()
}
pub fn set_type(&mut self, v: ::std::string::String) {
self.type_ = ::std::option::Option::Some(v);
}
pub fn mut_type(&mut self) -> &mut ::std::string::String {
if self.type_.is_none() {
self.type_ = ::std::option::Option::Some(::std::string::String::new());
}
self.type_.as_mut().unwrap()
}
pub fn take_type_(&mut self) -> ::std::string::String {
self.type_.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn sortmethod(&self) -> &str {
match self.sortmethod.as_ref() {
Some(v) => v,
None => "lastupdated",
}
}
pub fn clear_sortmethod(&mut self) {
self.sortmethod = ::std::option::Option::None;
}
pub fn has_sortmethod(&self) -> bool {
self.sortmethod.is_some()
}
pub fn set_sortmethod(&mut self, v: ::std::string::String) {
self.sortmethod = ::std::option::Option::Some(v);
}
pub fn mut_sortmethod(&mut self) -> &mut ::std::string::String {
if self.sortmethod.is_none() {
self.sortmethod = ::std::option::Option::Some(::std::string::String::new());
}
self.sortmethod.as_mut().unwrap()
}
pub fn take_sortmethod(&mut self) -> ::std::string::String {
self.sortmethod.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn privacy(&self) -> u32 {
self.privacy.unwrap_or(0)
}
pub fn clear_privacy(&mut self) {
self.privacy = ::std::option::Option::None;
}
pub fn has_privacy(&self) -> bool {
self.privacy.is_some()
}
pub fn set_privacy(&mut self, v: u32) {
self.privacy = ::std::option::Option::Some(v);
}
pub fn filetype(&self) -> u32 {
self.filetype.unwrap_or(0)
}
pub fn clear_filetype(&mut self) {
self.filetype = ::std::option::Option::None;
}
pub fn has_filetype(&self) -> bool {
self.filetype.is_some()
}
pub fn set_filetype(&mut self, v: u32) {
self.filetype = ::std::option::Option::Some(v);
}
pub fn creator_appid(&self) -> u32 {
self.creator_appid.unwrap_or(0)
}
pub fn clear_creator_appid(&mut self) {
self.creator_appid = ::std::option::Option::None;
}
pub fn has_creator_appid(&self) -> bool {
self.creator_appid.is_some()
}
pub fn set_creator_appid(&mut self, v: u32) {
self.creator_appid = ::std::option::Option::Some(v);
}
pub fn match_cloud_filename(&self) -> &str {
match self.match_cloud_filename.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_match_cloud_filename(&mut self) {
self.match_cloud_filename = ::std::option::Option::None;
}
pub fn has_match_cloud_filename(&self) -> bool {
self.match_cloud_filename.is_some()
}
pub fn set_match_cloud_filename(&mut self, v: ::std::string::String) {
self.match_cloud_filename = ::std::option::Option::Some(v);
}
pub fn mut_match_cloud_filename(&mut self) -> &mut ::std::string::String {
if self.match_cloud_filename.is_none() {
self.match_cloud_filename = ::std::option::Option::Some(::std::string::String::new());
}
self.match_cloud_filename.as_mut().unwrap()
}
pub fn take_match_cloud_filename(&mut self) -> ::std::string::String {
self.match_cloud_filename.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn cache_max_age_seconds(&self) -> u32 {
self.cache_max_age_seconds.unwrap_or(0u32)
}
pub fn clear_cache_max_age_seconds(&mut self) {
self.cache_max_age_seconds = ::std::option::Option::None;
}
pub fn has_cache_max_age_seconds(&self) -> bool {
self.cache_max_age_seconds.is_some()
}
pub fn set_cache_max_age_seconds(&mut self, v: u32) {
self.cache_max_age_seconds = ::std::option::Option::Some(v);
}
pub fn language(&self) -> i32 {
self.language.unwrap_or(0i32)
}
pub fn clear_language(&mut self) {
self.language = ::std::option::Option::None;
}
pub fn has_language(&self) -> bool {
self.language.is_some()
}
pub fn set_language(&mut self, v: i32) {
self.language = ::std::option::Option::Some(v);
}
pub fn totalonly(&self) -> bool {
self.totalonly.unwrap_or(false)
}
pub fn clear_totalonly(&mut self) {
self.totalonly = ::std::option::Option::None;
}
pub fn has_totalonly(&self) -> bool {
self.totalonly.is_some()
}
pub fn set_totalonly(&mut self, v: bool) {
self.totalonly = ::std::option::Option::Some(v);
}
pub fn ids_only(&self) -> bool {
self.ids_only.unwrap_or(false)
}
pub fn clear_ids_only(&mut self) {
self.ids_only = ::std::option::Option::None;
}
pub fn has_ids_only(&self) -> bool {
self.ids_only.is_some()
}
pub fn set_ids_only(&mut self, v: bool) {
self.ids_only = ::std::option::Option::Some(v);
}
pub fn return_vote_data(&self) -> bool {
self.return_vote_data.unwrap_or(true)
}
pub fn clear_return_vote_data(&mut self) {
self.return_vote_data = ::std::option::Option::None;
}
pub fn has_return_vote_data(&self) -> bool {
self.return_vote_data.is_some()
}
pub fn set_return_vote_data(&mut self, v: bool) {
self.return_vote_data = ::std::option::Option::Some(v);
}
pub fn return_tags(&self) -> bool {
self.return_tags.unwrap_or(false)
}
pub fn clear_return_tags(&mut self) {
self.return_tags = ::std::option::Option::None;
}
pub fn has_return_tags(&self) -> bool {
self.return_tags.is_some()
}
pub fn set_return_tags(&mut self, v: bool) {
self.return_tags = ::std::option::Option::Some(v);
}
pub fn return_kv_tags(&self) -> bool {
self.return_kv_tags.unwrap_or(true)
}
pub fn clear_return_kv_tags(&mut self) {
self.return_kv_tags = ::std::option::Option::None;
}
pub fn has_return_kv_tags(&self) -> bool {
self.return_kv_tags.is_some()
}
pub fn set_return_kv_tags(&mut self, v: bool) {
self.return_kv_tags = ::std::option::Option::Some(v);
}
pub fn return_previews(&self) -> bool {
self.return_previews.unwrap_or(false)
}
pub fn clear_return_previews(&mut self) {
self.return_previews = ::std::option::Option::None;
}
pub fn has_return_previews(&self) -> bool {
self.return_previews.is_some()
}
pub fn set_return_previews(&mut self, v: bool) {
self.return_previews = ::std::option::Option::Some(v);
}
pub fn return_children(&self) -> bool {
self.return_children.unwrap_or(false)
}
pub fn clear_return_children(&mut self) {
self.return_children = ::std::option::Option::None;
}
pub fn has_return_children(&self) -> bool {
self.return_children.is_some()
}
pub fn set_return_children(&mut self, v: bool) {
self.return_children = ::std::option::Option::Some(v);
}
pub fn return_short_description(&self) -> bool {
self.return_short_description.unwrap_or(true)
}
pub fn clear_return_short_description(&mut self) {
self.return_short_description = ::std::option::Option::None;
}
pub fn has_return_short_description(&self) -> bool {
self.return_short_description.is_some()
}
pub fn set_return_short_description(&mut self, v: bool) {
self.return_short_description = ::std::option::Option::Some(v);
}
pub fn return_for_sale_data(&self) -> bool {
self.return_for_sale_data.unwrap_or(false)
}
pub fn clear_return_for_sale_data(&mut self) {
self.return_for_sale_data = ::std::option::Option::None;
}
pub fn has_return_for_sale_data(&self) -> bool {
self.return_for_sale_data.is_some()
}
pub fn set_return_for_sale_data(&mut self, v: bool) {
self.return_for_sale_data = ::std::option::Option::Some(v);
}
pub fn return_metadata(&self) -> bool {
self.return_metadata.unwrap_or(false)
}
pub fn clear_return_metadata(&mut self) {
self.return_metadata = ::std::option::Option::None;
}
pub fn has_return_metadata(&self) -> bool {
self.return_metadata.is_some()
}
pub fn set_return_metadata(&mut self, v: bool) {
self.return_metadata = ::std::option::Option::Some(v);
}
pub fn return_playtime_stats(&self) -> u32 {
self.return_playtime_stats.unwrap_or(0)
}
pub fn clear_return_playtime_stats(&mut self) {
self.return_playtime_stats = ::std::option::Option::None;
}
pub fn has_return_playtime_stats(&self) -> bool {
self.return_playtime_stats.is_some()
}
pub fn set_return_playtime_stats(&mut self, v: u32) {
self.return_playtime_stats = ::std::option::Option::Some(v);
}
pub fn strip_description_bbcode(&self) -> bool {
self.strip_description_bbcode.unwrap_or(false)
}
pub fn clear_strip_description_bbcode(&mut self) {
self.strip_description_bbcode = ::std::option::Option::None;
}
pub fn has_strip_description_bbcode(&self) -> bool {
self.strip_description_bbcode.is_some()
}
pub fn set_strip_description_bbcode(&mut self, v: bool) {
self.strip_description_bbcode = ::std::option::Option::Some(v);
}
pub fn return_reactions(&self) -> bool {
self.return_reactions.unwrap_or(false)
}
pub fn clear_return_reactions(&mut self) {
self.return_reactions = ::std::option::Option::None;
}
pub fn has_return_reactions(&self) -> bool {
self.return_reactions.is_some()
}
pub fn set_return_reactions(&mut self, v: bool) {
self.return_reactions = ::std::option::Option::Some(v);
}
pub fn startindex_override(&self) -> u32 {
self.startindex_override.unwrap_or(0)
}
pub fn clear_startindex_override(&mut self) {
self.startindex_override = ::std::option::Option::None;
}
pub fn has_startindex_override(&self) -> bool {
self.startindex_override.is_some()
}
pub fn set_startindex_override(&mut self, v: u32) {
self.startindex_override = ::std::option::Option::Some(v);
}
pub fn desired_revision(&self) -> EPublishedFileRevision {
match self.desired_revision {
Some(e) => e.enum_value_or(EPublishedFileRevision::k_EPublishedFileRevision_Default),
None => EPublishedFileRevision::k_EPublishedFileRevision_Default,
}
}
pub fn clear_desired_revision(&mut self) {
self.desired_revision = ::std::option::Option::None;
}
pub fn has_desired_revision(&self) -> bool {
self.desired_revision.is_some()
}
pub fn set_desired_revision(&mut self, v: EPublishedFileRevision) {
self.desired_revision = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
}
pub fn return_apps(&self) -> bool {
self.return_apps.unwrap_or(false)
}
pub fn clear_return_apps(&mut self) {
self.return_apps = ::std::option::Option::None;
}
pub fn has_return_apps(&self) -> bool {
self.return_apps.is_some()
}
pub fn set_return_apps(&mut self, v: bool) {
self.return_apps = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_GetUserFiles_Request {
const NAME: &'static str = "CPublishedFile_GetUserFiles_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 {
9 => {
self.steamid = ::std::option::Option::Some(is.read_fixed64()?);
},
16 => {
self.appid = ::std::option::Option::Some(is.read_uint32()?);
},
24 => {
self.shortcutid = ::std::option::Option::Some(is.read_uint32()?);
},
32 => {
self.page = ::std::option::Option::Some(is.read_uint32()?);
},
40 => {
self.numperpage = ::std::option::Option::Some(is.read_uint32()?);
},
50 => {
self.type_ = ::std::option::Option::Some(is.read_string()?);
},
58 => {
self.sortmethod = ::std::option::Option::Some(is.read_string()?);
},
72 => {
self.privacy = ::std::option::Option::Some(is.read_uint32()?);
},
82 => {
self.requiredtags.push(is.read_string()?);
},
90 => {
self.excludedtags.push(is.read_string()?);
},
242 => {
self.required_kv_tags.push(is.read_message()?);
},
112 => {
self.filetype = ::std::option::Option::Some(is.read_uint32()?);
},
120 => {
self.creator_appid = ::std::option::Option::Some(is.read_uint32()?);
},
130 => {
self.match_cloud_filename = ::std::option::Option::Some(is.read_string()?);
},
216 => {
self.cache_max_age_seconds = ::std::option::Option::Some(is.read_uint32()?);
},
232 => {
self.language = ::std::option::Option::Some(is.read_int32()?);
},
274 => {
self.taggroups.push(is.read_message()?);
},
296 => {
self.excluded_content_descriptors.push(is.read_enum_or_unknown()?);
},
298 => {
::protobuf::rt::read_repeated_packed_enum_or_unknown_into(is, &mut self.excluded_content_descriptors)?
},
136 => {
self.totalonly = ::std::option::Option::Some(is.read_bool()?);
},
144 => {
self.ids_only = ::std::option::Option::Some(is.read_bool()?);
},
152 => {
self.return_vote_data = ::std::option::Option::Some(is.read_bool()?);
},
160 => {
self.return_tags = ::std::option::Option::Some(is.read_bool()?);
},
168 => {
self.return_kv_tags = ::std::option::Option::Some(is.read_bool()?);
},
176 => {
self.return_previews = ::std::option::Option::Some(is.read_bool()?);
},
184 => {
self.return_children = ::std::option::Option::Some(is.read_bool()?);
},
192 => {
self.return_short_description = ::std::option::Option::Some(is.read_bool()?);
},
208 => {
self.return_for_sale_data = ::std::option::Option::Some(is.read_bool()?);
},
224 => {
self.return_metadata = ::std::option::Option::Some(is.read_bool()?);
},
248 => {
self.return_playtime_stats = ::std::option::Option::Some(is.read_uint32()?);
},
256 => {
self.strip_description_bbcode = ::std::option::Option::Some(is.read_bool()?);
},
280 => {
self.return_reactions = ::std::option::Option::Some(is.read_bool()?);
},
200 => {
self.startindex_override = ::std::option::Option::Some(is.read_uint32()?);
},
264 => {
self.desired_revision = ::std::option::Option::Some(is.read_enum_or_unknown()?);
},
288 => {
self.return_apps = ::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.steamid {
my_size += 1 + 8;
}
if let Some(v) = self.appid {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.shortcutid {
my_size += ::protobuf::rt::uint32_size(3, v);
}
if let Some(v) = self.page {
my_size += ::protobuf::rt::uint32_size(4, v);
}
if let Some(v) = self.numperpage {
my_size += ::protobuf::rt::uint32_size(5, v);
}
if let Some(v) = self.type_.as_ref() {
my_size += ::protobuf::rt::string_size(6, &v);
}
if let Some(v) = self.sortmethod.as_ref() {
my_size += ::protobuf::rt::string_size(7, &v);
}
if let Some(v) = self.privacy {
my_size += ::protobuf::rt::uint32_size(9, v);
}
for value in &self.requiredtags {
my_size += ::protobuf::rt::string_size(10, &value);
};
for value in &self.excludedtags {
my_size += ::protobuf::rt::string_size(11, &value);
};
for value in &self.required_kv_tags {
let len = value.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
if let Some(v) = self.filetype {
my_size += ::protobuf::rt::uint32_size(14, v);
}
if let Some(v) = self.creator_appid {
my_size += ::protobuf::rt::uint32_size(15, v);
}
if let Some(v) = self.match_cloud_filename.as_ref() {
my_size += ::protobuf::rt::string_size(16, &v);
}
if let Some(v) = self.cache_max_age_seconds {
my_size += ::protobuf::rt::uint32_size(27, v);
}
if let Some(v) = self.language {
my_size += ::protobuf::rt::int32_size(29, v);
}
for value in &self.taggroups {
let len = value.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
for value in &self.excluded_content_descriptors {
my_size += ::protobuf::rt::int32_size(37, value.value());
};
if let Some(v) = self.totalonly {
my_size += 2 + 1;
}
if let Some(v) = self.ids_only {
my_size += 2 + 1;
}
if let Some(v) = self.return_vote_data {
my_size += 2 + 1;
}
if let Some(v) = self.return_tags {
my_size += 2 + 1;
}
if let Some(v) = self.return_kv_tags {
my_size += 2 + 1;
}
if let Some(v) = self.return_previews {
my_size += 2 + 1;
}
if let Some(v) = self.return_children {
my_size += 2 + 1;
}
if let Some(v) = self.return_short_description {
my_size += 2 + 1;
}
if let Some(v) = self.return_for_sale_data {
my_size += 2 + 1;
}
if let Some(v) = self.return_metadata {
my_size += 2 + 1;
}
if let Some(v) = self.return_playtime_stats {
my_size += ::protobuf::rt::uint32_size(31, v);
}
if let Some(v) = self.strip_description_bbcode {
my_size += 2 + 1;
}
if let Some(v) = self.return_reactions {
my_size += 2 + 1;
}
if let Some(v) = self.startindex_override {
my_size += ::protobuf::rt::uint32_size(25, v);
}
if let Some(v) = self.desired_revision {
my_size += ::protobuf::rt::int32_size(33, v.value());
}
if let Some(v) = self.return_apps {
my_size += 2 + 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.steamid {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.appid {
os.write_uint32(2, v)?;
}
if let Some(v) = self.shortcutid {
os.write_uint32(3, v)?;
}
if let Some(v) = self.page {
os.write_uint32(4, v)?;
}
if let Some(v) = self.numperpage {
os.write_uint32(5, v)?;
}
if let Some(v) = self.type_.as_ref() {
os.write_string(6, v)?;
}
if let Some(v) = self.sortmethod.as_ref() {
os.write_string(7, v)?;
}
if let Some(v) = self.privacy {
os.write_uint32(9, v)?;
}
for v in &self.requiredtags {
os.write_string(10, &v)?;
};
for v in &self.excludedtags {
os.write_string(11, &v)?;
};
for v in &self.required_kv_tags {
::protobuf::rt::write_message_field_with_cached_size(30, v, os)?;
};
if let Some(v) = self.filetype {
os.write_uint32(14, v)?;
}
if let Some(v) = self.creator_appid {
os.write_uint32(15, v)?;
}
if let Some(v) = self.match_cloud_filename.as_ref() {
os.write_string(16, v)?;
}
if let Some(v) = self.cache_max_age_seconds {
os.write_uint32(27, v)?;
}
if let Some(v) = self.language {
os.write_int32(29, v)?;
}
for v in &self.taggroups {
::protobuf::rt::write_message_field_with_cached_size(34, v, os)?;
};
for v in &self.excluded_content_descriptors {
os.write_enum(37, ::protobuf::EnumOrUnknown::value(v))?;
};
if let Some(v) = self.totalonly {
os.write_bool(17, v)?;
}
if let Some(v) = self.ids_only {
os.write_bool(18, v)?;
}
if let Some(v) = self.return_vote_data {
os.write_bool(19, v)?;
}
if let Some(v) = self.return_tags {
os.write_bool(20, v)?;
}
if let Some(v) = self.return_kv_tags {
os.write_bool(21, v)?;
}
if let Some(v) = self.return_previews {
os.write_bool(22, v)?;
}
if let Some(v) = self.return_children {
os.write_bool(23, v)?;
}
if let Some(v) = self.return_short_description {
os.write_bool(24, v)?;
}
if let Some(v) = self.return_for_sale_data {
os.write_bool(26, v)?;
}
if let Some(v) = self.return_metadata {
os.write_bool(28, v)?;
}
if let Some(v) = self.return_playtime_stats {
os.write_uint32(31, v)?;
}
if let Some(v) = self.strip_description_bbcode {
os.write_bool(32, v)?;
}
if let Some(v) = self.return_reactions {
os.write_bool(35, v)?;
}
if let Some(v) = self.startindex_override {
os.write_uint32(25, v)?;
}
if let Some(v) = self.desired_revision {
os.write_enum(33, ::protobuf::EnumOrUnknown::value(&v))?;
}
if let Some(v) = self.return_apps {
os.write_bool(36, 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() -> CPublishedFile_GetUserFiles_Request {
CPublishedFile_GetUserFiles_Request::new()
}
fn clear(&mut self) {
self.steamid = ::std::option::Option::None;
self.appid = ::std::option::Option::None;
self.shortcutid = ::std::option::Option::None;
self.page = ::std::option::Option::None;
self.numperpage = ::std::option::Option::None;
self.type_ = ::std::option::Option::None;
self.sortmethod = ::std::option::Option::None;
self.privacy = ::std::option::Option::None;
self.requiredtags.clear();
self.excludedtags.clear();
self.required_kv_tags.clear();
self.filetype = ::std::option::Option::None;
self.creator_appid = ::std::option::Option::None;
self.match_cloud_filename = ::std::option::Option::None;
self.cache_max_age_seconds = ::std::option::Option::None;
self.language = ::std::option::Option::None;
self.taggroups.clear();
self.excluded_content_descriptors.clear();
self.totalonly = ::std::option::Option::None;
self.ids_only = ::std::option::Option::None;
self.return_vote_data = ::std::option::Option::None;
self.return_tags = ::std::option::Option::None;
self.return_kv_tags = ::std::option::Option::None;
self.return_previews = ::std::option::Option::None;
self.return_children = ::std::option::Option::None;
self.return_short_description = ::std::option::Option::None;
self.return_for_sale_data = ::std::option::Option::None;
self.return_metadata = ::std::option::Option::None;
self.return_playtime_stats = ::std::option::Option::None;
self.strip_description_bbcode = ::std::option::Option::None;
self.return_reactions = ::std::option::Option::None;
self.startindex_override = ::std::option::Option::None;
self.desired_revision = ::std::option::Option::None;
self.return_apps = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetUserFiles_Request {
static instance: CPublishedFile_GetUserFiles_Request = CPublishedFile_GetUserFiles_Request {
steamid: ::std::option::Option::None,
appid: ::std::option::Option::None,
shortcutid: ::std::option::Option::None,
page: ::std::option::Option::None,
numperpage: ::std::option::Option::None,
type_: ::std::option::Option::None,
sortmethod: ::std::option::Option::None,
privacy: ::std::option::Option::None,
requiredtags: ::std::vec::Vec::new(),
excludedtags: ::std::vec::Vec::new(),
required_kv_tags: ::std::vec::Vec::new(),
filetype: ::std::option::Option::None,
creator_appid: ::std::option::Option::None,
match_cloud_filename: ::std::option::Option::None,
cache_max_age_seconds: ::std::option::Option::None,
language: ::std::option::Option::None,
taggroups: ::std::vec::Vec::new(),
excluded_content_descriptors: ::std::vec::Vec::new(),
totalonly: ::std::option::Option::None,
ids_only: ::std::option::Option::None,
return_vote_data: ::std::option::Option::None,
return_tags: ::std::option::Option::None,
return_kv_tags: ::std::option::Option::None,
return_previews: ::std::option::Option::None,
return_children: ::std::option::Option::None,
return_short_description: ::std::option::Option::None,
return_for_sale_data: ::std::option::Option::None,
return_metadata: ::std::option::Option::None,
return_playtime_stats: ::std::option::Option::None,
strip_description_bbcode: ::std::option::Option::None,
return_reactions: ::std::option::Option::None,
startindex_override: ::std::option::Option::None,
desired_revision: ::std::option::Option::None,
return_apps: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
pub mod cpublished_file_get_user_files_request {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct KVTag {
pub key: ::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 KVTag {
fn default() -> &'a KVTag {
<KVTag as ::protobuf::Message>::default_instance()
}
}
impl KVTag {
pub fn new() -> KVTag {
::std::default::Default::default()
}
pub fn key(&self) -> &str {
match self.key.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_key(&mut self) {
self.key = ::std::option::Option::None;
}
pub fn has_key(&self) -> bool {
self.key.is_some()
}
pub fn set_key(&mut self, v: ::std::string::String) {
self.key = ::std::option::Option::Some(v);
}
pub fn mut_key(&mut self) -> &mut ::std::string::String {
if self.key.is_none() {
self.key = ::std::option::Option::Some(::std::string::String::new());
}
self.key.as_mut().unwrap()
}
pub fn take_key(&mut self) -> ::std::string::String {
self.key.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 KVTag {
const NAME: &'static str = "KVTag";
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.key = ::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.key.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.key.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() -> KVTag {
KVTag::new()
}
fn clear(&mut self) {
self.key = ::std::option::Option::None;
self.value = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static KVTag {
static instance: KVTag = KVTag {
key: ::std::option::Option::None,
value: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct TagGroup {
pub tags: ::std::vec::Vec<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a TagGroup {
fn default() -> &'a TagGroup {
<TagGroup as ::protobuf::Message>::default_instance()
}
}
impl TagGroup {
pub fn new() -> TagGroup {
::std::default::Default::default()
}
}
impl ::protobuf::Message for TagGroup {
const NAME: &'static str = "TagGroup";
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.tags.push(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;
for value in &self.tags {
my_size += ::protobuf::rt::string_size(1, &value);
};
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.tags {
os.write_string(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() -> TagGroup {
TagGroup::new()
}
fn clear(&mut self) {
self.tags.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static TagGroup {
static instance: TagGroup = TagGroup {
tags: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_GetUserFiles_Response {
pub total: ::std::option::Option<u32>,
pub startindex: ::std::option::Option<u32>,
pub publishedfiledetails: ::std::vec::Vec<PublishedFileDetails>,
pub apps: ::std::vec::Vec<cpublished_file_get_user_files_response::App>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetUserFiles_Response {
fn default() -> &'a CPublishedFile_GetUserFiles_Response {
<CPublishedFile_GetUserFiles_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetUserFiles_Response {
pub fn new() -> CPublishedFile_GetUserFiles_Response {
::std::default::Default::default()
}
pub fn total(&self) -> u32 {
self.total.unwrap_or(0)
}
pub fn clear_total(&mut self) {
self.total = ::std::option::Option::None;
}
pub fn has_total(&self) -> bool {
self.total.is_some()
}
pub fn set_total(&mut self, v: u32) {
self.total = ::std::option::Option::Some(v);
}
pub fn startindex(&self) -> u32 {
self.startindex.unwrap_or(0)
}
pub fn clear_startindex(&mut self) {
self.startindex = ::std::option::Option::None;
}
pub fn has_startindex(&self) -> bool {
self.startindex.is_some()
}
pub fn set_startindex(&mut self, v: u32) {
self.startindex = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_GetUserFiles_Response {
const NAME: &'static str = "CPublishedFile_GetUserFiles_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.total = ::std::option::Option::Some(is.read_uint32()?);
},
16 => {
self.startindex = ::std::option::Option::Some(is.read_uint32()?);
},
26 => {
self.publishedfiledetails.push(is.read_message()?);
},
34 => {
self.apps.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.total {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.startindex {
my_size += ::protobuf::rt::uint32_size(2, v);
}
for value in &self.publishedfiledetails {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
for value in &self.apps {
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.total {
os.write_uint32(1, v)?;
}
if let Some(v) = self.startindex {
os.write_uint32(2, v)?;
}
for v in &self.publishedfiledetails {
::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
};
for v in &self.apps {
::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() -> CPublishedFile_GetUserFiles_Response {
CPublishedFile_GetUserFiles_Response::new()
}
fn clear(&mut self) {
self.total = ::std::option::Option::None;
self.startindex = ::std::option::Option::None;
self.publishedfiledetails.clear();
self.apps.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetUserFiles_Response {
static instance: CPublishedFile_GetUserFiles_Response = CPublishedFile_GetUserFiles_Response {
total: ::std::option::Option::None,
startindex: ::std::option::Option::None,
publishedfiledetails: ::std::vec::Vec::new(),
apps: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
pub mod cpublished_file_get_user_files_response {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct App {
pub appid: ::std::option::Option<u32>,
pub name: ::std::option::Option<::std::string::String>,
pub shortcutid: ::std::option::Option<u32>,
pub private: ::std::option::Option<bool>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a App {
fn default() -> &'a App {
<App as ::protobuf::Message>::default_instance()
}
}
impl App {
pub fn new() -> App {
::std::default::Default::default()
}
pub fn appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
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 shortcutid(&self) -> u32 {
self.shortcutid.unwrap_or(0)
}
pub fn clear_shortcutid(&mut self) {
self.shortcutid = ::std::option::Option::None;
}
pub fn has_shortcutid(&self) -> bool {
self.shortcutid.is_some()
}
pub fn set_shortcutid(&mut self, v: u32) {
self.shortcutid = ::std::option::Option::Some(v);
}
pub fn private(&self) -> bool {
self.private.unwrap_or(false)
}
pub fn clear_private(&mut self) {
self.private = ::std::option::Option::None;
}
pub fn has_private(&self) -> bool {
self.private.is_some()
}
pub fn set_private(&mut self, v: bool) {
self.private = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for App {
const NAME: &'static str = "App";
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.appid = ::std::option::Option::Some(is.read_uint32()?);
},
18 => {
self.name = ::std::option::Option::Some(is.read_string()?);
},
24 => {
self.shortcutid = ::std::option::Option::Some(is.read_uint32()?);
},
32 => {
self.private = ::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.appid {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.name.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
if let Some(v) = self.shortcutid {
my_size += ::protobuf::rt::uint32_size(3, v);
}
if let Some(v) = self.private {
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.appid {
os.write_uint32(1, v)?;
}
if let Some(v) = self.name.as_ref() {
os.write_string(2, v)?;
}
if let Some(v) = self.shortcutid {
os.write_uint32(3, v)?;
}
if let Some(v) = self.private {
os.write_bool(4, 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() -> App {
App::new()
}
fn clear(&mut self) {
self.appid = ::std::option::Option::None;
self.name = ::std::option::Option::None;
self.shortcutid = ::std::option::Option::None;
self.private = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static App {
static instance: App = App {
appid: ::std::option::Option::None,
name: ::std::option::Option::None,
shortcutid: ::std::option::Option::None,
private: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Determines which files in the given list are in a user's subscription list"]
pub struct CPublishedFile_AreFilesInSubscriptionList_Request {
pub appid: ::std::option::Option<u32>,
pub publishedfileids: ::std::vec::Vec<u64>,
pub listtype: ::std::option::Option<u32>,
pub filetype: ::std::option::Option<u32>,
pub workshopfiletype: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_AreFilesInSubscriptionList_Request {
fn default() -> &'a CPublishedFile_AreFilesInSubscriptionList_Request {
<CPublishedFile_AreFilesInSubscriptionList_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_AreFilesInSubscriptionList_Request {
pub fn new() -> CPublishedFile_AreFilesInSubscriptionList_Request {
::std::default::Default::default()
}
pub fn appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
pub fn listtype(&self) -> u32 {
self.listtype.unwrap_or(0)
}
pub fn clear_listtype(&mut self) {
self.listtype = ::std::option::Option::None;
}
pub fn has_listtype(&self) -> bool {
self.listtype.is_some()
}
pub fn set_listtype(&mut self, v: u32) {
self.listtype = ::std::option::Option::Some(v);
}
pub fn filetype(&self) -> u32 {
self.filetype.unwrap_or(0)
}
pub fn clear_filetype(&mut self) {
self.filetype = ::std::option::Option::None;
}
pub fn has_filetype(&self) -> bool {
self.filetype.is_some()
}
pub fn set_filetype(&mut self, v: u32) {
self.filetype = ::std::option::Option::Some(v);
}
pub fn workshopfiletype(&self) -> u32 {
self.workshopfiletype.unwrap_or(0)
}
pub fn clear_workshopfiletype(&mut self) {
self.workshopfiletype = ::std::option::Option::None;
}
pub fn has_workshopfiletype(&self) -> bool {
self.workshopfiletype.is_some()
}
pub fn set_workshopfiletype(&mut self, v: u32) {
self.workshopfiletype = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_AreFilesInSubscriptionList_Request {
const NAME: &'static str = "CPublishedFile_AreFilesInSubscriptionList_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.appid = ::std::option::Option::Some(is.read_uint32()?);
},
18 => {
is.read_repeated_packed_fixed64_into(&mut self.publishedfileids)?;
},
17 => {
self.publishedfileids.push(is.read_fixed64()?);
},
24 => {
self.listtype = ::std::option::Option::Some(is.read_uint32()?);
},
32 => {
self.filetype = ::std::option::Option::Some(is.read_uint32()?);
},
40 => {
self.workshopfiletype = ::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.appid {
my_size += ::protobuf::rt::uint32_size(1, v);
}
my_size += 9 * self.publishedfileids.len() as u64;
if let Some(v) = self.listtype {
my_size += ::protobuf::rt::uint32_size(3, v);
}
if let Some(v) = self.filetype {
my_size += ::protobuf::rt::uint32_size(4, v);
}
if let Some(v) = self.workshopfiletype {
my_size += ::protobuf::rt::uint32_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.appid {
os.write_uint32(1, v)?;
}
for v in &self.publishedfileids {
os.write_fixed64(2, *v)?;
};
if let Some(v) = self.listtype {
os.write_uint32(3, v)?;
}
if let Some(v) = self.filetype {
os.write_uint32(4, v)?;
}
if let Some(v) = self.workshopfiletype {
os.write_uint32(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() -> CPublishedFile_AreFilesInSubscriptionList_Request {
CPublishedFile_AreFilesInSubscriptionList_Request::new()
}
fn clear(&mut self) {
self.appid = ::std::option::Option::None;
self.publishedfileids.clear();
self.listtype = ::std::option::Option::None;
self.filetype = ::std::option::Option::None;
self.workshopfiletype = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_AreFilesInSubscriptionList_Request {
static instance: CPublishedFile_AreFilesInSubscriptionList_Request = CPublishedFile_AreFilesInSubscriptionList_Request {
appid: ::std::option::Option::None,
publishedfileids: ::std::vec::Vec::new(),
listtype: ::std::option::Option::None,
filetype: ::std::option::Option::None,
workshopfiletype: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_AreFilesInSubscriptionList_Response {
pub files: ::std::vec::Vec<cpublished_file_are_files_in_subscription_list_response::InList>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_AreFilesInSubscriptionList_Response {
fn default() -> &'a CPublishedFile_AreFilesInSubscriptionList_Response {
<CPublishedFile_AreFilesInSubscriptionList_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_AreFilesInSubscriptionList_Response {
pub fn new() -> CPublishedFile_AreFilesInSubscriptionList_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_AreFilesInSubscriptionList_Response {
const NAME: &'static str = "CPublishedFile_AreFilesInSubscriptionList_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.files.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.files {
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.files {
::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() -> CPublishedFile_AreFilesInSubscriptionList_Response {
CPublishedFile_AreFilesInSubscriptionList_Response::new()
}
fn clear(&mut self) {
self.files.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_AreFilesInSubscriptionList_Response {
static instance: CPublishedFile_AreFilesInSubscriptionList_Response = CPublishedFile_AreFilesInSubscriptionList_Response {
files: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
pub mod cpublished_file_are_files_in_subscription_list_response {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct InList {
pub publishedfileid: ::std::option::Option<u64>,
pub inlist: ::std::option::Option<bool>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a InList {
fn default() -> &'a InList {
<InList as ::protobuf::Message>::default_instance()
}
}
impl InList {
pub fn new() -> InList {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
pub fn inlist(&self) -> bool {
self.inlist.unwrap_or(false)
}
pub fn clear_inlist(&mut self) {
self.inlist = ::std::option::Option::None;
}
pub fn has_inlist(&self) -> bool {
self.inlist.is_some()
}
pub fn set_inlist(&mut self, v: bool) {
self.inlist = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for InList {
const NAME: &'static str = "InList";
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 {
9 => {
self.publishedfileid = ::std::option::Option::Some(is.read_fixed64()?);
},
16 => {
self.inlist = ::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.publishedfileid {
my_size += 1 + 8;
}
if let Some(v) = self.inlist {
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.publishedfileid {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.inlist {
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() -> InList {
InList::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.inlist = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static InList {
static instance: InList = InList {
publishedfileid: ::std::option::Option::None,
inlist: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Updates information about a published file."]
pub struct CPublishedFile_Update_Request {
pub appid: ::std::option::Option<u32>,
pub publishedfileid: ::std::option::Option<u64>,
pub title: ::std::option::Option<::std::string::String>,
pub file_description: ::std::option::Option<::std::string::String>,
pub visibility: ::std::option::Option<u32>,
pub tags: ::std::vec::Vec<::std::string::String>,
pub filename: ::std::option::Option<::std::string::String>,
pub preview_filename: ::std::option::Option<::std::string::String>,
pub spoiler_tag: ::std::option::Option<bool>,
pub image_width: ::std::option::Option<u32>,
pub image_height: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_Update_Request {
fn default() -> &'a CPublishedFile_Update_Request {
<CPublishedFile_Update_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_Update_Request {
pub fn new() -> CPublishedFile_Update_Request {
::std::default::Default::default()
}
pub fn appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
pub fn title(&self) -> &str {
match self.title.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_title(&mut self) {
self.title = ::std::option::Option::None;
}
pub fn has_title(&self) -> bool {
self.title.is_some()
}
pub fn set_title(&mut self, v: ::std::string::String) {
self.title = ::std::option::Option::Some(v);
}
pub fn mut_title(&mut self) -> &mut ::std::string::String {
if self.title.is_none() {
self.title = ::std::option::Option::Some(::std::string::String::new());
}
self.title.as_mut().unwrap()
}
pub fn take_title(&mut self) -> ::std::string::String {
self.title.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn file_description(&self) -> &str {
match self.file_description.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_file_description(&mut self) {
self.file_description = ::std::option::Option::None;
}
pub fn has_file_description(&self) -> bool {
self.file_description.is_some()
}
pub fn set_file_description(&mut self, v: ::std::string::String) {
self.file_description = ::std::option::Option::Some(v);
}
pub fn mut_file_description(&mut self) -> &mut ::std::string::String {
if self.file_description.is_none() {
self.file_description = ::std::option::Option::Some(::std::string::String::new());
}
self.file_description.as_mut().unwrap()
}
pub fn take_file_description(&mut self) -> ::std::string::String {
self.file_description.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn visibility(&self) -> u32 {
self.visibility.unwrap_or(0)
}
pub fn clear_visibility(&mut self) {
self.visibility = ::std::option::Option::None;
}
pub fn has_visibility(&self) -> bool {
self.visibility.is_some()
}
pub fn set_visibility(&mut self, v: u32) {
self.visibility = ::std::option::Option::Some(v);
}
pub fn filename(&self) -> &str {
match self.filename.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_filename(&mut self) {
self.filename = ::std::option::Option::None;
}
pub fn has_filename(&self) -> bool {
self.filename.is_some()
}
pub fn set_filename(&mut self, v: ::std::string::String) {
self.filename = ::std::option::Option::Some(v);
}
pub fn mut_filename(&mut self) -> &mut ::std::string::String {
if self.filename.is_none() {
self.filename = ::std::option::Option::Some(::std::string::String::new());
}
self.filename.as_mut().unwrap()
}
pub fn take_filename(&mut self) -> ::std::string::String {
self.filename.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn preview_filename(&self) -> &str {
match self.preview_filename.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_preview_filename(&mut self) {
self.preview_filename = ::std::option::Option::None;
}
pub fn has_preview_filename(&self) -> bool {
self.preview_filename.is_some()
}
pub fn set_preview_filename(&mut self, v: ::std::string::String) {
self.preview_filename = ::std::option::Option::Some(v);
}
pub fn mut_preview_filename(&mut self) -> &mut ::std::string::String {
if self.preview_filename.is_none() {
self.preview_filename = ::std::option::Option::Some(::std::string::String::new());
}
self.preview_filename.as_mut().unwrap()
}
pub fn take_preview_filename(&mut self) -> ::std::string::String {
self.preview_filename.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn spoiler_tag(&self) -> bool {
self.spoiler_tag.unwrap_or(false)
}
pub fn clear_spoiler_tag(&mut self) {
self.spoiler_tag = ::std::option::Option::None;
}
pub fn has_spoiler_tag(&self) -> bool {
self.spoiler_tag.is_some()
}
pub fn set_spoiler_tag(&mut self, v: bool) {
self.spoiler_tag = ::std::option::Option::Some(v);
}
pub fn image_width(&self) -> u32 {
self.image_width.unwrap_or(0)
}
pub fn clear_image_width(&mut self) {
self.image_width = ::std::option::Option::None;
}
pub fn has_image_width(&self) -> bool {
self.image_width.is_some()
}
pub fn set_image_width(&mut self, v: u32) {
self.image_width = ::std::option::Option::Some(v);
}
pub fn image_height(&self) -> u32 {
self.image_height.unwrap_or(0)
}
pub fn clear_image_height(&mut self) {
self.image_height = ::std::option::Option::None;
}
pub fn has_image_height(&self) -> bool {
self.image_height.is_some()
}
pub fn set_image_height(&mut self, v: u32) {
self.image_height = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_Update_Request {
const NAME: &'static str = "CPublishedFile_Update_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.appid = ::std::option::Option::Some(is.read_uint32()?);
},
17 => {
self.publishedfileid = ::std::option::Option::Some(is.read_fixed64()?);
},
26 => {
self.title = ::std::option::Option::Some(is.read_string()?);
},
34 => {
self.file_description = ::std::option::Option::Some(is.read_string()?);
},
40 => {
self.visibility = ::std::option::Option::Some(is.read_uint32()?);
},
50 => {
self.tags.push(is.read_string()?);
},
58 => {
self.filename = ::std::option::Option::Some(is.read_string()?);
},
66 => {
self.preview_filename = ::std::option::Option::Some(is.read_string()?);
},
80 => {
self.spoiler_tag = ::std::option::Option::Some(is.read_bool()?);
},
120 => {
self.image_width = ::std::option::Option::Some(is.read_uint32()?);
},
128 => {
self.image_height = ::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.appid {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.publishedfileid {
my_size += 1 + 8;
}
if let Some(v) = self.title.as_ref() {
my_size += ::protobuf::rt::string_size(3, &v);
}
if let Some(v) = self.file_description.as_ref() {
my_size += ::protobuf::rt::string_size(4, &v);
}
if let Some(v) = self.visibility {
my_size += ::protobuf::rt::uint32_size(5, v);
}
for value in &self.tags {
my_size += ::protobuf::rt::string_size(6, &value);
};
if let Some(v) = self.filename.as_ref() {
my_size += ::protobuf::rt::string_size(7, &v);
}
if let Some(v) = self.preview_filename.as_ref() {
my_size += ::protobuf::rt::string_size(8, &v);
}
if let Some(v) = self.spoiler_tag {
my_size += 1 + 1;
}
if let Some(v) = self.image_width {
my_size += ::protobuf::rt::uint32_size(15, v);
}
if let Some(v) = self.image_height {
my_size += ::protobuf::rt::uint32_size(16, 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.appid {
os.write_uint32(1, v)?;
}
if let Some(v) = self.publishedfileid {
os.write_fixed64(2, v)?;
}
if let Some(v) = self.title.as_ref() {
os.write_string(3, v)?;
}
if let Some(v) = self.file_description.as_ref() {
os.write_string(4, v)?;
}
if let Some(v) = self.visibility {
os.write_uint32(5, v)?;
}
for v in &self.tags {
os.write_string(6, &v)?;
};
if let Some(v) = self.filename.as_ref() {
os.write_string(7, v)?;
}
if let Some(v) = self.preview_filename.as_ref() {
os.write_string(8, v)?;
}
if let Some(v) = self.spoiler_tag {
os.write_bool(10, v)?;
}
if let Some(v) = self.image_width {
os.write_uint32(15, v)?;
}
if let Some(v) = self.image_height {
os.write_uint32(16, 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() -> CPublishedFile_Update_Request {
CPublishedFile_Update_Request::new()
}
fn clear(&mut self) {
self.appid = ::std::option::Option::None;
self.publishedfileid = ::std::option::Option::None;
self.title = ::std::option::Option::None;
self.file_description = ::std::option::Option::None;
self.visibility = ::std::option::Option::None;
self.tags.clear();
self.filename = ::std::option::Option::None;
self.preview_filename = ::std::option::Option::None;
self.spoiler_tag = ::std::option::Option::None;
self.image_width = ::std::option::Option::None;
self.image_height = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_Update_Request {
static instance: CPublishedFile_Update_Request = CPublishedFile_Update_Request {
appid: ::std::option::Option::None,
publishedfileid: ::std::option::Option::None,
title: ::std::option::Option::None,
file_description: ::std::option::Option::None,
visibility: ::std::option::Option::None,
tags: ::std::vec::Vec::new(),
filename: ::std::option::Option::None,
preview_filename: ::std::option::Option::None,
spoiler_tag: ::std::option::Option::None,
image_width: ::std::option::Option::None,
image_height: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_Update_Response {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_Update_Response {
fn default() -> &'a CPublishedFile_Update_Response {
<CPublishedFile_Update_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_Update_Response {
pub fn new() -> CPublishedFile_Update_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_Update_Response {
const NAME: &'static str = "CPublishedFile_Update_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() -> CPublishedFile_Update_Response {
CPublishedFile_Update_Response::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_Update_Response {
static instance: CPublishedFile_Update_Response = CPublishedFile_Update_Response {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Deletes a published file."]
pub struct CPublishedFile_Delete_Request {
pub publishedfileid: ::std::option::Option<u64>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_Delete_Request {
fn default() -> &'a CPublishedFile_Delete_Request {
<CPublishedFile_Delete_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_Delete_Request {
pub fn new() -> CPublishedFile_Delete_Request {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_Delete_Request {
const NAME: &'static str = "CPublishedFile_Delete_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 {
9 => {
self.publishedfileid = ::std::option::Option::Some(is.read_fixed64()?);
},
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.publishedfileid {
my_size += 1 + 8;
}
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.publishedfileid {
os.write_fixed64(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() -> CPublishedFile_Delete_Request {
CPublishedFile_Delete_Request::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_Delete_Request {
static instance: CPublishedFile_Delete_Request = CPublishedFile_Delete_Request {
publishedfileid: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_Delete_Response {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_Delete_Response {
fn default() -> &'a CPublishedFile_Delete_Response {
<CPublishedFile_Delete_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_Delete_Response {
pub fn new() -> CPublishedFile_Delete_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_Delete_Response {
const NAME: &'static str = "CPublishedFile_Delete_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() -> CPublishedFile_Delete_Response {
CPublishedFile_Delete_Response::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_Delete_Response {
static instance: CPublishedFile_Delete_Response = CPublishedFile_Delete_Response {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Returns data on a specific change history entry for a published file"]
pub struct CPublishedFile_GetChangeHistoryEntry_Request {
pub publishedfileid: ::std::option::Option<u64>,
pub timestamp: ::std::option::Option<u32>,
pub language: ::std::option::Option<i32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetChangeHistoryEntry_Request {
fn default() -> &'a CPublishedFile_GetChangeHistoryEntry_Request {
<CPublishedFile_GetChangeHistoryEntry_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetChangeHistoryEntry_Request {
pub fn new() -> CPublishedFile_GetChangeHistoryEntry_Request {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
pub fn timestamp(&self) -> u32 {
self.timestamp.unwrap_or(0)
}
pub fn clear_timestamp(&mut self) {
self.timestamp = ::std::option::Option::None;
}
pub fn has_timestamp(&self) -> bool {
self.timestamp.is_some()
}
pub fn set_timestamp(&mut self, v: u32) {
self.timestamp = ::std::option::Option::Some(v);
}
pub fn language(&self) -> i32 {
self.language.unwrap_or(0)
}
pub fn clear_language(&mut self) {
self.language = ::std::option::Option::None;
}
pub fn has_language(&self) -> bool {
self.language.is_some()
}
pub fn set_language(&mut self, v: i32) {
self.language = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_GetChangeHistoryEntry_Request {
const NAME: &'static str = "CPublishedFile_GetChangeHistoryEntry_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 {
9 => {
self.publishedfileid = ::std::option::Option::Some(is.read_fixed64()?);
},
16 => {
self.timestamp = ::std::option::Option::Some(is.read_uint32()?);
},
24 => {
self.language = ::std::option::Option::Some(is.read_int32()?);
},
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.publishedfileid {
my_size += 1 + 8;
}
if let Some(v) = self.timestamp {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.language {
my_size += ::protobuf::rt::int32_size(3, 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.publishedfileid {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.timestamp {
os.write_uint32(2, v)?;
}
if let Some(v) = self.language {
os.write_int32(3, 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() -> CPublishedFile_GetChangeHistoryEntry_Request {
CPublishedFile_GetChangeHistoryEntry_Request::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.timestamp = ::std::option::Option::None;
self.language = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetChangeHistoryEntry_Request {
static instance: CPublishedFile_GetChangeHistoryEntry_Request = CPublishedFile_GetChangeHistoryEntry_Request {
publishedfileid: ::std::option::Option::None,
timestamp: ::std::option::Option::None,
language: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_GetChangeHistoryEntry_Response {
pub change_description: ::std::option::Option<::std::string::String>,
pub language: ::std::option::Option<i32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetChangeHistoryEntry_Response {
fn default() -> &'a CPublishedFile_GetChangeHistoryEntry_Response {
<CPublishedFile_GetChangeHistoryEntry_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetChangeHistoryEntry_Response {
pub fn new() -> CPublishedFile_GetChangeHistoryEntry_Response {
::std::default::Default::default()
}
pub fn change_description(&self) -> &str {
match self.change_description.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_change_description(&mut self) {
self.change_description = ::std::option::Option::None;
}
pub fn has_change_description(&self) -> bool {
self.change_description.is_some()
}
pub fn set_change_description(&mut self, v: ::std::string::String) {
self.change_description = ::std::option::Option::Some(v);
}
pub fn mut_change_description(&mut self) -> &mut ::std::string::String {
if self.change_description.is_none() {
self.change_description = ::std::option::Option::Some(::std::string::String::new());
}
self.change_description.as_mut().unwrap()
}
pub fn take_change_description(&mut self) -> ::std::string::String {
self.change_description.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn language(&self) -> i32 {
self.language.unwrap_or(0)
}
pub fn clear_language(&mut self) {
self.language = ::std::option::Option::None;
}
pub fn has_language(&self) -> bool {
self.language.is_some()
}
pub fn set_language(&mut self, v: i32) {
self.language = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_GetChangeHistoryEntry_Response {
const NAME: &'static str = "CPublishedFile_GetChangeHistoryEntry_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.change_description = ::std::option::Option::Some(is.read_string()?);
},
16 => {
self.language = ::std::option::Option::Some(is.read_int32()?);
},
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.change_description.as_ref() {
my_size += ::protobuf::rt::string_size(1, &v);
}
if let Some(v) = self.language {
my_size += ::protobuf::rt::int32_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.change_description.as_ref() {
os.write_string(1, v)?;
}
if let Some(v) = self.language {
os.write_int32(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() -> CPublishedFile_GetChangeHistoryEntry_Response {
CPublishedFile_GetChangeHistoryEntry_Response::new()
}
fn clear(&mut self) {
self.change_description = ::std::option::Option::None;
self.language = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetChangeHistoryEntry_Response {
static instance: CPublishedFile_GetChangeHistoryEntry_Response = CPublishedFile_GetChangeHistoryEntry_Response {
change_description: ::std::option::Option::None,
language: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Returns data on the change history for a published file"]
pub struct CPublishedFile_GetChangeHistory_Request {
pub publishedfileid: ::std::option::Option<u64>,
pub total_only: ::std::option::Option<bool>,
pub startindex: ::std::option::Option<u32>,
pub count: ::std::option::Option<u32>,
pub language: ::std::option::Option<i32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetChangeHistory_Request {
fn default() -> &'a CPublishedFile_GetChangeHistory_Request {
<CPublishedFile_GetChangeHistory_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetChangeHistory_Request {
pub fn new() -> CPublishedFile_GetChangeHistory_Request {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
pub fn total_only(&self) -> bool {
self.total_only.unwrap_or(false)
}
pub fn clear_total_only(&mut self) {
self.total_only = ::std::option::Option::None;
}
pub fn has_total_only(&self) -> bool {
self.total_only.is_some()
}
pub fn set_total_only(&mut self, v: bool) {
self.total_only = ::std::option::Option::Some(v);
}
pub fn startindex(&self) -> u32 {
self.startindex.unwrap_or(0)
}
pub fn clear_startindex(&mut self) {
self.startindex = ::std::option::Option::None;
}
pub fn has_startindex(&self) -> bool {
self.startindex.is_some()
}
pub fn set_startindex(&mut self, v: u32) {
self.startindex = ::std::option::Option::Some(v);
}
pub fn count(&self) -> u32 {
self.count.unwrap_or(0)
}
pub fn clear_count(&mut self) {
self.count = ::std::option::Option::None;
}
pub fn has_count(&self) -> bool {
self.count.is_some()
}
pub fn set_count(&mut self, v: u32) {
self.count = ::std::option::Option::Some(v);
}
pub fn language(&self) -> i32 {
self.language.unwrap_or(0i32)
}
pub fn clear_language(&mut self) {
self.language = ::std::option::Option::None;
}
pub fn has_language(&self) -> bool {
self.language.is_some()
}
pub fn set_language(&mut self, v: i32) {
self.language = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_GetChangeHistory_Request {
const NAME: &'static str = "CPublishedFile_GetChangeHistory_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 {
9 => {
self.publishedfileid = ::std::option::Option::Some(is.read_fixed64()?);
},
16 => {
self.total_only = ::std::option::Option::Some(is.read_bool()?);
},
24 => {
self.startindex = ::std::option::Option::Some(is.read_uint32()?);
},
32 => {
self.count = ::std::option::Option::Some(is.read_uint32()?);
},
40 => {
self.language = ::std::option::Option::Some(is.read_int32()?);
},
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.publishedfileid {
my_size += 1 + 8;
}
if let Some(v) = self.total_only {
my_size += 1 + 1;
}
if let Some(v) = self.startindex {
my_size += ::protobuf::rt::uint32_size(3, v);
}
if let Some(v) = self.count {
my_size += ::protobuf::rt::uint32_size(4, v);
}
if let Some(v) = self.language {
my_size += ::protobuf::rt::int32_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.publishedfileid {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.total_only {
os.write_bool(2, v)?;
}
if let Some(v) = self.startindex {
os.write_uint32(3, v)?;
}
if let Some(v) = self.count {
os.write_uint32(4, v)?;
}
if let Some(v) = self.language {
os.write_int32(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() -> CPublishedFile_GetChangeHistory_Request {
CPublishedFile_GetChangeHistory_Request::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.total_only = ::std::option::Option::None;
self.startindex = ::std::option::Option::None;
self.count = ::std::option::Option::None;
self.language = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetChangeHistory_Request {
static instance: CPublishedFile_GetChangeHistory_Request = CPublishedFile_GetChangeHistory_Request {
publishedfileid: ::std::option::Option::None,
total_only: ::std::option::Option::None,
startindex: ::std::option::Option::None,
count: ::std::option::Option::None,
language: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_GetChangeHistory_Response {
pub changes: ::std::vec::Vec<cpublished_file_get_change_history_response::ChangeLog>,
pub total: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetChangeHistory_Response {
fn default() -> &'a CPublishedFile_GetChangeHistory_Response {
<CPublishedFile_GetChangeHistory_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetChangeHistory_Response {
pub fn new() -> CPublishedFile_GetChangeHistory_Response {
::std::default::Default::default()
}
pub fn total(&self) -> u32 {
self.total.unwrap_or(0)
}
pub fn clear_total(&mut self) {
self.total = ::std::option::Option::None;
}
pub fn has_total(&self) -> bool {
self.total.is_some()
}
pub fn set_total(&mut self, v: u32) {
self.total = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_GetChangeHistory_Response {
const NAME: &'static str = "CPublishedFile_GetChangeHistory_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.changes.push(is.read_message()?);
},
16 => {
self.total = ::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.changes {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
if let Some(v) = self.total {
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.changes {
::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
};
if let Some(v) = self.total {
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() -> CPublishedFile_GetChangeHistory_Response {
CPublishedFile_GetChangeHistory_Response::new()
}
fn clear(&mut self) {
self.changes.clear();
self.total = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetChangeHistory_Response {
static instance: CPublishedFile_GetChangeHistory_Response = CPublishedFile_GetChangeHistory_Response {
changes: ::std::vec::Vec::new(),
total: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
pub mod cpublished_file_get_change_history_response {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ChangeLog {
pub timestamp: ::std::option::Option<u32>,
pub change_description: ::std::option::Option<::std::string::String>,
pub language: ::std::option::Option<i32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a ChangeLog {
fn default() -> &'a ChangeLog {
<ChangeLog as ::protobuf::Message>::default_instance()
}
}
impl ChangeLog {
pub fn new() -> ChangeLog {
::std::default::Default::default()
}
pub fn timestamp(&self) -> u32 {
self.timestamp.unwrap_or(0)
}
pub fn clear_timestamp(&mut self) {
self.timestamp = ::std::option::Option::None;
}
pub fn has_timestamp(&self) -> bool {
self.timestamp.is_some()
}
pub fn set_timestamp(&mut self, v: u32) {
self.timestamp = ::std::option::Option::Some(v);
}
pub fn change_description(&self) -> &str {
match self.change_description.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_change_description(&mut self) {
self.change_description = ::std::option::Option::None;
}
pub fn has_change_description(&self) -> bool {
self.change_description.is_some()
}
pub fn set_change_description(&mut self, v: ::std::string::String) {
self.change_description = ::std::option::Option::Some(v);
}
pub fn mut_change_description(&mut self) -> &mut ::std::string::String {
if self.change_description.is_none() {
self.change_description = ::std::option::Option::Some(::std::string::String::new());
}
self.change_description.as_mut().unwrap()
}
pub fn take_change_description(&mut self) -> ::std::string::String {
self.change_description.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn language(&self) -> i32 {
self.language.unwrap_or(0)
}
pub fn clear_language(&mut self) {
self.language = ::std::option::Option::None;
}
pub fn has_language(&self) -> bool {
self.language.is_some()
}
pub fn set_language(&mut self, v: i32) {
self.language = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for ChangeLog {
const NAME: &'static str = "ChangeLog";
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.timestamp = ::std::option::Option::Some(is.read_uint32()?);
},
18 => {
self.change_description = ::std::option::Option::Some(is.read_string()?);
},
24 => {
self.language = ::std::option::Option::Some(is.read_int32()?);
},
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.timestamp {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.change_description.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
if let Some(v) = self.language {
my_size += ::protobuf::rt::int32_size(3, 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.timestamp {
os.write_uint32(1, v)?;
}
if let Some(v) = self.change_description.as_ref() {
os.write_string(2, v)?;
}
if let Some(v) = self.language {
os.write_int32(3, 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() -> ChangeLog {
ChangeLog::new()
}
fn clear(&mut self) {
self.timestamp = ::std::option::Option::None;
self.change_description = ::std::option::Option::None;
self.language = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static ChangeLog {
static instance: ChangeLog = ChangeLog {
timestamp: ::std::option::Option::None,
change_description: ::std::option::Option::None,
language: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Refresh the voting queue for the user"]
pub struct CPublishedFile_RefreshVotingQueue_Request {
pub appid: ::std::option::Option<u32>,
pub matching_file_type: ::std::option::Option<u32>,
pub tags: ::std::vec::Vec<::std::string::String>,
pub match_all_tags: ::std::option::Option<bool>,
pub excluded_tags: ::std::vec::Vec<::std::string::String>,
pub desired_queue_size: ::std::option::Option<u32>,
pub desired_revision: ::std::option::Option<::protobuf::EnumOrUnknown<EPublishedFileRevision>>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_RefreshVotingQueue_Request {
fn default() -> &'a CPublishedFile_RefreshVotingQueue_Request {
<CPublishedFile_RefreshVotingQueue_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_RefreshVotingQueue_Request {
pub fn new() -> CPublishedFile_RefreshVotingQueue_Request {
::std::default::Default::default()
}
pub fn appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
pub fn matching_file_type(&self) -> u32 {
self.matching_file_type.unwrap_or(0)
}
pub fn clear_matching_file_type(&mut self) {
self.matching_file_type = ::std::option::Option::None;
}
pub fn has_matching_file_type(&self) -> bool {
self.matching_file_type.is_some()
}
pub fn set_matching_file_type(&mut self, v: u32) {
self.matching_file_type = ::std::option::Option::Some(v);
}
pub fn match_all_tags(&self) -> bool {
self.match_all_tags.unwrap_or(true)
}
pub fn clear_match_all_tags(&mut self) {
self.match_all_tags = ::std::option::Option::None;
}
pub fn has_match_all_tags(&self) -> bool {
self.match_all_tags.is_some()
}
pub fn set_match_all_tags(&mut self, v: bool) {
self.match_all_tags = ::std::option::Option::Some(v);
}
pub fn desired_queue_size(&self) -> u32 {
self.desired_queue_size.unwrap_or(0)
}
pub fn clear_desired_queue_size(&mut self) {
self.desired_queue_size = ::std::option::Option::None;
}
pub fn has_desired_queue_size(&self) -> bool {
self.desired_queue_size.is_some()
}
pub fn set_desired_queue_size(&mut self, v: u32) {
self.desired_queue_size = ::std::option::Option::Some(v);
}
pub fn desired_revision(&self) -> EPublishedFileRevision {
match self.desired_revision {
Some(e) => e.enum_value_or(EPublishedFileRevision::k_EPublishedFileRevision_Default),
None => EPublishedFileRevision::k_EPublishedFileRevision_Default,
}
}
pub fn clear_desired_revision(&mut self) {
self.desired_revision = ::std::option::Option::None;
}
pub fn has_desired_revision(&self) -> bool {
self.desired_revision.is_some()
}
pub fn set_desired_revision(&mut self, v: EPublishedFileRevision) {
self.desired_revision = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
}
}
impl ::protobuf::Message for CPublishedFile_RefreshVotingQueue_Request {
const NAME: &'static str = "CPublishedFile_RefreshVotingQueue_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.appid = ::std::option::Option::Some(is.read_uint32()?);
},
16 => {
self.matching_file_type = ::std::option::Option::Some(is.read_uint32()?);
},
26 => {
self.tags.push(is.read_string()?);
},
32 => {
self.match_all_tags = ::std::option::Option::Some(is.read_bool()?);
},
42 => {
self.excluded_tags.push(is.read_string()?);
},
48 => {
self.desired_queue_size = ::std::option::Option::Some(is.read_uint32()?);
},
64 => {
self.desired_revision = ::std::option::Option::Some(is.read_enum_or_unknown()?);
},
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.appid {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.matching_file_type {
my_size += ::protobuf::rt::uint32_size(2, v);
}
for value in &self.tags {
my_size += ::protobuf::rt::string_size(3, &value);
};
if let Some(v) = self.match_all_tags {
my_size += 1 + 1;
}
for value in &self.excluded_tags {
my_size += ::protobuf::rt::string_size(5, &value);
};
if let Some(v) = self.desired_queue_size {
my_size += ::protobuf::rt::uint32_size(6, v);
}
if let Some(v) = self.desired_revision {
my_size += ::protobuf::rt::int32_size(8, v.value());
}
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.appid {
os.write_uint32(1, v)?;
}
if let Some(v) = self.matching_file_type {
os.write_uint32(2, v)?;
}
for v in &self.tags {
os.write_string(3, &v)?;
};
if let Some(v) = self.match_all_tags {
os.write_bool(4, v)?;
}
for v in &self.excluded_tags {
os.write_string(5, &v)?;
};
if let Some(v) = self.desired_queue_size {
os.write_uint32(6, v)?;
}
if let Some(v) = self.desired_revision {
os.write_enum(8, ::protobuf::EnumOrUnknown::value(&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() -> CPublishedFile_RefreshVotingQueue_Request {
CPublishedFile_RefreshVotingQueue_Request::new()
}
fn clear(&mut self) {
self.appid = ::std::option::Option::None;
self.matching_file_type = ::std::option::Option::None;
self.tags.clear();
self.match_all_tags = ::std::option::Option::None;
self.excluded_tags.clear();
self.desired_queue_size = ::std::option::Option::None;
self.desired_revision = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_RefreshVotingQueue_Request {
static instance: CPublishedFile_RefreshVotingQueue_Request = CPublishedFile_RefreshVotingQueue_Request {
appid: ::std::option::Option::None,
matching_file_type: ::std::option::Option::None,
tags: ::std::vec::Vec::new(),
match_all_tags: ::std::option::Option::None,
excluded_tags: ::std::vec::Vec::new(),
desired_queue_size: ::std::option::Option::None,
desired_revision: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_RefreshVotingQueue_Response {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_RefreshVotingQueue_Response {
fn default() -> &'a CPublishedFile_RefreshVotingQueue_Response {
<CPublishedFile_RefreshVotingQueue_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_RefreshVotingQueue_Response {
pub fn new() -> CPublishedFile_RefreshVotingQueue_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_RefreshVotingQueue_Response {
const NAME: &'static str = "CPublishedFile_RefreshVotingQueue_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() -> CPublishedFile_RefreshVotingQueue_Response {
CPublishedFile_RefreshVotingQueue_Response::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_RefreshVotingQueue_Response {
static instance: CPublishedFile_RefreshVotingQueue_Response = CPublishedFile_RefreshVotingQueue_Response {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Performs a search query for published files"]
pub struct CPublishedFile_QueryFiles_Request {
pub query_type: ::std::option::Option<u32>,
pub page: ::std::option::Option<u32>,
pub cursor: ::std::option::Option<::std::string::String>,
pub numperpage: ::std::option::Option<u32>,
pub creator_appid: ::std::option::Option<u32>,
pub appid: ::std::option::Option<u32>,
pub requiredtags: ::std::vec::Vec<::std::string::String>,
pub excludedtags: ::std::vec::Vec<::std::string::String>,
pub match_all_tags: ::std::option::Option<bool>,
pub required_flags: ::std::vec::Vec<::std::string::String>,
pub omitted_flags: ::std::vec::Vec<::std::string::String>,
pub search_text: ::std::option::Option<::std::string::String>,
pub filetype: ::std::option::Option<u32>,
pub child_publishedfileid: ::std::option::Option<u64>,
pub days: ::std::option::Option<u32>,
pub include_recent_votes_only: ::std::option::Option<bool>,
pub cache_max_age_seconds: ::std::option::Option<u32>,
pub language: ::std::option::Option<i32>,
pub required_kv_tags: ::std::vec::Vec<cpublished_file_query_files_request::KVTag>,
pub taggroups: ::std::vec::Vec<cpublished_file_query_files_request::TagGroup>,
pub date_range_created: ::protobuf::MessageField<cpublished_file_query_files_request::DateRange>,
pub date_range_updated: ::protobuf::MessageField<cpublished_file_query_files_request::DateRange>,
pub excluded_content_descriptors: ::std::vec::Vec<::protobuf::EnumOrUnknown<super::enums_productinfo::EContentDescriptorID>>,
pub totalonly: ::std::option::Option<bool>,
pub ids_only: ::std::option::Option<bool>,
pub return_vote_data: ::std::option::Option<bool>,
pub return_tags: ::std::option::Option<bool>,
pub return_kv_tags: ::std::option::Option<bool>,
pub return_previews: ::std::option::Option<bool>,
pub return_children: ::std::option::Option<bool>,
pub return_short_description: ::std::option::Option<bool>,
pub return_for_sale_data: ::std::option::Option<bool>,
pub return_metadata: ::std::option::Option<bool>,
pub return_playtime_stats: ::std::option::Option<u32>,
pub return_details: ::std::option::Option<bool>,
pub strip_description_bbcode: ::std::option::Option<bool>,
pub desired_revision: ::std::option::Option<::protobuf::EnumOrUnknown<EPublishedFileRevision>>,
pub return_reactions: ::std::option::Option<bool>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_QueryFiles_Request {
fn default() -> &'a CPublishedFile_QueryFiles_Request {
<CPublishedFile_QueryFiles_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_QueryFiles_Request {
pub fn new() -> CPublishedFile_QueryFiles_Request {
::std::default::Default::default()
}
pub fn query_type(&self) -> u32 {
self.query_type.unwrap_or(0)
}
pub fn clear_query_type(&mut self) {
self.query_type = ::std::option::Option::None;
}
pub fn has_query_type(&self) -> bool {
self.query_type.is_some()
}
pub fn set_query_type(&mut self, v: u32) {
self.query_type = ::std::option::Option::Some(v);
}
pub fn page(&self) -> u32 {
self.page.unwrap_or(0)
}
pub fn clear_page(&mut self) {
self.page = ::std::option::Option::None;
}
pub fn has_page(&self) -> bool {
self.page.is_some()
}
pub fn set_page(&mut self, v: u32) {
self.page = ::std::option::Option::Some(v);
}
pub fn cursor(&self) -> &str {
match self.cursor.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_cursor(&mut self) {
self.cursor = ::std::option::Option::None;
}
pub fn has_cursor(&self) -> bool {
self.cursor.is_some()
}
pub fn set_cursor(&mut self, v: ::std::string::String) {
self.cursor = ::std::option::Option::Some(v);
}
pub fn mut_cursor(&mut self) -> &mut ::std::string::String {
if self.cursor.is_none() {
self.cursor = ::std::option::Option::Some(::std::string::String::new());
}
self.cursor.as_mut().unwrap()
}
pub fn take_cursor(&mut self) -> ::std::string::String {
self.cursor.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn numperpage(&self) -> u32 {
self.numperpage.unwrap_or(1u32)
}
pub fn clear_numperpage(&mut self) {
self.numperpage = ::std::option::Option::None;
}
pub fn has_numperpage(&self) -> bool {
self.numperpage.is_some()
}
pub fn set_numperpage(&mut self, v: u32) {
self.numperpage = ::std::option::Option::Some(v);
}
pub fn creator_appid(&self) -> u32 {
self.creator_appid.unwrap_or(0)
}
pub fn clear_creator_appid(&mut self) {
self.creator_appid = ::std::option::Option::None;
}
pub fn has_creator_appid(&self) -> bool {
self.creator_appid.is_some()
}
pub fn set_creator_appid(&mut self, v: u32) {
self.creator_appid = ::std::option::Option::Some(v);
}
pub fn appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
pub fn match_all_tags(&self) -> bool {
self.match_all_tags.unwrap_or(true)
}
pub fn clear_match_all_tags(&mut self) {
self.match_all_tags = ::std::option::Option::None;
}
pub fn has_match_all_tags(&self) -> bool {
self.match_all_tags.is_some()
}
pub fn set_match_all_tags(&mut self, v: bool) {
self.match_all_tags = ::std::option::Option::Some(v);
}
pub fn search_text(&self) -> &str {
match self.search_text.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_search_text(&mut self) {
self.search_text = ::std::option::Option::None;
}
pub fn has_search_text(&self) -> bool {
self.search_text.is_some()
}
pub fn set_search_text(&mut self, v: ::std::string::String) {
self.search_text = ::std::option::Option::Some(v);
}
pub fn mut_search_text(&mut self) -> &mut ::std::string::String {
if self.search_text.is_none() {
self.search_text = ::std::option::Option::Some(::std::string::String::new());
}
self.search_text.as_mut().unwrap()
}
pub fn take_search_text(&mut self) -> ::std::string::String {
self.search_text.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn filetype(&self) -> u32 {
self.filetype.unwrap_or(0)
}
pub fn clear_filetype(&mut self) {
self.filetype = ::std::option::Option::None;
}
pub fn has_filetype(&self) -> bool {
self.filetype.is_some()
}
pub fn set_filetype(&mut self, v: u32) {
self.filetype = ::std::option::Option::Some(v);
}
pub fn child_publishedfileid(&self) -> u64 {
self.child_publishedfileid.unwrap_or(0)
}
pub fn clear_child_publishedfileid(&mut self) {
self.child_publishedfileid = ::std::option::Option::None;
}
pub fn has_child_publishedfileid(&self) -> bool {
self.child_publishedfileid.is_some()
}
pub fn set_child_publishedfileid(&mut self, v: u64) {
self.child_publishedfileid = ::std::option::Option::Some(v);
}
pub fn days(&self) -> u32 {
self.days.unwrap_or(0)
}
pub fn clear_days(&mut self) {
self.days = ::std::option::Option::None;
}
pub fn has_days(&self) -> bool {
self.days.is_some()
}
pub fn set_days(&mut self, v: u32) {
self.days = ::std::option::Option::Some(v);
}
pub fn include_recent_votes_only(&self) -> bool {
self.include_recent_votes_only.unwrap_or(false)
}
pub fn clear_include_recent_votes_only(&mut self) {
self.include_recent_votes_only = ::std::option::Option::None;
}
pub fn has_include_recent_votes_only(&self) -> bool {
self.include_recent_votes_only.is_some()
}
pub fn set_include_recent_votes_only(&mut self, v: bool) {
self.include_recent_votes_only = ::std::option::Option::Some(v);
}
pub fn cache_max_age_seconds(&self) -> u32 {
self.cache_max_age_seconds.unwrap_or(0u32)
}
pub fn clear_cache_max_age_seconds(&mut self) {
self.cache_max_age_seconds = ::std::option::Option::None;
}
pub fn has_cache_max_age_seconds(&self) -> bool {
self.cache_max_age_seconds.is_some()
}
pub fn set_cache_max_age_seconds(&mut self, v: u32) {
self.cache_max_age_seconds = ::std::option::Option::Some(v);
}
pub fn language(&self) -> i32 {
self.language.unwrap_or(0i32)
}
pub fn clear_language(&mut self) {
self.language = ::std::option::Option::None;
}
pub fn has_language(&self) -> bool {
self.language.is_some()
}
pub fn set_language(&mut self, v: i32) {
self.language = ::std::option::Option::Some(v);
}
pub fn totalonly(&self) -> bool {
self.totalonly.unwrap_or(false)
}
pub fn clear_totalonly(&mut self) {
self.totalonly = ::std::option::Option::None;
}
pub fn has_totalonly(&self) -> bool {
self.totalonly.is_some()
}
pub fn set_totalonly(&mut self, v: bool) {
self.totalonly = ::std::option::Option::Some(v);
}
pub fn ids_only(&self) -> bool {
self.ids_only.unwrap_or(false)
}
pub fn clear_ids_only(&mut self) {
self.ids_only = ::std::option::Option::None;
}
pub fn has_ids_only(&self) -> bool {
self.ids_only.is_some()
}
pub fn set_ids_only(&mut self, v: bool) {
self.ids_only = ::std::option::Option::Some(v);
}
pub fn return_vote_data(&self) -> bool {
self.return_vote_data.unwrap_or(false)
}
pub fn clear_return_vote_data(&mut self) {
self.return_vote_data = ::std::option::Option::None;
}
pub fn has_return_vote_data(&self) -> bool {
self.return_vote_data.is_some()
}
pub fn set_return_vote_data(&mut self, v: bool) {
self.return_vote_data = ::std::option::Option::Some(v);
}
pub fn return_tags(&self) -> bool {
self.return_tags.unwrap_or(false)
}
pub fn clear_return_tags(&mut self) {
self.return_tags = ::std::option::Option::None;
}
pub fn has_return_tags(&self) -> bool {
self.return_tags.is_some()
}
pub fn set_return_tags(&mut self, v: bool) {
self.return_tags = ::std::option::Option::Some(v);
}
pub fn return_kv_tags(&self) -> bool {
self.return_kv_tags.unwrap_or(false)
}
pub fn clear_return_kv_tags(&mut self) {
self.return_kv_tags = ::std::option::Option::None;
}
pub fn has_return_kv_tags(&self) -> bool {
self.return_kv_tags.is_some()
}
pub fn set_return_kv_tags(&mut self, v: bool) {
self.return_kv_tags = ::std::option::Option::Some(v);
}
pub fn return_previews(&self) -> bool {
self.return_previews.unwrap_or(false)
}
pub fn clear_return_previews(&mut self) {
self.return_previews = ::std::option::Option::None;
}
pub fn has_return_previews(&self) -> bool {
self.return_previews.is_some()
}
pub fn set_return_previews(&mut self, v: bool) {
self.return_previews = ::std::option::Option::Some(v);
}
pub fn return_children(&self) -> bool {
self.return_children.unwrap_or(false)
}
pub fn clear_return_children(&mut self) {
self.return_children = ::std::option::Option::None;
}
pub fn has_return_children(&self) -> bool {
self.return_children.is_some()
}
pub fn set_return_children(&mut self, v: bool) {
self.return_children = ::std::option::Option::Some(v);
}
pub fn return_short_description(&self) -> bool {
self.return_short_description.unwrap_or(false)
}
pub fn clear_return_short_description(&mut self) {
self.return_short_description = ::std::option::Option::None;
}
pub fn has_return_short_description(&self) -> bool {
self.return_short_description.is_some()
}
pub fn set_return_short_description(&mut self, v: bool) {
self.return_short_description = ::std::option::Option::Some(v);
}
pub fn return_for_sale_data(&self) -> bool {
self.return_for_sale_data.unwrap_or(false)
}
pub fn clear_return_for_sale_data(&mut self) {
self.return_for_sale_data = ::std::option::Option::None;
}
pub fn has_return_for_sale_data(&self) -> bool {
self.return_for_sale_data.is_some()
}
pub fn set_return_for_sale_data(&mut self, v: bool) {
self.return_for_sale_data = ::std::option::Option::Some(v);
}
pub fn return_metadata(&self) -> bool {
self.return_metadata.unwrap_or(false)
}
pub fn clear_return_metadata(&mut self) {
self.return_metadata = ::std::option::Option::None;
}
pub fn has_return_metadata(&self) -> bool {
self.return_metadata.is_some()
}
pub fn set_return_metadata(&mut self, v: bool) {
self.return_metadata = ::std::option::Option::Some(v);
}
pub fn return_playtime_stats(&self) -> u32 {
self.return_playtime_stats.unwrap_or(0)
}
pub fn clear_return_playtime_stats(&mut self) {
self.return_playtime_stats = ::std::option::Option::None;
}
pub fn has_return_playtime_stats(&self) -> bool {
self.return_playtime_stats.is_some()
}
pub fn set_return_playtime_stats(&mut self, v: u32) {
self.return_playtime_stats = ::std::option::Option::Some(v);
}
pub fn return_details(&self) -> bool {
self.return_details.unwrap_or(false)
}
pub fn clear_return_details(&mut self) {
self.return_details = ::std::option::Option::None;
}
pub fn has_return_details(&self) -> bool {
self.return_details.is_some()
}
pub fn set_return_details(&mut self, v: bool) {
self.return_details = ::std::option::Option::Some(v);
}
pub fn strip_description_bbcode(&self) -> bool {
self.strip_description_bbcode.unwrap_or(false)
}
pub fn clear_strip_description_bbcode(&mut self) {
self.strip_description_bbcode = ::std::option::Option::None;
}
pub fn has_strip_description_bbcode(&self) -> bool {
self.strip_description_bbcode.is_some()
}
pub fn set_strip_description_bbcode(&mut self, v: bool) {
self.strip_description_bbcode = ::std::option::Option::Some(v);
}
pub fn desired_revision(&self) -> EPublishedFileRevision {
match self.desired_revision {
Some(e) => e.enum_value_or(EPublishedFileRevision::k_EPublishedFileRevision_Default),
None => EPublishedFileRevision::k_EPublishedFileRevision_Default,
}
}
pub fn clear_desired_revision(&mut self) {
self.desired_revision = ::std::option::Option::None;
}
pub fn has_desired_revision(&self) -> bool {
self.desired_revision.is_some()
}
pub fn set_desired_revision(&mut self, v: EPublishedFileRevision) {
self.desired_revision = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
}
pub fn return_reactions(&self) -> bool {
self.return_reactions.unwrap_or(false)
}
pub fn clear_return_reactions(&mut self) {
self.return_reactions = ::std::option::Option::None;
}
pub fn has_return_reactions(&self) -> bool {
self.return_reactions.is_some()
}
pub fn set_return_reactions(&mut self, v: bool) {
self.return_reactions = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_QueryFiles_Request {
const NAME: &'static str = "CPublishedFile_QueryFiles_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.query_type = ::std::option::Option::Some(is.read_uint32()?);
},
16 => {
self.page = ::std::option::Option::Some(is.read_uint32()?);
},
314 => {
self.cursor = ::std::option::Option::Some(is.read_string()?);
},
24 => {
self.numperpage = ::std::option::Option::Some(is.read_uint32()?);
},
32 => {
self.creator_appid = ::std::option::Option::Some(is.read_uint32()?);
},
40 => {
self.appid = ::std::option::Option::Some(is.read_uint32()?);
},
50 => {
self.requiredtags.push(is.read_string()?);
},
58 => {
self.excludedtags.push(is.read_string()?);
},
64 => {
self.match_all_tags = ::std::option::Option::Some(is.read_bool()?);
},
74 => {
self.required_flags.push(is.read_string()?);
},
82 => {
self.omitted_flags.push(is.read_string()?);
},
90 => {
self.search_text = ::std::option::Option::Some(is.read_string()?);
},
96 => {
self.filetype = ::std::option::Option::Some(is.read_uint32()?);
},
105 => {
self.child_publishedfileid = ::std::option::Option::Some(is.read_fixed64()?);
},
112 => {
self.days = ::std::option::Option::Some(is.read_uint32()?);
},
120 => {
self.include_recent_votes_only = ::std::option::Option::Some(is.read_bool()?);
},
248 => {
self.cache_max_age_seconds = ::std::option::Option::Some(is.read_uint32()?);
},
264 => {
self.language = ::std::option::Option::Some(is.read_int32()?);
},
274 => {
self.required_kv_tags.push(is.read_message()?);
},
338 => {
self.taggroups.push(is.read_message()?);
},
354 => {
::protobuf::rt::read_singular_message_into_field(is, &mut self.date_range_created)?;
},
362 => {
::protobuf::rt::read_singular_message_into_field(is, &mut self.date_range_updated)?;
},
368 => {
self.excluded_content_descriptors.push(is.read_enum_or_unknown()?);
},
370 => {
::protobuf::rt::read_repeated_packed_enum_or_unknown_into(is, &mut self.excluded_content_descriptors)?
},
128 => {
self.totalonly = ::std::option::Option::Some(is.read_bool()?);
},
280 => {
self.ids_only = ::std::option::Option::Some(is.read_bool()?);
},
136 => {
self.return_vote_data = ::std::option::Option::Some(is.read_bool()?);
},
144 => {
self.return_tags = ::std::option::Option::Some(is.read_bool()?);
},
152 => {
self.return_kv_tags = ::std::option::Option::Some(is.read_bool()?);
},
160 => {
self.return_previews = ::std::option::Option::Some(is.read_bool()?);
},
168 => {
self.return_children = ::std::option::Option::Some(is.read_bool()?);
},
176 => {
self.return_short_description = ::std::option::Option::Some(is.read_bool()?);
},
240 => {
self.return_for_sale_data = ::std::option::Option::Some(is.read_bool()?);
},
256 => {
self.return_metadata = ::std::option::Option::Some(is.read_bool()?);
},
288 => {
self.return_playtime_stats = ::std::option::Option::Some(is.read_uint32()?);
},
296 => {
self.return_details = ::std::option::Option::Some(is.read_bool()?);
},
304 => {
self.strip_description_bbcode = ::std::option::Option::Some(is.read_bool()?);
},
320 => {
self.desired_revision = ::std::option::Option::Some(is.read_enum_or_unknown()?);
},
344 => {
self.return_reactions = ::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.query_type {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.page {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.cursor.as_ref() {
my_size += ::protobuf::rt::string_size(39, &v);
}
if let Some(v) = self.numperpage {
my_size += ::protobuf::rt::uint32_size(3, v);
}
if let Some(v) = self.creator_appid {
my_size += ::protobuf::rt::uint32_size(4, v);
}
if let Some(v) = self.appid {
my_size += ::protobuf::rt::uint32_size(5, v);
}
for value in &self.requiredtags {
my_size += ::protobuf::rt::string_size(6, &value);
};
for value in &self.excludedtags {
my_size += ::protobuf::rt::string_size(7, &value);
};
if let Some(v) = self.match_all_tags {
my_size += 1 + 1;
}
for value in &self.required_flags {
my_size += ::protobuf::rt::string_size(9, &value);
};
for value in &self.omitted_flags {
my_size += ::protobuf::rt::string_size(10, &value);
};
if let Some(v) = self.search_text.as_ref() {
my_size += ::protobuf::rt::string_size(11, &v);
}
if let Some(v) = self.filetype {
my_size += ::protobuf::rt::uint32_size(12, v);
}
if let Some(v) = self.child_publishedfileid {
my_size += 1 + 8;
}
if let Some(v) = self.days {
my_size += ::protobuf::rt::uint32_size(14, v);
}
if let Some(v) = self.include_recent_votes_only {
my_size += 1 + 1;
}
if let Some(v) = self.cache_max_age_seconds {
my_size += ::protobuf::rt::uint32_size(31, v);
}
if let Some(v) = self.language {
my_size += ::protobuf::rt::int32_size(33, v);
}
for value in &self.required_kv_tags {
let len = value.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
for value in &self.taggroups {
let len = value.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
if let Some(v) = self.date_range_created.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
}
if let Some(v) = self.date_range_updated.as_ref() {
let len = v.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
}
for value in &self.excluded_content_descriptors {
my_size += ::protobuf::rt::int32_size(46, value.value());
};
if let Some(v) = self.totalonly {
my_size += 2 + 1;
}
if let Some(v) = self.ids_only {
my_size += 2 + 1;
}
if let Some(v) = self.return_vote_data {
my_size += 2 + 1;
}
if let Some(v) = self.return_tags {
my_size += 2 + 1;
}
if let Some(v) = self.return_kv_tags {
my_size += 2 + 1;
}
if let Some(v) = self.return_previews {
my_size += 2 + 1;
}
if let Some(v) = self.return_children {
my_size += 2 + 1;
}
if let Some(v) = self.return_short_description {
my_size += 2 + 1;
}
if let Some(v) = self.return_for_sale_data {
my_size += 2 + 1;
}
if let Some(v) = self.return_metadata {
my_size += 2 + 1;
}
if let Some(v) = self.return_playtime_stats {
my_size += ::protobuf::rt::uint32_size(36, v);
}
if let Some(v) = self.return_details {
my_size += 2 + 1;
}
if let Some(v) = self.strip_description_bbcode {
my_size += 2 + 1;
}
if let Some(v) = self.desired_revision {
my_size += ::protobuf::rt::int32_size(40, v.value());
}
if let Some(v) = self.return_reactions {
my_size += 2 + 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.query_type {
os.write_uint32(1, v)?;
}
if let Some(v) = self.page {
os.write_uint32(2, v)?;
}
if let Some(v) = self.cursor.as_ref() {
os.write_string(39, v)?;
}
if let Some(v) = self.numperpage {
os.write_uint32(3, v)?;
}
if let Some(v) = self.creator_appid {
os.write_uint32(4, v)?;
}
if let Some(v) = self.appid {
os.write_uint32(5, v)?;
}
for v in &self.requiredtags {
os.write_string(6, &v)?;
};
for v in &self.excludedtags {
os.write_string(7, &v)?;
};
if let Some(v) = self.match_all_tags {
os.write_bool(8, v)?;
}
for v in &self.required_flags {
os.write_string(9, &v)?;
};
for v in &self.omitted_flags {
os.write_string(10, &v)?;
};
if let Some(v) = self.search_text.as_ref() {
os.write_string(11, v)?;
}
if let Some(v) = self.filetype {
os.write_uint32(12, v)?;
}
if let Some(v) = self.child_publishedfileid {
os.write_fixed64(13, v)?;
}
if let Some(v) = self.days {
os.write_uint32(14, v)?;
}
if let Some(v) = self.include_recent_votes_only {
os.write_bool(15, v)?;
}
if let Some(v) = self.cache_max_age_seconds {
os.write_uint32(31, v)?;
}
if let Some(v) = self.language {
os.write_int32(33, v)?;
}
for v in &self.required_kv_tags {
::protobuf::rt::write_message_field_with_cached_size(34, v, os)?;
};
for v in &self.taggroups {
::protobuf::rt::write_message_field_with_cached_size(42, v, os)?;
};
if let Some(v) = self.date_range_created.as_ref() {
::protobuf::rt::write_message_field_with_cached_size(44, v, os)?;
}
if let Some(v) = self.date_range_updated.as_ref() {
::protobuf::rt::write_message_field_with_cached_size(45, v, os)?;
}
for v in &self.excluded_content_descriptors {
os.write_enum(46, ::protobuf::EnumOrUnknown::value(v))?;
};
if let Some(v) = self.totalonly {
os.write_bool(16, v)?;
}
if let Some(v) = self.ids_only {
os.write_bool(35, v)?;
}
if let Some(v) = self.return_vote_data {
os.write_bool(17, v)?;
}
if let Some(v) = self.return_tags {
os.write_bool(18, v)?;
}
if let Some(v) = self.return_kv_tags {
os.write_bool(19, v)?;
}
if let Some(v) = self.return_previews {
os.write_bool(20, v)?;
}
if let Some(v) = self.return_children {
os.write_bool(21, v)?;
}
if let Some(v) = self.return_short_description {
os.write_bool(22, v)?;
}
if let Some(v) = self.return_for_sale_data {
os.write_bool(30, v)?;
}
if let Some(v) = self.return_metadata {
os.write_bool(32, v)?;
}
if let Some(v) = self.return_playtime_stats {
os.write_uint32(36, v)?;
}
if let Some(v) = self.return_details {
os.write_bool(37, v)?;
}
if let Some(v) = self.strip_description_bbcode {
os.write_bool(38, v)?;
}
if let Some(v) = self.desired_revision {
os.write_enum(40, ::protobuf::EnumOrUnknown::value(&v))?;
}
if let Some(v) = self.return_reactions {
os.write_bool(43, 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() -> CPublishedFile_QueryFiles_Request {
CPublishedFile_QueryFiles_Request::new()
}
fn clear(&mut self) {
self.query_type = ::std::option::Option::None;
self.page = ::std::option::Option::None;
self.cursor = ::std::option::Option::None;
self.numperpage = ::std::option::Option::None;
self.creator_appid = ::std::option::Option::None;
self.appid = ::std::option::Option::None;
self.requiredtags.clear();
self.excludedtags.clear();
self.match_all_tags = ::std::option::Option::None;
self.required_flags.clear();
self.omitted_flags.clear();
self.search_text = ::std::option::Option::None;
self.filetype = ::std::option::Option::None;
self.child_publishedfileid = ::std::option::Option::None;
self.days = ::std::option::Option::None;
self.include_recent_votes_only = ::std::option::Option::None;
self.cache_max_age_seconds = ::std::option::Option::None;
self.language = ::std::option::Option::None;
self.required_kv_tags.clear();
self.taggroups.clear();
self.date_range_created.clear();
self.date_range_updated.clear();
self.excluded_content_descriptors.clear();
self.totalonly = ::std::option::Option::None;
self.ids_only = ::std::option::Option::None;
self.return_vote_data = ::std::option::Option::None;
self.return_tags = ::std::option::Option::None;
self.return_kv_tags = ::std::option::Option::None;
self.return_previews = ::std::option::Option::None;
self.return_children = ::std::option::Option::None;
self.return_short_description = ::std::option::Option::None;
self.return_for_sale_data = ::std::option::Option::None;
self.return_metadata = ::std::option::Option::None;
self.return_playtime_stats = ::std::option::Option::None;
self.return_details = ::std::option::Option::None;
self.strip_description_bbcode = ::std::option::Option::None;
self.desired_revision = ::std::option::Option::None;
self.return_reactions = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_QueryFiles_Request {
static instance: CPublishedFile_QueryFiles_Request = CPublishedFile_QueryFiles_Request {
query_type: ::std::option::Option::None,
page: ::std::option::Option::None,
cursor: ::std::option::Option::None,
numperpage: ::std::option::Option::None,
creator_appid: ::std::option::Option::None,
appid: ::std::option::Option::None,
requiredtags: ::std::vec::Vec::new(),
excludedtags: ::std::vec::Vec::new(),
match_all_tags: ::std::option::Option::None,
required_flags: ::std::vec::Vec::new(),
omitted_flags: ::std::vec::Vec::new(),
search_text: ::std::option::Option::None,
filetype: ::std::option::Option::None,
child_publishedfileid: ::std::option::Option::None,
days: ::std::option::Option::None,
include_recent_votes_only: ::std::option::Option::None,
cache_max_age_seconds: ::std::option::Option::None,
language: ::std::option::Option::None,
required_kv_tags: ::std::vec::Vec::new(),
taggroups: ::std::vec::Vec::new(),
date_range_created: ::protobuf::MessageField::none(),
date_range_updated: ::protobuf::MessageField::none(),
excluded_content_descriptors: ::std::vec::Vec::new(),
totalonly: ::std::option::Option::None,
ids_only: ::std::option::Option::None,
return_vote_data: ::std::option::Option::None,
return_tags: ::std::option::Option::None,
return_kv_tags: ::std::option::Option::None,
return_previews: ::std::option::Option::None,
return_children: ::std::option::Option::None,
return_short_description: ::std::option::Option::None,
return_for_sale_data: ::std::option::Option::None,
return_metadata: ::std::option::Option::None,
return_playtime_stats: ::std::option::Option::None,
return_details: ::std::option::Option::None,
strip_description_bbcode: ::std::option::Option::None,
desired_revision: ::std::option::Option::None,
return_reactions: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
pub mod cpublished_file_query_files_request {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct KVTag {
pub key: ::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 KVTag {
fn default() -> &'a KVTag {
<KVTag as ::protobuf::Message>::default_instance()
}
}
impl KVTag {
pub fn new() -> KVTag {
::std::default::Default::default()
}
pub fn key(&self) -> &str {
match self.key.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_key(&mut self) {
self.key = ::std::option::Option::None;
}
pub fn has_key(&self) -> bool {
self.key.is_some()
}
pub fn set_key(&mut self, v: ::std::string::String) {
self.key = ::std::option::Option::Some(v);
}
pub fn mut_key(&mut self) -> &mut ::std::string::String {
if self.key.is_none() {
self.key = ::std::option::Option::Some(::std::string::String::new());
}
self.key.as_mut().unwrap()
}
pub fn take_key(&mut self) -> ::std::string::String {
self.key.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 KVTag {
const NAME: &'static str = "KVTag";
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.key = ::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.key.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.key.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() -> KVTag {
KVTag::new()
}
fn clear(&mut self) {
self.key = ::std::option::Option::None;
self.value = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static KVTag {
static instance: KVTag = KVTag {
key: ::std::option::Option::None,
value: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct TagGroup {
pub tags: ::std::vec::Vec<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a TagGroup {
fn default() -> &'a TagGroup {
<TagGroup as ::protobuf::Message>::default_instance()
}
}
impl TagGroup {
pub fn new() -> TagGroup {
::std::default::Default::default()
}
}
impl ::protobuf::Message for TagGroup {
const NAME: &'static str = "TagGroup";
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.tags.push(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;
for value in &self.tags {
my_size += ::protobuf::rt::string_size(1, &value);
};
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.tags {
os.write_string(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() -> TagGroup {
TagGroup::new()
}
fn clear(&mut self) {
self.tags.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static TagGroup {
static instance: TagGroup = TagGroup {
tags: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct DateRange {
pub timestamp_start: ::std::option::Option<u32>,
pub timestamp_end: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a DateRange {
fn default() -> &'a DateRange {
<DateRange as ::protobuf::Message>::default_instance()
}
}
impl DateRange {
pub fn new() -> DateRange {
::std::default::Default::default()
}
pub fn timestamp_start(&self) -> u32 {
self.timestamp_start.unwrap_or(0)
}
pub fn clear_timestamp_start(&mut self) {
self.timestamp_start = ::std::option::Option::None;
}
pub fn has_timestamp_start(&self) -> bool {
self.timestamp_start.is_some()
}
pub fn set_timestamp_start(&mut self, v: u32) {
self.timestamp_start = ::std::option::Option::Some(v);
}
pub fn timestamp_end(&self) -> u32 {
self.timestamp_end.unwrap_or(0)
}
pub fn clear_timestamp_end(&mut self) {
self.timestamp_end = ::std::option::Option::None;
}
pub fn has_timestamp_end(&self) -> bool {
self.timestamp_end.is_some()
}
pub fn set_timestamp_end(&mut self, v: u32) {
self.timestamp_end = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for DateRange {
const NAME: &'static str = "DateRange";
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.timestamp_start = ::std::option::Option::Some(is.read_uint32()?);
},
16 => {
self.timestamp_end = ::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.timestamp_start {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.timestamp_end {
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.timestamp_start {
os.write_uint32(1, v)?;
}
if let Some(v) = self.timestamp_end {
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() -> DateRange {
DateRange::new()
}
fn clear(&mut self) {
self.timestamp_start = ::std::option::Option::None;
self.timestamp_end = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static DateRange {
static instance: DateRange = DateRange {
timestamp_start: ::std::option::Option::None,
timestamp_end: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_QueryFiles_Response {
pub total: ::std::option::Option<u32>,
pub publishedfiledetails: ::std::vec::Vec<PublishedFileDetails>,
pub next_cursor: ::std::option::Option<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_QueryFiles_Response {
fn default() -> &'a CPublishedFile_QueryFiles_Response {
<CPublishedFile_QueryFiles_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_QueryFiles_Response {
pub fn new() -> CPublishedFile_QueryFiles_Response {
::std::default::Default::default()
}
pub fn total(&self) -> u32 {
self.total.unwrap_or(0)
}
pub fn clear_total(&mut self) {
self.total = ::std::option::Option::None;
}
pub fn has_total(&self) -> bool {
self.total.is_some()
}
pub fn set_total(&mut self, v: u32) {
self.total = ::std::option::Option::Some(v);
}
pub fn next_cursor(&self) -> &str {
match self.next_cursor.as_ref() {
Some(v) => v,
None => "",
}
}
pub fn clear_next_cursor(&mut self) {
self.next_cursor = ::std::option::Option::None;
}
pub fn has_next_cursor(&self) -> bool {
self.next_cursor.is_some()
}
pub fn set_next_cursor(&mut self, v: ::std::string::String) {
self.next_cursor = ::std::option::Option::Some(v);
}
pub fn mut_next_cursor(&mut self) -> &mut ::std::string::String {
if self.next_cursor.is_none() {
self.next_cursor = ::std::option::Option::Some(::std::string::String::new());
}
self.next_cursor.as_mut().unwrap()
}
pub fn take_next_cursor(&mut self) -> ::std::string::String {
self.next_cursor.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for CPublishedFile_QueryFiles_Response {
const NAME: &'static str = "CPublishedFile_QueryFiles_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.total = ::std::option::Option::Some(is.read_uint32()?);
},
18 => {
self.publishedfiledetails.push(is.read_message()?);
},
26 => {
self.next_cursor = ::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.total {
my_size += ::protobuf::rt::uint32_size(1, v);
}
for value in &self.publishedfiledetails {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
if let Some(v) = self.next_cursor.as_ref() {
my_size += ::protobuf::rt::string_size(3, &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.total {
os.write_uint32(1, v)?;
}
for v in &self.publishedfiledetails {
::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
};
if let Some(v) = self.next_cursor.as_ref() {
os.write_string(3, 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() -> CPublishedFile_QueryFiles_Response {
CPublishedFile_QueryFiles_Response::new()
}
fn clear(&mut self) {
self.total = ::std::option::Option::None;
self.publishedfiledetails.clear();
self.next_cursor = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_QueryFiles_Response {
static instance: CPublishedFile_QueryFiles_Response = CPublishedFile_QueryFiles_Response {
total: ::std::option::Option::None,
publishedfiledetails: ::std::vec::Vec::new(),
next_cursor: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Adds a relationship between the published file and the given app"]
pub struct CPublishedFile_AddAppRelationship_Request {
pub publishedfileid: ::std::option::Option<u64>,
pub appid: ::std::option::Option<u32>,
pub relationship: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_AddAppRelationship_Request {
fn default() -> &'a CPublishedFile_AddAppRelationship_Request {
<CPublishedFile_AddAppRelationship_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_AddAppRelationship_Request {
pub fn new() -> CPublishedFile_AddAppRelationship_Request {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
pub fn appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
pub fn relationship(&self) -> u32 {
self.relationship.unwrap_or(0)
}
pub fn clear_relationship(&mut self) {
self.relationship = ::std::option::Option::None;
}
pub fn has_relationship(&self) -> bool {
self.relationship.is_some()
}
pub fn set_relationship(&mut self, v: u32) {
self.relationship = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_AddAppRelationship_Request {
const NAME: &'static str = "CPublishedFile_AddAppRelationship_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.publishedfileid = ::std::option::Option::Some(is.read_uint64()?);
},
16 => {
self.appid = ::std::option::Option::Some(is.read_uint32()?);
},
24 => {
self.relationship = ::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.publishedfileid {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.appid {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.relationship {
my_size += ::protobuf::rt::uint32_size(3, 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.publishedfileid {
os.write_uint64(1, v)?;
}
if let Some(v) = self.appid {
os.write_uint32(2, v)?;
}
if let Some(v) = self.relationship {
os.write_uint32(3, 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() -> CPublishedFile_AddAppRelationship_Request {
CPublishedFile_AddAppRelationship_Request::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.appid = ::std::option::Option::None;
self.relationship = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_AddAppRelationship_Request {
static instance: CPublishedFile_AddAppRelationship_Request = CPublishedFile_AddAppRelationship_Request {
publishedfileid: ::std::option::Option::None,
appid: ::std::option::Option::None,
relationship: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_AddAppRelationship_Response {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_AddAppRelationship_Response {
fn default() -> &'a CPublishedFile_AddAppRelationship_Response {
<CPublishedFile_AddAppRelationship_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_AddAppRelationship_Response {
pub fn new() -> CPublishedFile_AddAppRelationship_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_AddAppRelationship_Response {
const NAME: &'static str = "CPublishedFile_AddAppRelationship_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() -> CPublishedFile_AddAppRelationship_Response {
CPublishedFile_AddAppRelationship_Response::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_AddAppRelationship_Response {
static instance: CPublishedFile_AddAppRelationship_Response = CPublishedFile_AddAppRelationship_Response {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Remove a relationship between the published file and the given app"]
pub struct CPublishedFile_RemoveAppRelationship_Request {
pub publishedfileid: ::std::option::Option<u64>,
pub appid: ::std::option::Option<u32>,
pub relationship: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_RemoveAppRelationship_Request {
fn default() -> &'a CPublishedFile_RemoveAppRelationship_Request {
<CPublishedFile_RemoveAppRelationship_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_RemoveAppRelationship_Request {
pub fn new() -> CPublishedFile_RemoveAppRelationship_Request {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
pub fn appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
pub fn relationship(&self) -> u32 {
self.relationship.unwrap_or(0)
}
pub fn clear_relationship(&mut self) {
self.relationship = ::std::option::Option::None;
}
pub fn has_relationship(&self) -> bool {
self.relationship.is_some()
}
pub fn set_relationship(&mut self, v: u32) {
self.relationship = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_RemoveAppRelationship_Request {
const NAME: &'static str = "CPublishedFile_RemoveAppRelationship_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.publishedfileid = ::std::option::Option::Some(is.read_uint64()?);
},
16 => {
self.appid = ::std::option::Option::Some(is.read_uint32()?);
},
24 => {
self.relationship = ::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.publishedfileid {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.appid {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.relationship {
my_size += ::protobuf::rt::uint32_size(3, 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.publishedfileid {
os.write_uint64(1, v)?;
}
if let Some(v) = self.appid {
os.write_uint32(2, v)?;
}
if let Some(v) = self.relationship {
os.write_uint32(3, 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() -> CPublishedFile_RemoveAppRelationship_Request {
CPublishedFile_RemoveAppRelationship_Request::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.appid = ::std::option::Option::None;
self.relationship = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_RemoveAppRelationship_Request {
static instance: CPublishedFile_RemoveAppRelationship_Request = CPublishedFile_RemoveAppRelationship_Request {
publishedfileid: ::std::option::Option::None,
appid: ::std::option::Option::None,
relationship: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_RemoveAppRelationship_Response {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_RemoveAppRelationship_Response {
fn default() -> &'a CPublishedFile_RemoveAppRelationship_Response {
<CPublishedFile_RemoveAppRelationship_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_RemoveAppRelationship_Response {
pub fn new() -> CPublishedFile_RemoveAppRelationship_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_RemoveAppRelationship_Response {
const NAME: &'static str = "CPublishedFile_RemoveAppRelationship_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() -> CPublishedFile_RemoveAppRelationship_Response {
CPublishedFile_RemoveAppRelationship_Response::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_RemoveAppRelationship_Response {
static instance: CPublishedFile_RemoveAppRelationship_Response = CPublishedFile_RemoveAppRelationship_Response {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Returns the list of app relationships for this published file"]
pub struct CPublishedFile_GetAppRelationships_Request {
pub publishedfileid: ::std::option::Option<u64>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetAppRelationships_Request {
fn default() -> &'a CPublishedFile_GetAppRelationships_Request {
<CPublishedFile_GetAppRelationships_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetAppRelationships_Request {
pub fn new() -> CPublishedFile_GetAppRelationships_Request {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_GetAppRelationships_Request {
const NAME: &'static str = "CPublishedFile_GetAppRelationships_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.publishedfileid = ::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.publishedfileid {
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.publishedfileid {
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() -> CPublishedFile_GetAppRelationships_Request {
CPublishedFile_GetAppRelationships_Request::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetAppRelationships_Request {
static instance: CPublishedFile_GetAppRelationships_Request = CPublishedFile_GetAppRelationships_Request {
publishedfileid: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_GetAppRelationships_Response {
pub app_relationships: ::std::vec::Vec<cpublished_file_get_app_relationships_response::AppRelationship>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetAppRelationships_Response {
fn default() -> &'a CPublishedFile_GetAppRelationships_Response {
<CPublishedFile_GetAppRelationships_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetAppRelationships_Response {
pub fn new() -> CPublishedFile_GetAppRelationships_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_GetAppRelationships_Response {
const NAME: &'static str = "CPublishedFile_GetAppRelationships_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 {
26 => {
self.app_relationships.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.app_relationships {
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.app_relationships {
::protobuf::rt::write_message_field_with_cached_size(3, 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() -> CPublishedFile_GetAppRelationships_Response {
CPublishedFile_GetAppRelationships_Response::new()
}
fn clear(&mut self) {
self.app_relationships.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetAppRelationships_Response {
static instance: CPublishedFile_GetAppRelationships_Response = CPublishedFile_GetAppRelationships_Response {
app_relationships: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
pub mod cpublished_file_get_app_relationships_response {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct AppRelationship {
pub appid: ::std::option::Option<u32>,
pub relationship: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a AppRelationship {
fn default() -> &'a AppRelationship {
<AppRelationship as ::protobuf::Message>::default_instance()
}
}
impl AppRelationship {
pub fn new() -> AppRelationship {
::std::default::Default::default()
}
pub fn appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
pub fn relationship(&self) -> u32 {
self.relationship.unwrap_or(0)
}
pub fn clear_relationship(&mut self) {
self.relationship = ::std::option::Option::None;
}
pub fn has_relationship(&self) -> bool {
self.relationship.is_some()
}
pub fn set_relationship(&mut self, v: u32) {
self.relationship = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for AppRelationship {
const NAME: &'static str = "AppRelationship";
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.appid = ::std::option::Option::Some(is.read_uint32()?);
},
16 => {
self.relationship = ::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.appid {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.relationship {
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.appid {
os.write_uint32(1, v)?;
}
if let Some(v) = self.relationship {
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() -> AppRelationship {
AppRelationship::new()
}
fn clear(&mut self) {
self.appid = ::std::option::Option::None;
self.relationship = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static AppRelationship {
static instance: AppRelationship = AppRelationship {
appid: ::std::option::Option::None,
relationship: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Returns the list of app relationships for set of published files"]
pub struct CPublishedFile_GetAppRelationshipsBatched_Request {
pub publishedfileids: ::std::vec::Vec<u64>,
pub filter_relationship: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetAppRelationshipsBatched_Request {
fn default() -> &'a CPublishedFile_GetAppRelationshipsBatched_Request {
<CPublishedFile_GetAppRelationshipsBatched_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetAppRelationshipsBatched_Request {
pub fn new() -> CPublishedFile_GetAppRelationshipsBatched_Request {
::std::default::Default::default()
}
pub fn filter_relationship(&self) -> u32 {
self.filter_relationship.unwrap_or(0)
}
pub fn clear_filter_relationship(&mut self) {
self.filter_relationship = ::std::option::Option::None;
}
pub fn has_filter_relationship(&self) -> bool {
self.filter_relationship.is_some()
}
pub fn set_filter_relationship(&mut self, v: u32) {
self.filter_relationship = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_GetAppRelationshipsBatched_Request {
const NAME: &'static str = "CPublishedFile_GetAppRelationshipsBatched_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_uint64_into(&mut self.publishedfileids)?;
},
8 => {
self.publishedfileids.push(is.read_uint64()?);
},
16 => {
self.filter_relationship = ::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.publishedfileids {
my_size += ::protobuf::rt::uint64_size(1, *value);
};
if let Some(v) = self.filter_relationship {
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.publishedfileids {
os.write_uint64(1, *v)?;
};
if let Some(v) = self.filter_relationship {
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() -> CPublishedFile_GetAppRelationshipsBatched_Request {
CPublishedFile_GetAppRelationshipsBatched_Request::new()
}
fn clear(&mut self) {
self.publishedfileids.clear();
self.filter_relationship = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetAppRelationshipsBatched_Request {
static instance: CPublishedFile_GetAppRelationshipsBatched_Request = CPublishedFile_GetAppRelationshipsBatched_Request {
publishedfileids: ::std::vec::Vec::new(),
filter_relationship: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_GetAppRelationshipsBatched_Response {
pub relationships: ::std::vec::Vec<cpublished_file_get_app_relationships_batched_response::PublishedFileAppRelationship>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetAppRelationshipsBatched_Response {
fn default() -> &'a CPublishedFile_GetAppRelationshipsBatched_Response {
<CPublishedFile_GetAppRelationshipsBatched_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetAppRelationshipsBatched_Response {
pub fn new() -> CPublishedFile_GetAppRelationshipsBatched_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_GetAppRelationshipsBatched_Response {
const NAME: &'static str = "CPublishedFile_GetAppRelationshipsBatched_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.relationships.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.relationships {
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.relationships {
::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() -> CPublishedFile_GetAppRelationshipsBatched_Response {
CPublishedFile_GetAppRelationshipsBatched_Response::new()
}
fn clear(&mut self) {
self.relationships.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetAppRelationshipsBatched_Response {
static instance: CPublishedFile_GetAppRelationshipsBatched_Response = CPublishedFile_GetAppRelationshipsBatched_Response {
relationships: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
pub mod cpublished_file_get_app_relationships_batched_response {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct AppRelationship {
pub appid: ::std::option::Option<u32>,
pub relationship: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a AppRelationship {
fn default() -> &'a AppRelationship {
<AppRelationship as ::protobuf::Message>::default_instance()
}
}
impl AppRelationship {
pub fn new() -> AppRelationship {
::std::default::Default::default()
}
pub fn appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
pub fn relationship(&self) -> u32 {
self.relationship.unwrap_or(0)
}
pub fn clear_relationship(&mut self) {
self.relationship = ::std::option::Option::None;
}
pub fn has_relationship(&self) -> bool {
self.relationship.is_some()
}
pub fn set_relationship(&mut self, v: u32) {
self.relationship = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for AppRelationship {
const NAME: &'static str = "AppRelationship";
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.appid = ::std::option::Option::Some(is.read_uint32()?);
},
16 => {
self.relationship = ::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.appid {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.relationship {
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.appid {
os.write_uint32(1, v)?;
}
if let Some(v) = self.relationship {
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() -> AppRelationship {
AppRelationship::new()
}
fn clear(&mut self) {
self.appid = ::std::option::Option::None;
self.relationship = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static AppRelationship {
static instance: AppRelationship = AppRelationship {
appid: ::std::option::Option::None,
relationship: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PublishedFileAppRelationship {
pub publishedfileid: ::std::option::Option<u64>,
pub result: ::std::option::Option<u32>,
pub app_relationships: ::std::vec::Vec<AppRelationship>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a PublishedFileAppRelationship {
fn default() -> &'a PublishedFileAppRelationship {
<PublishedFileAppRelationship as ::protobuf::Message>::default_instance()
}
}
impl PublishedFileAppRelationship {
pub fn new() -> PublishedFileAppRelationship {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
pub fn result(&self) -> u32 {
self.result.unwrap_or(0)
}
pub fn clear_result(&mut self) {
self.result = ::std::option::Option::None;
}
pub fn has_result(&self) -> bool {
self.result.is_some()
}
pub fn set_result(&mut self, v: u32) {
self.result = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for PublishedFileAppRelationship {
const NAME: &'static str = "PublishedFileAppRelationship";
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.publishedfileid = ::std::option::Option::Some(is.read_uint64()?);
},
16 => {
self.result = ::std::option::Option::Some(is.read_uint32()?);
},
26 => {
self.app_relationships.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.publishedfileid {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.result {
my_size += ::protobuf::rt::uint32_size(2, v);
}
for value in &self.app_relationships {
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.publishedfileid {
os.write_uint64(1, v)?;
}
if let Some(v) = self.result {
os.write_uint32(2, v)?;
}
for v in &self.app_relationships {
::protobuf::rt::write_message_field_with_cached_size(3, 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() -> PublishedFileAppRelationship {
PublishedFileAppRelationship::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.result = ::std::option::Option::None;
self.app_relationships.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static PublishedFileAppRelationship {
static instance: PublishedFileAppRelationship = PublishedFileAppRelationship {
publishedfileid: ::std::option::Option::None,
result: ::std::option::Option::None,
app_relationships: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Start usage tracking for a given set of published files"]
pub struct CPublishedFile_StartPlaytimeTracking_Request {
pub appid: ::std::option::Option<u32>,
pub publishedfileids: ::std::vec::Vec<u64>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_StartPlaytimeTracking_Request {
fn default() -> &'a CPublishedFile_StartPlaytimeTracking_Request {
<CPublishedFile_StartPlaytimeTracking_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_StartPlaytimeTracking_Request {
pub fn new() -> CPublishedFile_StartPlaytimeTracking_Request {
::std::default::Default::default()
}
pub fn appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_StartPlaytimeTracking_Request {
const NAME: &'static str = "CPublishedFile_StartPlaytimeTracking_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.appid = ::std::option::Option::Some(is.read_uint32()?);
},
18 => {
is.read_repeated_packed_uint64_into(&mut self.publishedfileids)?;
},
16 => {
self.publishedfileids.push(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.appid {
my_size += ::protobuf::rt::uint32_size(1, v);
}
for value in &self.publishedfileids {
my_size += ::protobuf::rt::uint64_size(2, *value);
};
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.appid {
os.write_uint32(1, v)?;
}
for v in &self.publishedfileids {
os.write_uint64(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() -> CPublishedFile_StartPlaytimeTracking_Request {
CPublishedFile_StartPlaytimeTracking_Request::new()
}
fn clear(&mut self) {
self.appid = ::std::option::Option::None;
self.publishedfileids.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_StartPlaytimeTracking_Request {
static instance: CPublishedFile_StartPlaytimeTracking_Request = CPublishedFile_StartPlaytimeTracking_Request {
appid: ::std::option::Option::None,
publishedfileids: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_StartPlaytimeTracking_Response {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_StartPlaytimeTracking_Response {
fn default() -> &'a CPublishedFile_StartPlaytimeTracking_Response {
<CPublishedFile_StartPlaytimeTracking_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_StartPlaytimeTracking_Response {
pub fn new() -> CPublishedFile_StartPlaytimeTracking_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_StartPlaytimeTracking_Response {
const NAME: &'static str = "CPublishedFile_StartPlaytimeTracking_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() -> CPublishedFile_StartPlaytimeTracking_Response {
CPublishedFile_StartPlaytimeTracking_Response::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_StartPlaytimeTracking_Response {
static instance: CPublishedFile_StartPlaytimeTracking_Response = CPublishedFile_StartPlaytimeTracking_Response {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Stops usage tracking for a given set of published files"]
pub struct CPublishedFile_StopPlaytimeTracking_Request {
pub appid: ::std::option::Option<u32>,
pub publishedfileids: ::std::vec::Vec<u64>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_StopPlaytimeTracking_Request {
fn default() -> &'a CPublishedFile_StopPlaytimeTracking_Request {
<CPublishedFile_StopPlaytimeTracking_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_StopPlaytimeTracking_Request {
pub fn new() -> CPublishedFile_StopPlaytimeTracking_Request {
::std::default::Default::default()
}
pub fn appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_StopPlaytimeTracking_Request {
const NAME: &'static str = "CPublishedFile_StopPlaytimeTracking_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.appid = ::std::option::Option::Some(is.read_uint32()?);
},
18 => {
is.read_repeated_packed_uint64_into(&mut self.publishedfileids)?;
},
16 => {
self.publishedfileids.push(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.appid {
my_size += ::protobuf::rt::uint32_size(1, v);
}
for value in &self.publishedfileids {
my_size += ::protobuf::rt::uint64_size(2, *value);
};
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.appid {
os.write_uint32(1, v)?;
}
for v in &self.publishedfileids {
os.write_uint64(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() -> CPublishedFile_StopPlaytimeTracking_Request {
CPublishedFile_StopPlaytimeTracking_Request::new()
}
fn clear(&mut self) {
self.appid = ::std::option::Option::None;
self.publishedfileids.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_StopPlaytimeTracking_Request {
static instance: CPublishedFile_StopPlaytimeTracking_Request = CPublishedFile_StopPlaytimeTracking_Request {
appid: ::std::option::Option::None,
publishedfileids: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_StopPlaytimeTracking_Response {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_StopPlaytimeTracking_Response {
fn default() -> &'a CPublishedFile_StopPlaytimeTracking_Response {
<CPublishedFile_StopPlaytimeTracking_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_StopPlaytimeTracking_Response {
pub fn new() -> CPublishedFile_StopPlaytimeTracking_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_StopPlaytimeTracking_Response {
const NAME: &'static str = "CPublishedFile_StopPlaytimeTracking_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() -> CPublishedFile_StopPlaytimeTracking_Response {
CPublishedFile_StopPlaytimeTracking_Response::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_StopPlaytimeTracking_Response {
static instance: CPublishedFile_StopPlaytimeTracking_Response = CPublishedFile_StopPlaytimeTracking_Response {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Stops usage tracking for all items currently tracked for the specified app"]
pub struct CPublishedFile_StopPlaytimeTrackingForAllAppItems_Request {
pub appid: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_StopPlaytimeTrackingForAllAppItems_Request {
fn default() -> &'a CPublishedFile_StopPlaytimeTrackingForAllAppItems_Request {
<CPublishedFile_StopPlaytimeTrackingForAllAppItems_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_StopPlaytimeTrackingForAllAppItems_Request {
pub fn new() -> CPublishedFile_StopPlaytimeTrackingForAllAppItems_Request {
::std::default::Default::default()
}
pub fn appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_StopPlaytimeTrackingForAllAppItems_Request {
const NAME: &'static str = "CPublishedFile_StopPlaytimeTrackingForAllAppItems_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.appid = ::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.appid {
my_size += ::protobuf::rt::uint32_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.appid {
os.write_uint32(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() -> CPublishedFile_StopPlaytimeTrackingForAllAppItems_Request {
CPublishedFile_StopPlaytimeTrackingForAllAppItems_Request::new()
}
fn clear(&mut self) {
self.appid = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_StopPlaytimeTrackingForAllAppItems_Request {
static instance: CPublishedFile_StopPlaytimeTrackingForAllAppItems_Request = CPublishedFile_StopPlaytimeTrackingForAllAppItems_Request {
appid: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_StopPlaytimeTrackingForAllAppItems_Response {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_StopPlaytimeTrackingForAllAppItems_Response {
fn default() -> &'a CPublishedFile_StopPlaytimeTrackingForAllAppItems_Response {
<CPublishedFile_StopPlaytimeTrackingForAllAppItems_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_StopPlaytimeTrackingForAllAppItems_Response {
pub fn new() -> CPublishedFile_StopPlaytimeTrackingForAllAppItems_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_StopPlaytimeTrackingForAllAppItems_Response {
const NAME: &'static str = "CPublishedFile_StopPlaytimeTrackingForAllAppItems_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() -> CPublishedFile_StopPlaytimeTrackingForAllAppItems_Response {
CPublishedFile_StopPlaytimeTrackingForAllAppItems_Response::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_StopPlaytimeTrackingForAllAppItems_Response {
static instance: CPublishedFile_StopPlaytimeTrackingForAllAppItems_Response = CPublishedFile_StopPlaytimeTrackingForAllAppItems_Response {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Stops usage tracking all controller configs for the given app and set the usage time for the for the given controller configs"]
pub struct CPublishedFile_SetPlaytimeForControllerConfigs_Request {
pub appid: ::std::option::Option<u32>,
pub controller_config_usage: ::std::vec::Vec<cpublished_file_set_playtime_for_controller_configs_request::ControllerConfigUsage>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_SetPlaytimeForControllerConfigs_Request {
fn default() -> &'a CPublishedFile_SetPlaytimeForControllerConfigs_Request {
<CPublishedFile_SetPlaytimeForControllerConfigs_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_SetPlaytimeForControllerConfigs_Request {
pub fn new() -> CPublishedFile_SetPlaytimeForControllerConfigs_Request {
::std::default::Default::default()
}
pub fn appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_SetPlaytimeForControllerConfigs_Request {
const NAME: &'static str = "CPublishedFile_SetPlaytimeForControllerConfigs_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.appid = ::std::option::Option::Some(is.read_uint32()?);
},
18 => {
self.controller_config_usage.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.appid {
my_size += ::protobuf::rt::uint32_size(1, v);
}
for value in &self.controller_config_usage {
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.appid {
os.write_uint32(1, v)?;
}
for v in &self.controller_config_usage {
::protobuf::rt::write_message_field_with_cached_size(2, 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() -> CPublishedFile_SetPlaytimeForControllerConfigs_Request {
CPublishedFile_SetPlaytimeForControllerConfigs_Request::new()
}
fn clear(&mut self) {
self.appid = ::std::option::Option::None;
self.controller_config_usage.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_SetPlaytimeForControllerConfigs_Request {
static instance: CPublishedFile_SetPlaytimeForControllerConfigs_Request = CPublishedFile_SetPlaytimeForControllerConfigs_Request {
appid: ::std::option::Option::None,
controller_config_usage: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
pub mod cpublished_file_set_playtime_for_controller_configs_request {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ControllerConfigUsage {
pub publishedfileid: ::std::option::Option<u64>,
pub seconds_active: ::std::option::Option<f32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a ControllerConfigUsage {
fn default() -> &'a ControllerConfigUsage {
<ControllerConfigUsage as ::protobuf::Message>::default_instance()
}
}
impl ControllerConfigUsage {
pub fn new() -> ControllerConfigUsage {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
pub fn seconds_active(&self) -> f32 {
self.seconds_active.unwrap_or(0.)
}
pub fn clear_seconds_active(&mut self) {
self.seconds_active = ::std::option::Option::None;
}
pub fn has_seconds_active(&self) -> bool {
self.seconds_active.is_some()
}
pub fn set_seconds_active(&mut self, v: f32) {
self.seconds_active = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for ControllerConfigUsage {
const NAME: &'static str = "ControllerConfigUsage";
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.publishedfileid = ::std::option::Option::Some(is.read_uint64()?);
},
21 => {
self.seconds_active = ::std::option::Option::Some(is.read_float()?);
},
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.publishedfileid {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.seconds_active {
my_size += 1 + 4;
}
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.publishedfileid {
os.write_uint64(1, v)?;
}
if let Some(v) = self.seconds_active {
os.write_float(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() -> ControllerConfigUsage {
ControllerConfigUsage::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.seconds_active = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static ControllerConfigUsage {
static instance: ControllerConfigUsage = ControllerConfigUsage {
publishedfileid: ::std::option::Option::None,
seconds_active: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_SetPlaytimeForControllerConfigs_Response {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_SetPlaytimeForControllerConfigs_Response {
fn default() -> &'a CPublishedFile_SetPlaytimeForControllerConfigs_Response {
<CPublishedFile_SetPlaytimeForControllerConfigs_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_SetPlaytimeForControllerConfigs_Response {
pub fn new() -> CPublishedFile_SetPlaytimeForControllerConfigs_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_SetPlaytimeForControllerConfigs_Response {
const NAME: &'static str = "CPublishedFile_SetPlaytimeForControllerConfigs_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() -> CPublishedFile_SetPlaytimeForControllerConfigs_Response {
CPublishedFile_SetPlaytimeForControllerConfigs_Response::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_SetPlaytimeForControllerConfigs_Response {
static instance: CPublishedFile_SetPlaytimeForControllerConfigs_Response = CPublishedFile_SetPlaytimeForControllerConfigs_Response {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Adds a parent->child relationship between the given items."]
pub struct CPublishedFile_AddChild_Request {
pub publishedfileid: ::std::option::Option<u64>,
pub child_publishedfileid: ::std::option::Option<u64>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_AddChild_Request {
fn default() -> &'a CPublishedFile_AddChild_Request {
<CPublishedFile_AddChild_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_AddChild_Request {
pub fn new() -> CPublishedFile_AddChild_Request {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
pub fn child_publishedfileid(&self) -> u64 {
self.child_publishedfileid.unwrap_or(0)
}
pub fn clear_child_publishedfileid(&mut self) {
self.child_publishedfileid = ::std::option::Option::None;
}
pub fn has_child_publishedfileid(&self) -> bool {
self.child_publishedfileid.is_some()
}
pub fn set_child_publishedfileid(&mut self, v: u64) {
self.child_publishedfileid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_AddChild_Request {
const NAME: &'static str = "CPublishedFile_AddChild_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.publishedfileid = ::std::option::Option::Some(is.read_uint64()?);
},
16 => {
self.child_publishedfileid = ::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.publishedfileid {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.child_publishedfileid {
my_size += ::protobuf::rt::uint64_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.publishedfileid {
os.write_uint64(1, v)?;
}
if let Some(v) = self.child_publishedfileid {
os.write_uint64(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() -> CPublishedFile_AddChild_Request {
CPublishedFile_AddChild_Request::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.child_publishedfileid = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_AddChild_Request {
static instance: CPublishedFile_AddChild_Request = CPublishedFile_AddChild_Request {
publishedfileid: ::std::option::Option::None,
child_publishedfileid: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_AddChild_Response {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_AddChild_Response {
fn default() -> &'a CPublishedFile_AddChild_Response {
<CPublishedFile_AddChild_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_AddChild_Response {
pub fn new() -> CPublishedFile_AddChild_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_AddChild_Response {
const NAME: &'static str = "CPublishedFile_AddChild_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() -> CPublishedFile_AddChild_Response {
CPublishedFile_AddChild_Response::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_AddChild_Response {
static instance: CPublishedFile_AddChild_Response = CPublishedFile_AddChild_Response {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Removes parent->child relationship between the given items."]
pub struct CPublishedFile_RemoveChild_Request {
pub publishedfileid: ::std::option::Option<u64>,
pub child_publishedfileid: ::std::option::Option<u64>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_RemoveChild_Request {
fn default() -> &'a CPublishedFile_RemoveChild_Request {
<CPublishedFile_RemoveChild_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_RemoveChild_Request {
pub fn new() -> CPublishedFile_RemoveChild_Request {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
pub fn child_publishedfileid(&self) -> u64 {
self.child_publishedfileid.unwrap_or(0)
}
pub fn clear_child_publishedfileid(&mut self) {
self.child_publishedfileid = ::std::option::Option::None;
}
pub fn has_child_publishedfileid(&self) -> bool {
self.child_publishedfileid.is_some()
}
pub fn set_child_publishedfileid(&mut self, v: u64) {
self.child_publishedfileid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_RemoveChild_Request {
const NAME: &'static str = "CPublishedFile_RemoveChild_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.publishedfileid = ::std::option::Option::Some(is.read_uint64()?);
},
16 => {
self.child_publishedfileid = ::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.publishedfileid {
my_size += ::protobuf::rt::uint64_size(1, v);
}
if let Some(v) = self.child_publishedfileid {
my_size += ::protobuf::rt::uint64_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.publishedfileid {
os.write_uint64(1, v)?;
}
if let Some(v) = self.child_publishedfileid {
os.write_uint64(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() -> CPublishedFile_RemoveChild_Request {
CPublishedFile_RemoveChild_Request::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.child_publishedfileid = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_RemoveChild_Request {
static instance: CPublishedFile_RemoveChild_Request = CPublishedFile_RemoveChild_Request {
publishedfileid: ::std::option::Option::None,
child_publishedfileid: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_RemoveChild_Response {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_RemoveChild_Response {
fn default() -> &'a CPublishedFile_RemoveChild_Response {
<CPublishedFile_RemoveChild_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_RemoveChild_Response {
pub fn new() -> CPublishedFile_RemoveChild_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_RemoveChild_Response {
const NAME: &'static str = "CPublishedFile_RemoveChild_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() -> CPublishedFile_RemoveChild_Response {
CPublishedFile_RemoveChild_Response::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_RemoveChild_Response {
static instance: CPublishedFile_RemoveChild_Response = CPublishedFile_RemoveChild_Response {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Get user vote summary"]
pub struct CPublishedFile_GetUserVoteSummary_Request {
pub publishedfileids: ::std::vec::Vec<u64>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetUserVoteSummary_Request {
fn default() -> &'a CPublishedFile_GetUserVoteSummary_Request {
<CPublishedFile_GetUserVoteSummary_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetUserVoteSummary_Request {
pub fn new() -> CPublishedFile_GetUserVoteSummary_Request {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_GetUserVoteSummary_Request {
const NAME: &'static str = "CPublishedFile_GetUserVoteSummary_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_fixed64_into(&mut self.publishedfileids)?;
},
9 => {
self.publishedfileids.push(is.read_fixed64()?);
},
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 += 9 * self.publishedfileids.len() as u64;
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.publishedfileids {
os.write_fixed64(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() -> CPublishedFile_GetUserVoteSummary_Request {
CPublishedFile_GetUserVoteSummary_Request::new()
}
fn clear(&mut self) {
self.publishedfileids.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetUserVoteSummary_Request {
static instance: CPublishedFile_GetUserVoteSummary_Request = CPublishedFile_GetUserVoteSummary_Request {
publishedfileids: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_GetUserVoteSummary_Response {
pub summaries: ::std::vec::Vec<cpublished_file_get_user_vote_summary_response::VoteSummary>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetUserVoteSummary_Response {
fn default() -> &'a CPublishedFile_GetUserVoteSummary_Response {
<CPublishedFile_GetUserVoteSummary_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetUserVoteSummary_Response {
pub fn new() -> CPublishedFile_GetUserVoteSummary_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_GetUserVoteSummary_Response {
const NAME: &'static str = "CPublishedFile_GetUserVoteSummary_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.summaries.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.summaries {
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.summaries {
::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() -> CPublishedFile_GetUserVoteSummary_Response {
CPublishedFile_GetUserVoteSummary_Response::new()
}
fn clear(&mut self) {
self.summaries.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetUserVoteSummary_Response {
static instance: CPublishedFile_GetUserVoteSummary_Response = CPublishedFile_GetUserVoteSummary_Response {
summaries: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
pub mod cpublished_file_get_user_vote_summary_response {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct VoteSummary {
pub publishedfileid: ::std::option::Option<u64>,
pub vote_for: ::std::option::Option<bool>,
pub vote_against: ::std::option::Option<bool>,
pub reported: ::std::option::Option<bool>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a VoteSummary {
fn default() -> &'a VoteSummary {
<VoteSummary as ::protobuf::Message>::default_instance()
}
}
impl VoteSummary {
pub fn new() -> VoteSummary {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
pub fn vote_for(&self) -> bool {
self.vote_for.unwrap_or(false)
}
pub fn clear_vote_for(&mut self) {
self.vote_for = ::std::option::Option::None;
}
pub fn has_vote_for(&self) -> bool {
self.vote_for.is_some()
}
pub fn set_vote_for(&mut self, v: bool) {
self.vote_for = ::std::option::Option::Some(v);
}
pub fn vote_against(&self) -> bool {
self.vote_against.unwrap_or(false)
}
pub fn clear_vote_against(&mut self) {
self.vote_against = ::std::option::Option::None;
}
pub fn has_vote_against(&self) -> bool {
self.vote_against.is_some()
}
pub fn set_vote_against(&mut self, v: bool) {
self.vote_against = ::std::option::Option::Some(v);
}
pub fn reported(&self) -> bool {
self.reported.unwrap_or(false)
}
pub fn clear_reported(&mut self) {
self.reported = ::std::option::Option::None;
}
pub fn has_reported(&self) -> bool {
self.reported.is_some()
}
pub fn set_reported(&mut self, v: bool) {
self.reported = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for VoteSummary {
const NAME: &'static str = "VoteSummary";
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 {
9 => {
self.publishedfileid = ::std::option::Option::Some(is.read_fixed64()?);
},
16 => {
self.vote_for = ::std::option::Option::Some(is.read_bool()?);
},
24 => {
self.vote_against = ::std::option::Option::Some(is.read_bool()?);
},
32 => {
self.reported = ::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.publishedfileid {
my_size += 1 + 8;
}
if let Some(v) = self.vote_for {
my_size += 1 + 1;
}
if let Some(v) = self.vote_against {
my_size += 1 + 1;
}
if let Some(v) = self.reported {
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.publishedfileid {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.vote_for {
os.write_bool(2, v)?;
}
if let Some(v) = self.vote_against {
os.write_bool(3, v)?;
}
if let Some(v) = self.reported {
os.write_bool(4, 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() -> VoteSummary {
VoteSummary::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.vote_for = ::std::option::Option::None;
self.vote_against = ::std::option::Option::None;
self.reported = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static VoteSummary {
static instance: VoteSummary = VoteSummary {
publishedfileid: ::std::option::Option::None,
vote_for: ::std::option::Option::None,
vote_against: ::std::option::Option::None,
reported: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Get list of updated items since given date"]
pub struct CPublishedFile_GetItemChanges_Request {
pub appid: ::std::option::Option<u32>,
pub last_time_updated: ::std::option::Option<u32>,
pub num_items_max: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetItemChanges_Request {
fn default() -> &'a CPublishedFile_GetItemChanges_Request {
<CPublishedFile_GetItemChanges_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetItemChanges_Request {
pub fn new() -> CPublishedFile_GetItemChanges_Request {
::std::default::Default::default()
}
pub fn appid(&self) -> u32 {
self.appid.unwrap_or(0)
}
pub fn clear_appid(&mut self) {
self.appid = ::std::option::Option::None;
}
pub fn has_appid(&self) -> bool {
self.appid.is_some()
}
pub fn set_appid(&mut self, v: u32) {
self.appid = ::std::option::Option::Some(v);
}
pub fn last_time_updated(&self) -> u32 {
self.last_time_updated.unwrap_or(0)
}
pub fn clear_last_time_updated(&mut self) {
self.last_time_updated = ::std::option::Option::None;
}
pub fn has_last_time_updated(&self) -> bool {
self.last_time_updated.is_some()
}
pub fn set_last_time_updated(&mut self, v: u32) {
self.last_time_updated = ::std::option::Option::Some(v);
}
pub fn num_items_max(&self) -> u32 {
self.num_items_max.unwrap_or(0)
}
pub fn clear_num_items_max(&mut self) {
self.num_items_max = ::std::option::Option::None;
}
pub fn has_num_items_max(&self) -> bool {
self.num_items_max.is_some()
}
pub fn set_num_items_max(&mut self, v: u32) {
self.num_items_max = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_GetItemChanges_Request {
const NAME: &'static str = "CPublishedFile_GetItemChanges_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.appid = ::std::option::Option::Some(is.read_uint32()?);
},
16 => {
self.last_time_updated = ::std::option::Option::Some(is.read_uint32()?);
},
24 => {
self.num_items_max = ::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.appid {
my_size += ::protobuf::rt::uint32_size(1, v);
}
if let Some(v) = self.last_time_updated {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.num_items_max {
my_size += ::protobuf::rt::uint32_size(3, 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.appid {
os.write_uint32(1, v)?;
}
if let Some(v) = self.last_time_updated {
os.write_uint32(2, v)?;
}
if let Some(v) = self.num_items_max {
os.write_uint32(3, 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() -> CPublishedFile_GetItemChanges_Request {
CPublishedFile_GetItemChanges_Request::new()
}
fn clear(&mut self) {
self.appid = ::std::option::Option::None;
self.last_time_updated = ::std::option::Option::None;
self.num_items_max = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetItemChanges_Request {
static instance: CPublishedFile_GetItemChanges_Request = CPublishedFile_GetItemChanges_Request {
appid: ::std::option::Option::None,
last_time_updated: ::std::option::Option::None,
num_items_max: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_GetItemChanges_Response {
pub update_time: ::std::option::Option<u32>,
pub workshop_items: ::std::vec::Vec<cpublished_file_get_item_changes_response::WorkshopItemInfo>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetItemChanges_Response {
fn default() -> &'a CPublishedFile_GetItemChanges_Response {
<CPublishedFile_GetItemChanges_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetItemChanges_Response {
pub fn new() -> CPublishedFile_GetItemChanges_Response {
::std::default::Default::default()
}
pub fn update_time(&self) -> u32 {
self.update_time.unwrap_or(0)
}
pub fn clear_update_time(&mut self) {
self.update_time = ::std::option::Option::None;
}
pub fn has_update_time(&self) -> bool {
self.update_time.is_some()
}
pub fn set_update_time(&mut self, v: u32) {
self.update_time = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_GetItemChanges_Response {
const NAME: &'static str = "CPublishedFile_GetItemChanges_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.update_time = ::std::option::Option::Some(is.read_uint32()?);
},
18 => {
self.workshop_items.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.update_time {
my_size += ::protobuf::rt::uint32_size(1, v);
}
for value in &self.workshop_items {
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.update_time {
os.write_uint32(1, v)?;
}
for v in &self.workshop_items {
::protobuf::rt::write_message_field_with_cached_size(2, 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() -> CPublishedFile_GetItemChanges_Response {
CPublishedFile_GetItemChanges_Response::new()
}
fn clear(&mut self) {
self.update_time = ::std::option::Option::None;
self.workshop_items.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetItemChanges_Response {
static instance: CPublishedFile_GetItemChanges_Response = CPublishedFile_GetItemChanges_Response {
update_time: ::std::option::Option::None,
workshop_items: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
pub mod cpublished_file_get_item_changes_response {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct WorkshopItemInfo {
pub published_file_id: ::std::option::Option<u64>,
pub time_updated: ::std::option::Option<u32>,
pub manifest_id: ::std::option::Option<u64>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a WorkshopItemInfo {
fn default() -> &'a WorkshopItemInfo {
<WorkshopItemInfo as ::protobuf::Message>::default_instance()
}
}
impl WorkshopItemInfo {
pub fn new() -> WorkshopItemInfo {
::std::default::Default::default()
}
pub fn published_file_id(&self) -> u64 {
self.published_file_id.unwrap_or(0)
}
pub fn clear_published_file_id(&mut self) {
self.published_file_id = ::std::option::Option::None;
}
pub fn has_published_file_id(&self) -> bool {
self.published_file_id.is_some()
}
pub fn set_published_file_id(&mut self, v: u64) {
self.published_file_id = ::std::option::Option::Some(v);
}
pub fn time_updated(&self) -> u32 {
self.time_updated.unwrap_or(0)
}
pub fn clear_time_updated(&mut self) {
self.time_updated = ::std::option::Option::None;
}
pub fn has_time_updated(&self) -> bool {
self.time_updated.is_some()
}
pub fn set_time_updated(&mut self, v: u32) {
self.time_updated = ::std::option::Option::Some(v);
}
pub fn manifest_id(&self) -> u64 {
self.manifest_id.unwrap_or(0)
}
pub fn clear_manifest_id(&mut self) {
self.manifest_id = ::std::option::Option::None;
}
pub fn has_manifest_id(&self) -> bool {
self.manifest_id.is_some()
}
pub fn set_manifest_id(&mut self, v: u64) {
self.manifest_id = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for WorkshopItemInfo {
const NAME: &'static str = "WorkshopItemInfo";
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 {
9 => {
self.published_file_id = ::std::option::Option::Some(is.read_fixed64()?);
},
16 => {
self.time_updated = ::std::option::Option::Some(is.read_uint32()?);
},
25 => {
self.manifest_id = ::std::option::Option::Some(is.read_fixed64()?);
},
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.published_file_id {
my_size += 1 + 8;
}
if let Some(v) = self.time_updated {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.manifest_id {
my_size += 1 + 8;
}
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.published_file_id {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.time_updated {
os.write_uint32(2, v)?;
}
if let Some(v) = self.manifest_id {
os.write_fixed64(3, 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() -> WorkshopItemInfo {
WorkshopItemInfo::new()
}
fn clear(&mut self) {
self.published_file_id = ::std::option::Option::None;
self.time_updated = ::std::option::Option::None;
self.manifest_id = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static WorkshopItemInfo {
static instance: WorkshopItemInfo = WorkshopItemInfo {
published_file_id: ::std::option::Option::None,
time_updated: ::std::option::Option::None,
manifest_id: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Returns more detailed information about the content descriptors for the published file"]
pub struct CPublishedFile_GetContentDescriptors_Request {
pub publishedfileid: ::std::option::Option<u64>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetContentDescriptors_Request {
fn default() -> &'a CPublishedFile_GetContentDescriptors_Request {
<CPublishedFile_GetContentDescriptors_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetContentDescriptors_Request {
pub fn new() -> CPublishedFile_GetContentDescriptors_Request {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_GetContentDescriptors_Request {
const NAME: &'static str = "CPublishedFile_GetContentDescriptors_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 {
9 => {
self.publishedfileid = ::std::option::Option::Some(is.read_fixed64()?);
},
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.publishedfileid {
my_size += 1 + 8;
}
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.publishedfileid {
os.write_fixed64(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() -> CPublishedFile_GetContentDescriptors_Request {
CPublishedFile_GetContentDescriptors_Request::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetContentDescriptors_Request {
static instance: CPublishedFile_GetContentDescriptors_Request = CPublishedFile_GetContentDescriptors_Request {
publishedfileid: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_GetContentDescriptors_Response {
pub content_descriptors: ::std::vec::Vec<cpublished_file_get_content_descriptors_response::ContentDescriptor>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_GetContentDescriptors_Response {
fn default() -> &'a CPublishedFile_GetContentDescriptors_Response {
<CPublishedFile_GetContentDescriptors_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_GetContentDescriptors_Response {
pub fn new() -> CPublishedFile_GetContentDescriptors_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CPublishedFile_GetContentDescriptors_Response {
const NAME: &'static str = "CPublishedFile_GetContentDescriptors_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.content_descriptors.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.content_descriptors {
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.content_descriptors {
::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() -> CPublishedFile_GetContentDescriptors_Response {
CPublishedFile_GetContentDescriptors_Response::new()
}
fn clear(&mut self) {
self.content_descriptors.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_GetContentDescriptors_Response {
static instance: CPublishedFile_GetContentDescriptors_Response = CPublishedFile_GetContentDescriptors_Response {
content_descriptors: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
pub mod cpublished_file_get_content_descriptors_response {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ContentDescriptor {
pub descriptorid: ::std::option::Option<::protobuf::EnumOrUnknown<super::super::enums_productinfo::EContentDescriptorID>>,
pub accountid: ::std::option::Option<u32>,
pub timestamp: ::std::option::Option<u32>,
pub moderator_set: ::std::option::Option<bool>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a ContentDescriptor {
fn default() -> &'a ContentDescriptor {
<ContentDescriptor as ::protobuf::Message>::default_instance()
}
}
impl ContentDescriptor {
pub fn new() -> ContentDescriptor {
::std::default::Default::default()
}
pub fn descriptorid(&self) -> super::super::enums_productinfo::EContentDescriptorID {
match self.descriptorid {
Some(e) => e.enum_value_or(super::super::enums_productinfo::EContentDescriptorID::k_EContentDescriptor_NudityOrSexualContent),
None => super::super::enums_productinfo::EContentDescriptorID::k_EContentDescriptor_NudityOrSexualContent,
}
}
pub fn clear_descriptorid(&mut self) {
self.descriptorid = ::std::option::Option::None;
}
pub fn has_descriptorid(&self) -> bool {
self.descriptorid.is_some()
}
pub fn set_descriptorid(&mut self, v: super::super::enums_productinfo::EContentDescriptorID) {
self.descriptorid = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
}
pub fn accountid(&self) -> u32 {
self.accountid.unwrap_or(0)
}
pub fn clear_accountid(&mut self) {
self.accountid = ::std::option::Option::None;
}
pub fn has_accountid(&self) -> bool {
self.accountid.is_some()
}
pub fn set_accountid(&mut self, v: u32) {
self.accountid = ::std::option::Option::Some(v);
}
pub fn timestamp(&self) -> u32 {
self.timestamp.unwrap_or(0)
}
pub fn clear_timestamp(&mut self) {
self.timestamp = ::std::option::Option::None;
}
pub fn has_timestamp(&self) -> bool {
self.timestamp.is_some()
}
pub fn set_timestamp(&mut self, v: u32) {
self.timestamp = ::std::option::Option::Some(v);
}
pub fn moderator_set(&self) -> bool {
self.moderator_set.unwrap_or(false)
}
pub fn clear_moderator_set(&mut self) {
self.moderator_set = ::std::option::Option::None;
}
pub fn has_moderator_set(&self) -> bool {
self.moderator_set.is_some()
}
pub fn set_moderator_set(&mut self, v: bool) {
self.moderator_set = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for ContentDescriptor {
const NAME: &'static str = "ContentDescriptor";
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.descriptorid = ::std::option::Option::Some(is.read_enum_or_unknown()?);
},
16 => {
self.accountid = ::std::option::Option::Some(is.read_uint32()?);
},
24 => {
self.timestamp = ::std::option::Option::Some(is.read_uint32()?);
},
32 => {
self.moderator_set = ::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.descriptorid {
my_size += ::protobuf::rt::int32_size(1, v.value());
}
if let Some(v) = self.accountid {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.timestamp {
my_size += ::protobuf::rt::uint32_size(3, v);
}
if let Some(v) = self.moderator_set {
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.descriptorid {
os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?;
}
if let Some(v) = self.accountid {
os.write_uint32(2, v)?;
}
if let Some(v) = self.timestamp {
os.write_uint32(3, v)?;
}
if let Some(v) = self.moderator_set {
os.write_bool(4, 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() -> ContentDescriptor {
ContentDescriptor::new()
}
fn clear(&mut self) {
self.descriptorid = ::std::option::Option::None;
self.accountid = ::std::option::Option::None;
self.timestamp = ::std::option::Option::None;
self.moderator_set = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static ContentDescriptor {
static instance: ContentDescriptor = ContentDescriptor {
descriptorid: ::std::option::Option::None,
accountid: ::std::option::Option::None,
timestamp: ::std::option::Option::None,
moderator_set: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Updates content descriptors on the published file"]
pub struct CPublishedFile_UpdateContentDescriptors_Request {
pub publishedfileid: ::std::option::Option<u64>,
pub descriptors_to_add: ::std::vec::Vec<::protobuf::EnumOrUnknown<super::enums_productinfo::EContentDescriptorID>>,
pub descriptors_to_remove: ::std::vec::Vec<::protobuf::EnumOrUnknown<super::enums_productinfo::EContentDescriptorID>>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_UpdateContentDescriptors_Request {
fn default() -> &'a CPublishedFile_UpdateContentDescriptors_Request {
<CPublishedFile_UpdateContentDescriptors_Request as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_UpdateContentDescriptors_Request {
pub fn new() -> CPublishedFile_UpdateContentDescriptors_Request {
::std::default::Default::default()
}
pub fn publishedfileid(&self) -> u64 {
self.publishedfileid.unwrap_or(0)
}
pub fn clear_publishedfileid(&mut self) {
self.publishedfileid = ::std::option::Option::None;
}
pub fn has_publishedfileid(&self) -> bool {
self.publishedfileid.is_some()
}
pub fn set_publishedfileid(&mut self, v: u64) {
self.publishedfileid = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_UpdateContentDescriptors_Request {
const NAME: &'static str = "CPublishedFile_UpdateContentDescriptors_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 {
9 => {
self.publishedfileid = ::std::option::Option::Some(is.read_fixed64()?);
},
16 => {
self.descriptors_to_add.push(is.read_enum_or_unknown()?);
},
18 => {
::protobuf::rt::read_repeated_packed_enum_or_unknown_into(is, &mut self.descriptors_to_add)?
},
24 => {
self.descriptors_to_remove.push(is.read_enum_or_unknown()?);
},
26 => {
::protobuf::rt::read_repeated_packed_enum_or_unknown_into(is, &mut self.descriptors_to_remove)?
},
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.publishedfileid {
my_size += 1 + 8;
}
for value in &self.descriptors_to_add {
my_size += ::protobuf::rt::int32_size(2, value.value());
};
for value in &self.descriptors_to_remove {
my_size += ::protobuf::rt::int32_size(3, value.value());
};
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.publishedfileid {
os.write_fixed64(1, v)?;
}
for v in &self.descriptors_to_add {
os.write_enum(2, ::protobuf::EnumOrUnknown::value(v))?;
};
for v in &self.descriptors_to_remove {
os.write_enum(3, ::protobuf::EnumOrUnknown::value(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() -> CPublishedFile_UpdateContentDescriptors_Request {
CPublishedFile_UpdateContentDescriptors_Request::new()
}
fn clear(&mut self) {
self.publishedfileid = ::std::option::Option::None;
self.descriptors_to_add.clear();
self.descriptors_to_remove.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_UpdateContentDescriptors_Request {
static instance: CPublishedFile_UpdateContentDescriptors_Request = CPublishedFile_UpdateContentDescriptors_Request {
publishedfileid: ::std::option::Option::None,
descriptors_to_add: ::std::vec::Vec::new(),
descriptors_to_remove: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct CPublishedFile_UpdateContentDescriptors_Response {
pub timestamp_updated: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_UpdateContentDescriptors_Response {
fn default() -> &'a CPublishedFile_UpdateContentDescriptors_Response {
<CPublishedFile_UpdateContentDescriptors_Response as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_UpdateContentDescriptors_Response {
pub fn new() -> CPublishedFile_UpdateContentDescriptors_Response {
::std::default::Default::default()
}
pub fn timestamp_updated(&self) -> u32 {
self.timestamp_updated.unwrap_or(0)
}
pub fn clear_timestamp_updated(&mut self) {
self.timestamp_updated = ::std::option::Option::None;
}
pub fn has_timestamp_updated(&self) -> bool {
self.timestamp_updated.is_some()
}
pub fn set_timestamp_updated(&mut self, v: u32) {
self.timestamp_updated = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_UpdateContentDescriptors_Response {
const NAME: &'static str = "CPublishedFile_UpdateContentDescriptors_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.timestamp_updated = ::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.timestamp_updated {
my_size += ::protobuf::rt::uint32_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.timestamp_updated {
os.write_uint32(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() -> CPublishedFile_UpdateContentDescriptors_Response {
CPublishedFile_UpdateContentDescriptors_Response::new()
}
fn clear(&mut self) {
self.timestamp_updated = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_UpdateContentDescriptors_Response {
static instance: CPublishedFile_UpdateContentDescriptors_Response = CPublishedFile_UpdateContentDescriptors_Response {
timestamp_updated: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Notification from the server when a user subscribes to a file"]
pub struct CPublishedFile_FileSubscribed_Notification {
pub published_file_id: ::std::option::Option<u64>,
pub app_id: ::std::option::Option<u32>,
pub file_hcontent: ::std::option::Option<u64>,
pub file_size: ::std::option::Option<u32>,
pub rtime_subscribed: ::std::option::Option<u32>,
pub is_depot_content: ::std::option::Option<bool>,
pub rtime_updated: ::std::option::Option<u32>,
pub revisions: ::std::vec::Vec<cpublished_file_file_subscribed_notification::RevisionData>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_FileSubscribed_Notification {
fn default() -> &'a CPublishedFile_FileSubscribed_Notification {
<CPublishedFile_FileSubscribed_Notification as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_FileSubscribed_Notification {
pub fn new() -> CPublishedFile_FileSubscribed_Notification {
::std::default::Default::default()
}
pub fn published_file_id(&self) -> u64 {
self.published_file_id.unwrap_or(0)
}
pub fn clear_published_file_id(&mut self) {
self.published_file_id = ::std::option::Option::None;
}
pub fn has_published_file_id(&self) -> bool {
self.published_file_id.is_some()
}
pub fn set_published_file_id(&mut self, v: u64) {
self.published_file_id = ::std::option::Option::Some(v);
}
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 file_hcontent(&self) -> u64 {
self.file_hcontent.unwrap_or(0)
}
pub fn clear_file_hcontent(&mut self) {
self.file_hcontent = ::std::option::Option::None;
}
pub fn has_file_hcontent(&self) -> bool {
self.file_hcontent.is_some()
}
pub fn set_file_hcontent(&mut self, v: u64) {
self.file_hcontent = ::std::option::Option::Some(v);
}
pub fn file_size(&self) -> u32 {
self.file_size.unwrap_or(0)
}
pub fn clear_file_size(&mut self) {
self.file_size = ::std::option::Option::None;
}
pub fn has_file_size(&self) -> bool {
self.file_size.is_some()
}
pub fn set_file_size(&mut self, v: u32) {
self.file_size = ::std::option::Option::Some(v);
}
pub fn rtime_subscribed(&self) -> u32 {
self.rtime_subscribed.unwrap_or(0)
}
pub fn clear_rtime_subscribed(&mut self) {
self.rtime_subscribed = ::std::option::Option::None;
}
pub fn has_rtime_subscribed(&self) -> bool {
self.rtime_subscribed.is_some()
}
pub fn set_rtime_subscribed(&mut self, v: u32) {
self.rtime_subscribed = ::std::option::Option::Some(v);
}
pub fn is_depot_content(&self) -> bool {
self.is_depot_content.unwrap_or(false)
}
pub fn clear_is_depot_content(&mut self) {
self.is_depot_content = ::std::option::Option::None;
}
pub fn has_is_depot_content(&self) -> bool {
self.is_depot_content.is_some()
}
pub fn set_is_depot_content(&mut self, v: bool) {
self.is_depot_content = ::std::option::Option::Some(v);
}
pub fn rtime_updated(&self) -> u32 {
self.rtime_updated.unwrap_or(0)
}
pub fn clear_rtime_updated(&mut self) {
self.rtime_updated = ::std::option::Option::None;
}
pub fn has_rtime_updated(&self) -> bool {
self.rtime_updated.is_some()
}
pub fn set_rtime_updated(&mut self, v: u32) {
self.rtime_updated = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for CPublishedFile_FileSubscribed_Notification {
const NAME: &'static str = "CPublishedFile_FileSubscribed_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 {
9 => {
self.published_file_id = ::std::option::Option::Some(is.read_fixed64()?);
},
16 => {
self.app_id = ::std::option::Option::Some(is.read_uint32()?);
},
25 => {
self.file_hcontent = ::std::option::Option::Some(is.read_fixed64()?);
},
32 => {
self.file_size = ::std::option::Option::Some(is.read_uint32()?);
},
40 => {
self.rtime_subscribed = ::std::option::Option::Some(is.read_uint32()?);
},
48 => {
self.is_depot_content = ::std::option::Option::Some(is.read_bool()?);
},
56 => {
self.rtime_updated = ::std::option::Option::Some(is.read_uint32()?);
},
66 => {
self.revisions.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.published_file_id {
my_size += 1 + 8;
}
if let Some(v) = self.app_id {
my_size += ::protobuf::rt::uint32_size(2, v);
}
if let Some(v) = self.file_hcontent {
my_size += 1 + 8;
}
if let Some(v) = self.file_size {
my_size += ::protobuf::rt::uint32_size(4, v);
}
if let Some(v) = self.rtime_subscribed {
my_size += ::protobuf::rt::uint32_size(5, v);
}
if let Some(v) = self.is_depot_content {
my_size += 1 + 1;
}
if let Some(v) = self.rtime_updated {
my_size += ::protobuf::rt::uint32_size(7, v);
}
for value in &self.revisions {
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.published_file_id {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.app_id {
os.write_uint32(2, v)?;
}
if let Some(v) = self.file_hcontent {
os.write_fixed64(3, v)?;
}
if let Some(v) = self.file_size {
os.write_uint32(4, v)?;
}
if let Some(v) = self.rtime_subscribed {
os.write_uint32(5, v)?;
}
if let Some(v) = self.is_depot_content {
os.write_bool(6, v)?;
}
if let Some(v) = self.rtime_updated {
os.write_uint32(7, v)?;
}
for v in &self.revisions {
::protobuf::rt::write_message_field_with_cached_size(8, 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() -> CPublishedFile_FileSubscribed_Notification {
CPublishedFile_FileSubscribed_Notification::new()
}
fn clear(&mut self) {
self.published_file_id = ::std::option::Option::None;
self.app_id = ::std::option::Option::None;
self.file_hcontent = ::std::option::Option::None;
self.file_size = ::std::option::Option::None;
self.rtime_subscribed = ::std::option::Option::None;
self.is_depot_content = ::std::option::Option::None;
self.rtime_updated = ::std::option::Option::None;
self.revisions.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_FileSubscribed_Notification {
static instance: CPublishedFile_FileSubscribed_Notification = CPublishedFile_FileSubscribed_Notification {
published_file_id: ::std::option::Option::None,
app_id: ::std::option::Option::None,
file_hcontent: ::std::option::Option::None,
file_size: ::std::option::Option::None,
rtime_subscribed: ::std::option::Option::None,
is_depot_content: ::std::option::Option::None,
rtime_updated: ::std::option::Option::None,
revisions: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
pub mod cpublished_file_file_subscribed_notification {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct RevisionData {
pub revision: ::std::option::Option<::protobuf::EnumOrUnknown<super::EPublishedFileRevision>>,
pub file_hcontent: ::std::option::Option<u64>,
pub rtime_updated: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a RevisionData {
fn default() -> &'a RevisionData {
<RevisionData as ::protobuf::Message>::default_instance()
}
}
impl RevisionData {
pub fn new() -> RevisionData {
::std::default::Default::default()
}
pub fn revision(&self) -> super::EPublishedFileRevision {
match self.revision {
Some(e) => e.enum_value_or(super::EPublishedFileRevision::k_EPublishedFileRevision_Default),
None => super::EPublishedFileRevision::k_EPublishedFileRevision_Default,
}
}
pub fn clear_revision(&mut self) {
self.revision = ::std::option::Option::None;
}
pub fn has_revision(&self) -> bool {
self.revision.is_some()
}
pub fn set_revision(&mut self, v: super::EPublishedFileRevision) {
self.revision = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
}
pub fn file_hcontent(&self) -> u64 {
self.file_hcontent.unwrap_or(0)
}
pub fn clear_file_hcontent(&mut self) {
self.file_hcontent = ::std::option::Option::None;
}
pub fn has_file_hcontent(&self) -> bool {
self.file_hcontent.is_some()
}
pub fn set_file_hcontent(&mut self, v: u64) {
self.file_hcontent = ::std::option::Option::Some(v);
}
pub fn rtime_updated(&self) -> u32 {
self.rtime_updated.unwrap_or(0)
}
pub fn clear_rtime_updated(&mut self) {
self.rtime_updated = ::std::option::Option::None;
}
pub fn has_rtime_updated(&self) -> bool {
self.rtime_updated.is_some()
}
pub fn set_rtime_updated(&mut self, v: u32) {
self.rtime_updated = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for RevisionData {
const NAME: &'static str = "RevisionData";
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.revision = ::std::option::Option::Some(is.read_enum_or_unknown()?);
},
17 => {
self.file_hcontent = ::std::option::Option::Some(is.read_fixed64()?);
},
24 => {
self.rtime_updated = ::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.revision {
my_size += ::protobuf::rt::int32_size(1, v.value());
}
if let Some(v) = self.file_hcontent {
my_size += 1 + 8;
}
if let Some(v) = self.rtime_updated {
my_size += ::protobuf::rt::uint32_size(3, 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.revision {
os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?;
}
if let Some(v) = self.file_hcontent {
os.write_fixed64(2, v)?;
}
if let Some(v) = self.rtime_updated {
os.write_uint32(3, 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() -> RevisionData {
RevisionData::new()
}
fn clear(&mut self) {
self.revision = ::std::option::Option::None;
self.file_hcontent = ::std::option::Option::None;
self.rtime_updated = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static RevisionData {
static instance: RevisionData = RevisionData {
revision: ::std::option::Option::None,
file_hcontent: ::std::option::Option::None,
rtime_updated: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Notification from the server when a user unsubscribes from a file"]
pub struct CPublishedFile_FileUnsubscribed_Notification {
pub published_file_id: ::std::option::Option<u64>,
pub app_id: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_FileUnsubscribed_Notification {
fn default() -> &'a CPublishedFile_FileUnsubscribed_Notification {
<CPublishedFile_FileUnsubscribed_Notification as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_FileUnsubscribed_Notification {
pub fn new() -> CPublishedFile_FileUnsubscribed_Notification {
::std::default::Default::default()
}
pub fn published_file_id(&self) -> u64 {
self.published_file_id.unwrap_or(0)
}
pub fn clear_published_file_id(&mut self) {
self.published_file_id = ::std::option::Option::None;
}
pub fn has_published_file_id(&self) -> bool {
self.published_file_id.is_some()
}
pub fn set_published_file_id(&mut self, v: u64) {
self.published_file_id = ::std::option::Option::Some(v);
}
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);
}
}
impl ::protobuf::Message for CPublishedFile_FileUnsubscribed_Notification {
const NAME: &'static str = "CPublishedFile_FileUnsubscribed_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 {
9 => {
self.published_file_id = ::std::option::Option::Some(is.read_fixed64()?);
},
16 => {
self.app_id = ::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.published_file_id {
my_size += 1 + 8;
}
if let Some(v) = self.app_id {
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.published_file_id {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.app_id {
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() -> CPublishedFile_FileUnsubscribed_Notification {
CPublishedFile_FileUnsubscribed_Notification::new()
}
fn clear(&mut self) {
self.published_file_id = ::std::option::Option::None;
self.app_id = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_FileUnsubscribed_Notification {
static instance: CPublishedFile_FileUnsubscribed_Notification = CPublishedFile_FileUnsubscribed_Notification {
published_file_id: ::std::option::Option::None,
app_id: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(PartialEq,Clone,Default,Debug)]
#[doc = "Notification from the server when a published file is deleted"]
pub struct CPublishedFile_FileDeleted_Client_Notification {
pub published_file_id: ::std::option::Option<u64>,
pub app_id: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a CPublishedFile_FileDeleted_Client_Notification {
fn default() -> &'a CPublishedFile_FileDeleted_Client_Notification {
<CPublishedFile_FileDeleted_Client_Notification as ::protobuf::Message>::default_instance()
}
}
impl CPublishedFile_FileDeleted_Client_Notification {
pub fn new() -> CPublishedFile_FileDeleted_Client_Notification {
::std::default::Default::default()
}
pub fn published_file_id(&self) -> u64 {
self.published_file_id.unwrap_or(0)
}
pub fn clear_published_file_id(&mut self) {
self.published_file_id = ::std::option::Option::None;
}
pub fn has_published_file_id(&self) -> bool {
self.published_file_id.is_some()
}
pub fn set_published_file_id(&mut self, v: u64) {
self.published_file_id = ::std::option::Option::Some(v);
}
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);
}
}
impl ::protobuf::Message for CPublishedFile_FileDeleted_Client_Notification {
const NAME: &'static str = "CPublishedFile_FileDeleted_Client_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 {
9 => {
self.published_file_id = ::std::option::Option::Some(is.read_fixed64()?);
},
16 => {
self.app_id = ::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.published_file_id {
my_size += 1 + 8;
}
if let Some(v) = self.app_id {
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.published_file_id {
os.write_fixed64(1, v)?;
}
if let Some(v) = self.app_id {
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() -> CPublishedFile_FileDeleted_Client_Notification {
CPublishedFile_FileDeleted_Client_Notification::new()
}
fn clear(&mut self) {
self.published_file_id = ::std::option::Option::None;
self.app_id = ::std::option::Option::None;
self.special_fields.clear();
}
fn default_instance() -> &'static CPublishedFile_FileDeleted_Client_Notification {
static instance: CPublishedFile_FileDeleted_Client_Notification = CPublishedFile_FileDeleted_Client_Notification {
published_file_id: ::std::option::Option::None,
app_id: ::std::option::Option::None,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
pub enum EPublishedFileRevision {
k_EPublishedFileRevision_Default = 0,
k_EPublishedFileRevision_Latest = 1,
k_EPublishedFileRevision_ApprovedSnapshot = 2,
k_EPublishedFileRevision_ApprovedSnapshot_China = 3,
k_EPublishedFileRevision_RejectedSnapshot = 4,
k_EPublishedFileRevision_RejectedSnapshot_China = 5,
}
impl ::protobuf::Enum for EPublishedFileRevision {
const NAME: &'static str = "EPublishedFileRevision";
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<EPublishedFileRevision> {
match value {
0 => ::std::option::Option::Some(EPublishedFileRevision::k_EPublishedFileRevision_Default),
1 => ::std::option::Option::Some(EPublishedFileRevision::k_EPublishedFileRevision_Latest),
2 => ::std::option::Option::Some(EPublishedFileRevision::k_EPublishedFileRevision_ApprovedSnapshot),
3 => ::std::option::Option::Some(EPublishedFileRevision::k_EPublishedFileRevision_ApprovedSnapshot_China),
4 => ::std::option::Option::Some(EPublishedFileRevision::k_EPublishedFileRevision_RejectedSnapshot),
5 => ::std::option::Option::Some(EPublishedFileRevision::k_EPublishedFileRevision_RejectedSnapshot_China),
_ => ::std::option::Option::None
}
}
const VALUES: &'static [EPublishedFileRevision] = &[
EPublishedFileRevision::k_EPublishedFileRevision_Default,
EPublishedFileRevision::k_EPublishedFileRevision_Latest,
EPublishedFileRevision::k_EPublishedFileRevision_ApprovedSnapshot,
EPublishedFileRevision::k_EPublishedFileRevision_ApprovedSnapshot_China,
EPublishedFileRevision::k_EPublishedFileRevision_RejectedSnapshot,
EPublishedFileRevision::k_EPublishedFileRevision_RejectedSnapshot_China,
];
}
impl ::std::default::Default for EPublishedFileRevision {
fn default() -> Self {
EPublishedFileRevision::k_EPublishedFileRevision_Default
}
}
#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
pub enum EPublishedFileForSaleStatus {
k_PFFSS_NotForSale = 0,
k_PFFSS_PendingApproval = 1,
k_PFFSS_ApprovedForSale = 2,
k_PFFSS_RejectedForSale = 3,
k_PFFSS_NoLongerForSale = 4,
k_PFFSS_TentativeApproval = 5,
}
impl ::protobuf::Enum for EPublishedFileForSaleStatus {
const NAME: &'static str = "EPublishedFileForSaleStatus";
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<EPublishedFileForSaleStatus> {
match value {
0 => ::std::option::Option::Some(EPublishedFileForSaleStatus::k_PFFSS_NotForSale),
1 => ::std::option::Option::Some(EPublishedFileForSaleStatus::k_PFFSS_PendingApproval),
2 => ::std::option::Option::Some(EPublishedFileForSaleStatus::k_PFFSS_ApprovedForSale),
3 => ::std::option::Option::Some(EPublishedFileForSaleStatus::k_PFFSS_RejectedForSale),
4 => ::std::option::Option::Some(EPublishedFileForSaleStatus::k_PFFSS_NoLongerForSale),
5 => ::std::option::Option::Some(EPublishedFileForSaleStatus::k_PFFSS_TentativeApproval),
_ => ::std::option::Option::None
}
}
const VALUES: &'static [EPublishedFileForSaleStatus] = &[
EPublishedFileForSaleStatus::k_PFFSS_NotForSale,
EPublishedFileForSaleStatus::k_PFFSS_PendingApproval,
EPublishedFileForSaleStatus::k_PFFSS_ApprovedForSale,
EPublishedFileForSaleStatus::k_PFFSS_RejectedForSale,
EPublishedFileForSaleStatus::k_PFFSS_NoLongerForSale,
EPublishedFileForSaleStatus::k_PFFSS_TentativeApproval,
];
}
impl ::std::default::Default for EPublishedFileForSaleStatus {
fn default() -> Self {
EPublishedFileForSaleStatus::k_PFFSS_NotForSale
}
}
#[allow(unused_imports)]
use crate::steammessages_base::*;
#[allow(unused_imports)]
use crate::steammessages_unified_base_steamclient::*;
#[allow(unused_imports)]
use crate::enums_productinfo::*;
impl crate::RpcMessage for CPublishedFile_Vote_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 CPublishedFile_Vote_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 CPublishedFile_Subscribe_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 CPublishedFile_Subscribe_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 CPublishedFile_Unsubscribe_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 CPublishedFile_Unsubscribe_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 CPublishedFile_CanSubscribe_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 CPublishedFile_CanSubscribe_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 CPublishedFile_GetSubSectionData_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 PublishedFileSubSection {
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 CPublishedFile_GetSubSectionData_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 CPublishedFile_Publish_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 CPublishedFile_Publish_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 CPublishedFile_GetDetails_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 PublishedFileDetails {
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 CPublishedFile_GetDetails_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 CPublishedFile_GetItemInfo_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 CPublishedFile_GetItemInfo_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 CPublishedFile_GetUserFiles_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 CPublishedFile_GetUserFiles_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 CPublishedFile_AreFilesInSubscriptionList_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 CPublishedFile_AreFilesInSubscriptionList_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 CPublishedFile_Update_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 CPublishedFile_Update_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 CPublishedFile_Delete_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 CPublishedFile_Delete_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 CPublishedFile_GetChangeHistoryEntry_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 CPublishedFile_GetChangeHistoryEntry_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 CPublishedFile_GetChangeHistory_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 CPublishedFile_GetChangeHistory_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 CPublishedFile_RefreshVotingQueue_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 CPublishedFile_RefreshVotingQueue_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 CPublishedFile_QueryFiles_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 CPublishedFile_QueryFiles_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 CPublishedFile_AddAppRelationship_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 CPublishedFile_AddAppRelationship_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 CPublishedFile_RemoveAppRelationship_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 CPublishedFile_RemoveAppRelationship_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 CPublishedFile_GetAppRelationships_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 CPublishedFile_GetAppRelationships_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 CPublishedFile_GetAppRelationshipsBatched_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 CPublishedFile_GetAppRelationshipsBatched_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 CPublishedFile_StartPlaytimeTracking_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 CPublishedFile_StartPlaytimeTracking_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 CPublishedFile_StopPlaytimeTracking_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 CPublishedFile_StopPlaytimeTracking_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 CPublishedFile_StopPlaytimeTrackingForAllAppItems_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 CPublishedFile_StopPlaytimeTrackingForAllAppItems_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 CPublishedFile_SetPlaytimeForControllerConfigs_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 CPublishedFile_SetPlaytimeForControllerConfigs_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 CPublishedFile_AddChild_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 CPublishedFile_AddChild_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 CPublishedFile_RemoveChild_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 CPublishedFile_RemoveChild_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 CPublishedFile_GetUserVoteSummary_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 CPublishedFile_GetUserVoteSummary_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 CPublishedFile_GetItemChanges_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 CPublishedFile_GetItemChanges_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 CPublishedFile_GetContentDescriptors_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 CPublishedFile_GetContentDescriptors_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 CPublishedFile_UpdateContentDescriptors_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 CPublishedFile_UpdateContentDescriptors_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 CPublishedFile_FileSubscribed_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 CPublishedFile_FileUnsubscribed_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 CPublishedFile_FileDeleted_Client_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
}
}
struct PublishedFile {}
impl crate::RpcService for PublishedFile {
const SERVICE_NAME: &'static str = "PublishedFile";
}
struct PublishedFileClient {}
impl crate::RpcService for PublishedFileClient {
const SERVICE_NAME: &'static str = "PublishedFileClient";
}
impl crate::RpcMethod for CPublishedFile_AddAppRelationship_Request {
const METHOD_NAME: &'static str = "PublishedFile.AddAppRelationship#1";
type Response = CPublishedFile_AddAppRelationship_Response;
}
impl crate::RpcMethod for CPublishedFile_AddChild_Request {
const METHOD_NAME: &'static str = "PublishedFile.AddChild#1";
type Response = CPublishedFile_AddChild_Response;
}
impl crate::RpcMethod for CPublishedFile_AreFilesInSubscriptionList_Request {
const METHOD_NAME: &'static str = "PublishedFile.AreFilesInSubscriptionList#1";
type Response = CPublishedFile_AreFilesInSubscriptionList_Response;
}
impl crate::RpcMethod for CPublishedFile_CanSubscribe_Request {
const METHOD_NAME: &'static str = "PublishedFile.CanSubscribe#1";
type Response = CPublishedFile_CanSubscribe_Response;
}
impl crate::RpcMethod for CPublishedFile_Delete_Request {
const METHOD_NAME: &'static str = "PublishedFile.Delete#1";
type Response = CPublishedFile_Delete_Response;
}
impl crate::RpcMethod for CPublishedFile_FileDeleted_Client_Notification {
const METHOD_NAME: &'static str = "PublishedFileClient.NotifyFileDeleted#1";
type Response = ();
}
impl crate::RpcMethod for CPublishedFile_FileSubscribed_Notification {
const METHOD_NAME: &'static str = "PublishedFileClient.NotifyFileSubscribed#1";
type Response = ();
}
impl crate::RpcMethod for CPublishedFile_FileUnsubscribed_Notification {
const METHOD_NAME: &'static str = "PublishedFileClient.NotifyFileUnsubscribed#1";
type Response = ();
}
impl crate::RpcMethod for CPublishedFile_GetAppRelationshipsBatched_Request {
const METHOD_NAME: &'static str = "PublishedFile.GetAppRelationshipsBatched#1";
type Response = CPublishedFile_GetAppRelationshipsBatched_Response;
}
impl crate::RpcMethod for CPublishedFile_GetAppRelationships_Request {
const METHOD_NAME: &'static str = "PublishedFile.GetAppRelationships#1";
type Response = CPublishedFile_GetAppRelationships_Response;
}
impl crate::RpcMethod for CPublishedFile_GetChangeHistoryEntry_Request {
const METHOD_NAME: &'static str = "PublishedFile.GetChangeHistoryEntry#1";
type Response = CPublishedFile_GetChangeHistoryEntry_Response;
}
impl crate::RpcMethod for CPublishedFile_GetChangeHistory_Request {
const METHOD_NAME: &'static str = "PublishedFile.GetChangeHistory#1";
type Response = CPublishedFile_GetChangeHistory_Response;
}
impl crate::RpcMethod for CPublishedFile_GetContentDescriptors_Request {
const METHOD_NAME: &'static str = "PublishedFile.GetContentDescriptors#1";
type Response = CPublishedFile_GetContentDescriptors_Response;
}
impl crate::RpcMethod for CPublishedFile_GetDetails_Request {
const METHOD_NAME: &'static str = "PublishedFile.GetDetails#1";
type Response = CPublishedFile_GetDetails_Response;
}
impl crate::RpcMethod for CPublishedFile_GetItemChanges_Request {
const METHOD_NAME: &'static str = "PublishedFile.GetItemChanges#1";
type Response = CPublishedFile_GetItemChanges_Response;
}
impl crate::RpcMethod for CPublishedFile_GetItemInfo_Request {
const METHOD_NAME: &'static str = "PublishedFile.GetItemInfo#1";
type Response = CPublishedFile_GetItemInfo_Response;
}
impl crate::RpcMethod for CPublishedFile_GetSubSectionData_Request {
const METHOD_NAME: &'static str = "PublishedFile.GetSubSectionData#1";
type Response = CPublishedFile_GetSubSectionData_Response;
}
impl crate::RpcMethod for CPublishedFile_GetUserFiles_Request {
const METHOD_NAME: &'static str = "PublishedFile.GetUserFiles#1";
type Response = CPublishedFile_GetUserFiles_Response;
}
impl crate::RpcMethod for CPublishedFile_GetUserVoteSummary_Request {
const METHOD_NAME: &'static str = "PublishedFile.GetUserVoteSummary#1";
type Response = CPublishedFile_GetUserVoteSummary_Response;
}
impl crate::RpcMethod for CPublishedFile_Publish_Request {
const METHOD_NAME: &'static str = "PublishedFile.Publish#1";
type Response = CPublishedFile_Publish_Response;
}
impl crate::RpcMethod for CPublishedFile_QueryFiles_Request {
const METHOD_NAME: &'static str = "PublishedFile.QueryFiles#1";
type Response = CPublishedFile_QueryFiles_Response;
}
impl crate::RpcMethod for CPublishedFile_RefreshVotingQueue_Request {
const METHOD_NAME: &'static str = "PublishedFile.RefreshVotingQueue#1";
type Response = CPublishedFile_RefreshVotingQueue_Response;
}
impl crate::RpcMethod for CPublishedFile_RemoveAppRelationship_Request {
const METHOD_NAME: &'static str = "PublishedFile.RemoveAppRelationship#1";
type Response = CPublishedFile_RemoveAppRelationship_Response;
}
impl crate::RpcMethod for CPublishedFile_RemoveChild_Request {
const METHOD_NAME: &'static str = "PublishedFile.RemoveChild#1";
type Response = CPublishedFile_RemoveChild_Response;
}
impl crate::RpcMethod for CPublishedFile_SetPlaytimeForControllerConfigs_Request {
const METHOD_NAME: &'static str = "PublishedFile.SetPlaytimeForControllerConfigs#1";
type Response = CPublishedFile_SetPlaytimeForControllerConfigs_Response;
}
impl crate::RpcMethod for CPublishedFile_StartPlaytimeTracking_Request {
const METHOD_NAME: &'static str = "PublishedFile.StartPlaytimeTracking#1";
type Response = CPublishedFile_StartPlaytimeTracking_Response;
}
impl crate::RpcMethod for CPublishedFile_StopPlaytimeTrackingForAllAppItems_Request {
const METHOD_NAME: &'static str = "PublishedFile.StopPlaytimeTrackingForAllAppItems#1";
type Response = CPublishedFile_StopPlaytimeTrackingForAllAppItems_Response;
}
impl crate::RpcMethod for CPublishedFile_StopPlaytimeTracking_Request {
const METHOD_NAME: &'static str = "PublishedFile.StopPlaytimeTracking#1";
type Response = CPublishedFile_StopPlaytimeTracking_Response;
}
impl crate::RpcMethod for CPublishedFile_Subscribe_Request {
const METHOD_NAME: &'static str = "PublishedFile.Subscribe#1";
type Response = CPublishedFile_Subscribe_Response;
}
impl crate::RpcMethod for CPublishedFile_Unsubscribe_Request {
const METHOD_NAME: &'static str = "PublishedFile.Unsubscribe#1";
type Response = CPublishedFile_Unsubscribe_Response;
}
impl crate::RpcMethod for CPublishedFile_UpdateContentDescriptors_Request {
const METHOD_NAME: &'static str = "PublishedFile.UpdateContentDescriptors#1";
type Response = CPublishedFile_UpdateContentDescriptors_Response;
}
impl crate::RpcMethod for CPublishedFile_Update_Request {
const METHOD_NAME: &'static str = "PublishedFile.Update#1";
type Response = CPublishedFile_Update_Response;
}
impl crate::RpcMethod for CPublishedFile_Vote_Request {
const METHOD_NAME: &'static str = "PublishedFile.Vote#1";
type Response = CPublishedFile_Vote_Response;
}