use std::io::Write;
use std::borrow::Cow;
use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, Result};
use quick_protobuf::sizeofs::*;
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct UserPoint {
pub event: u32,
pub paid: u32,
}
impl<'a> MessageRead<'a> for UserPoint {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(16) => msg.event = r.read_uint32(bytes)?,
Ok(24) => msg.paid = r.read_uint32(bytes)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for UserPoint {
fn get_size(&self) -> usize {
0
+ if self.event == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.event) as u64) }
+ if self.paid == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.paid) as u64) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.event != 0u32 { w.write_with_tag(16, |w| w.write_uint32(*&self.event))?; }
if self.paid != 0u32 { w.write_with_tag(24, |w| w.write_uint32(*&self.paid))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Volume<'a> {
pub title_id: u32,
pub thumbnail_image_url: Cow<'a, str>,
pub volume_num: Cow<'a, str>,
pub published_date: Cow<'a, str>,
pub header: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for Volume<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.title_id = r.read_uint32(bytes)?,
Ok(18) => msg.thumbnail_image_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(26) => msg.volume_num = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(34) => msg.published_date = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(42) => msg.header = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Volume<'a> {
fn get_size(&self) -> usize {
0
+ if self.title_id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.title_id) as u64) }
+ if self.thumbnail_image_url == "" { 0 } else { 1 + sizeof_len((&self.thumbnail_image_url).len()) }
+ if self.volume_num == "" { 0 } else { 1 + sizeof_len((&self.volume_num).len()) }
+ if self.published_date == "" { 0 } else { 1 + sizeof_len((&self.published_date).len()) }
+ if self.header == "" { 0 } else { 1 + sizeof_len((&self.header).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.title_id != 0u32 { w.write_with_tag(8, |w| w.write_uint32(*&self.title_id))?; }
if self.thumbnail_image_url != "" { w.write_with_tag(18, |w| w.write_string(&**&self.thumbnail_image_url))?; }
if self.volume_num != "" { w.write_with_tag(26, |w| w.write_string(&**&self.volume_num))?; }
if self.published_date != "" { w.write_with_tag(34, |w| w.write_string(&**&self.published_date))?; }
if self.header != "" { w.write_with_tag(42, |w| w.write_string(&**&self.header))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct VolumeGroup<'a> {
pub published_date: Cow<'a, str>,
pub volumes: Vec<Volume<'a>>,
}
impl<'a> MessageRead<'a> for VolumeGroup<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.published_date = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(18) => msg.volumes.push(r.read_message::<Volume>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for VolumeGroup<'a> {
fn get_size(&self) -> usize {
0
+ if self.published_date == "" { 0 } else { 1 + sizeof_len((&self.published_date).len()) }
+ self.volumes.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.published_date != "" { w.write_with_tag(10, |w| w.write_string(&**&self.published_date))?; }
for s in &self.volumes { w.write_with_tag(18, |w| w.write_message(s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Title<'a> {
pub id: u32,
pub type_pb: mod_Title::Type,
pub title_name: Cow<'a, str>,
pub title_name_kana: Cow<'a, str>,
pub author_name: Cow<'a, str>,
pub single_list_thumbnail_url: Cow<'a, str>,
pub spread_list_thumbnail_url: Cow<'a, str>,
pub short_description: Cow<'a, str>,
pub number_of_bookmarks: u32,
pub badge: mod_Title::Badge,
pub remaining_charge_time: u32,
pub remaining_bonus: u32,
pub category: Vec<Tag<'a>>,
pub charge_time: u32,
pub label: Option<Tag<'a>>,
pub can_comment: bool,
pub is_free_title: bool,
}
impl<'a> MessageRead<'a> for Title<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.id = r.read_uint32(bytes)?,
Ok(16) => msg.type_pb = r.read_enum(bytes)?,
Ok(26) => msg.title_name = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(34) => msg.title_name_kana = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(42) => msg.author_name = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(50) => msg.single_list_thumbnail_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(58) => msg.spread_list_thumbnail_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(66) => msg.short_description = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(72) => msg.number_of_bookmarks = r.read_uint32(bytes)?,
Ok(80) => msg.badge = r.read_enum(bytes)?,
Ok(88) => msg.remaining_charge_time = r.read_uint32(bytes)?,
Ok(96) => msg.remaining_bonus = r.read_uint32(bytes)?,
Ok(106) => msg.category.push(r.read_message::<Tag>(bytes)?),
Ok(112) => msg.charge_time = r.read_uint32(bytes)?,
Ok(122) => msg.label = Some(r.read_message::<Tag>(bytes)?),
Ok(128) => msg.can_comment = r.read_bool(bytes)?,
Ok(136) => msg.is_free_title = r.read_bool(bytes)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Title<'a> {
fn get_size(&self) -> usize {
0
+ if self.id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.id) as u64) }
+ if self.type_pb == reader::mod_Title::Type::MISC { 0 } else { 1 + sizeof_varint(*(&self.type_pb) as u64) }
+ if self.title_name == "" { 0 } else { 1 + sizeof_len((&self.title_name).len()) }
+ if self.title_name_kana == "" { 0 } else { 1 + sizeof_len((&self.title_name_kana).len()) }
+ if self.author_name == "" { 0 } else { 1 + sizeof_len((&self.author_name).len()) }
+ if self.single_list_thumbnail_url == "" { 0 } else { 1 + sizeof_len((&self.single_list_thumbnail_url).len()) }
+ if self.spread_list_thumbnail_url == "" { 0 } else { 1 + sizeof_len((&self.spread_list_thumbnail_url).len()) }
+ if self.short_description == "" { 0 } else { 1 + sizeof_len((&self.short_description).len()) }
+ if self.number_of_bookmarks == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.number_of_bookmarks) as u64) }
+ if self.badge == reader::mod_Title::Badge::NONE { 0 } else { 1 + sizeof_varint(*(&self.badge) as u64) }
+ if self.remaining_charge_time == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.remaining_charge_time) as u64) }
+ if self.remaining_bonus == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.remaining_bonus) as u64) }
+ self.category.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+ if self.charge_time == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.charge_time) as u64) }
+ self.label.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ if self.can_comment == false { 0 } else { 2 + sizeof_varint(*(&self.can_comment) as u64) }
+ if self.is_free_title == false { 0 } else { 2 + sizeof_varint(*(&self.is_free_title) as u64) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.id != 0u32 { w.write_with_tag(8, |w| w.write_uint32(*&self.id))?; }
if self.type_pb != reader::mod_Title::Type::MISC { w.write_with_tag(16, |w| w.write_enum(*&self.type_pb as i32))?; }
if self.title_name != "" { w.write_with_tag(26, |w| w.write_string(&**&self.title_name))?; }
if self.title_name_kana != "" { w.write_with_tag(34, |w| w.write_string(&**&self.title_name_kana))?; }
if self.author_name != "" { w.write_with_tag(42, |w| w.write_string(&**&self.author_name))?; }
if self.single_list_thumbnail_url != "" { w.write_with_tag(50, |w| w.write_string(&**&self.single_list_thumbnail_url))?; }
if self.spread_list_thumbnail_url != "" { w.write_with_tag(58, |w| w.write_string(&**&self.spread_list_thumbnail_url))?; }
if self.short_description != "" { w.write_with_tag(66, |w| w.write_string(&**&self.short_description))?; }
if self.number_of_bookmarks != 0u32 { w.write_with_tag(72, |w| w.write_uint32(*&self.number_of_bookmarks))?; }
if self.badge != reader::mod_Title::Badge::NONE { w.write_with_tag(80, |w| w.write_enum(*&self.badge as i32))?; }
if self.remaining_charge_time != 0u32 { w.write_with_tag(88, |w| w.write_uint32(*&self.remaining_charge_time))?; }
if self.remaining_bonus != 0u32 { w.write_with_tag(96, |w| w.write_uint32(*&self.remaining_bonus))?; }
for s in &self.category { w.write_with_tag(106, |w| w.write_message(s))?; }
if self.charge_time != 0u32 { w.write_with_tag(112, |w| w.write_uint32(*&self.charge_time))?; }
if let Some(ref s) = self.label { w.write_with_tag(122, |w| w.write_message(s))?; }
if self.can_comment != false { w.write_with_tag(128, |w| w.write_bool(*&self.can_comment))?; }
if self.is_free_title != false { w.write_with_tag(136, |w| w.write_bool(*&self.is_free_title))?; }
Ok(())
}
}
pub mod mod_Title {
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum Type {
MISC = 0,
MANGA = 1,
NOVEL = 2,
}
impl Default for Type {
fn default() -> Self {
Type::MISC
}
}
impl From<i32> for Type {
fn from(i: i32) -> Self {
match i {
0 => Type::MISC,
1 => Type::MANGA,
2 => Type::NOVEL,
_ => Self::default(),
}
}
}
impl<'a> From<&'a str> for Type {
fn from(s: &'a str) -> Self {
match s {
"MISC" => Type::MISC,
"MANGA" => Type::MANGA,
"NOVEL" => Type::NOVEL,
_ => Self::default(),
}
}
}
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum Badge {
NONE = 0,
NEW = 1,
UPDATE = 2,
}
impl Default for Badge {
fn default() -> Self {
Badge::NONE
}
}
impl From<i32> for Badge {
fn from(i: i32) -> Self {
match i {
0 => Badge::NONE,
1 => Badge::NEW,
2 => Badge::UPDATE,
_ => Self::default(),
}
}
}
impl<'a> From<&'a str> for Badge {
fn from(s: &'a str) -> Self {
match s {
"NONE" => Badge::NONE,
"NEW" => Badge::NEW,
"UPDATE" => Badge::UPDATE,
_ => Self::default(),
}
}
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct AdNetworkList<'a> {
pub ad_networks: Vec<AdNetwork<'a>>,
}
impl<'a> MessageRead<'a> for AdNetworkList<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.ad_networks.push(r.read_message::<AdNetwork>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for AdNetworkList<'a> {
fn get_size(&self) -> usize {
0
+ self.ad_networks.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
for s in &self.ad_networks { w.write_with_tag(10, |w| w.write_message(s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct AdNetwork<'a> {
pub network: mod_AdNetwork::OneOfnetwork<'a>,
}
impl<'a> MessageRead<'a> for AdNetwork<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(26) => msg.network = mod_AdNetwork::OneOfnetwork::facebook(r.read_message::<mod_AdNetwork::Facebook>(bytes)?),
Ok(34) => msg.network = mod_AdNetwork::OneOfnetwork::five(r.read_message::<mod_AdNetwork::Five>(bytes)?),
Ok(42) => msg.network = mod_AdNetwork::OneOfnetwork::unity(r.read_message::<mod_AdNetwork::Unity>(bytes)?),
Ok(50) => msg.network = mod_AdNetwork::OneOfnetwork::nend(r.read_message::<mod_AdNetwork::Nend>(bytes)?),
Ok(58) => msg.network = mod_AdNetwork::OneOfnetwork::app_lovin(r.read_message::<mod_AdNetwork::AppLovin>(bytes)?),
Ok(66) => msg.network = mod_AdNetwork::OneOfnetwork::maio(r.read_message::<mod_AdNetwork::Maio>(bytes)?),
Ok(74) => msg.network = mod_AdNetwork::OneOfnetwork::zucks(r.read_message::<mod_AdNetwork::Zucks>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for AdNetwork<'a> {
fn get_size(&self) -> usize {
0
+ match self.network {
mod_AdNetwork::OneOfnetwork::facebook(ref m) => 1 + sizeof_len((m).get_size()),
mod_AdNetwork::OneOfnetwork::five(ref m) => 1 + sizeof_len((m).get_size()),
mod_AdNetwork::OneOfnetwork::unity(ref m) => 1 + sizeof_len((m).get_size()),
mod_AdNetwork::OneOfnetwork::nend(ref m) => 1 + sizeof_len((m).get_size()),
mod_AdNetwork::OneOfnetwork::app_lovin(ref m) => 1 + sizeof_len((m).get_size()),
mod_AdNetwork::OneOfnetwork::maio(ref m) => 1 + sizeof_len((m).get_size()),
mod_AdNetwork::OneOfnetwork::zucks(ref m) => 1 + sizeof_len((m).get_size()),
mod_AdNetwork::OneOfnetwork::None => 0,
} }
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
match self.network { mod_AdNetwork::OneOfnetwork::facebook(ref m) => { w.write_with_tag(26, |w| w.write_message(m))? },
mod_AdNetwork::OneOfnetwork::five(ref m) => { w.write_with_tag(34, |w| w.write_message(m))? },
mod_AdNetwork::OneOfnetwork::unity(ref m) => { w.write_with_tag(42, |w| w.write_message(m))? },
mod_AdNetwork::OneOfnetwork::nend(ref m) => { w.write_with_tag(50, |w| w.write_message(m))? },
mod_AdNetwork::OneOfnetwork::app_lovin(ref m) => { w.write_with_tag(58, |w| w.write_message(m))? },
mod_AdNetwork::OneOfnetwork::maio(ref m) => { w.write_with_tag(66, |w| w.write_message(m))? },
mod_AdNetwork::OneOfnetwork::zucks(ref m) => { w.write_with_tag(74, |w| w.write_message(m))? },
mod_AdNetwork::OneOfnetwork::None => {},
} Ok(())
}
}
pub mod mod_AdNetwork {
use std::borrow::Cow;
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Facebook<'a> {
pub placement_id: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for Facebook<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.placement_id = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Facebook<'a> {
fn get_size(&self) -> usize {
0
+ if self.placement_id == "" { 0 } else { 1 + sizeof_len((&self.placement_id).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.placement_id != "" { w.write_with_tag(10, |w| w.write_string(&**&self.placement_id))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Five<'a> {
pub spot_id: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for Five<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.spot_id = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Five<'a> {
fn get_size(&self) -> usize {
0
+ if self.spot_id == "" { 0 } else { 1 + sizeof_len((&self.spot_id).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.spot_id != "" { w.write_with_tag(10, |w| w.write_string(&**&self.spot_id))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Unity<'a> {
pub placement_id: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for Unity<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.placement_id = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Unity<'a> {
fn get_size(&self) -> usize {
0
+ if self.placement_id == "" { 0 } else { 1 + sizeof_len((&self.placement_id).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.placement_id != "" { w.write_with_tag(10, |w| w.write_string(&**&self.placement_id))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Nend<'a> {
pub spot_id: i32,
pub api_key: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for Nend<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.spot_id = r.read_int32(bytes)?,
Ok(18) => msg.api_key = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Nend<'a> {
fn get_size(&self) -> usize {
0
+ if self.spot_id == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.spot_id) as u64) }
+ if self.api_key == "" { 0 } else { 1 + sizeof_len((&self.api_key).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.spot_id != 0i32 { w.write_with_tag(8, |w| w.write_int32(*&self.spot_id))?; }
if self.api_key != "" { w.write_with_tag(18, |w| w.write_string(&**&self.api_key))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct AppLovin { }
impl<'a> MessageRead<'a> for AppLovin {
fn from_reader(r: &mut BytesReader, _: &[u8]) -> Result<Self> {
r.read_to_end();
Ok(Self::default())
}
}
impl MessageWrite for AppLovin { }
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Maio<'a> {
pub zone_id: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for Maio<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(18) => msg.zone_id = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Maio<'a> {
fn get_size(&self) -> usize {
0
+ if self.zone_id == "" { 0 } else { 1 + sizeof_len((&self.zone_id).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.zone_id != "" { w.write_with_tag(18, |w| w.write_string(&**&self.zone_id))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Zucks<'a> {
pub frame_id: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for Zucks<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.frame_id = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Zucks<'a> {
fn get_size(&self) -> usize {
0
+ if self.frame_id == "" { 0 } else { 1 + sizeof_len((&self.frame_id).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.frame_id != "" { w.write_with_tag(10, |w| w.write_string(&**&self.frame_id))?; }
Ok(())
}
}
#[derive(Debug, PartialEq, Clone)]
pub enum OneOfnetwork<'a> {
facebook(mod_AdNetwork::Facebook<'a>),
five(mod_AdNetwork::Five<'a>),
unity(mod_AdNetwork::Unity<'a>),
nend(mod_AdNetwork::Nend<'a>),
app_lovin(mod_AdNetwork::AppLovin),
maio(mod_AdNetwork::Maio<'a>),
zucks(mod_AdNetwork::Zucks<'a>),
None,
}
impl<'a> Default for OneOfnetwork<'a> {
fn default() -> Self {
OneOfnetwork::None
}
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Banner<'a> {
pub id: u32,
pub image_url: Cow<'a, str>,
pub url: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for Banner<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.id = r.read_uint32(bytes)?,
Ok(18) => msg.image_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(26) => msg.url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Banner<'a> {
fn get_size(&self) -> usize {
0
+ if self.id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.id) as u64) }
+ if self.image_url == "" { 0 } else { 1 + sizeof_len((&self.image_url).len()) }
+ if self.url == "" { 0 } else { 1 + sizeof_len((&self.url).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.id != 0u32 { w.write_with_tag(8, |w| w.write_uint32(*&self.id))?; }
if self.image_url != "" { w.write_with_tag(18, |w| w.write_string(&**&self.image_url))?; }
if self.url != "" { w.write_with_tag(26, |w| w.write_string(&**&self.url))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct BillingItem<'a> {
pub id: Cow<'a, str>,
pub item: Option<UserPoint>,
pub label: Cow<'a, str>,
pub price_yen: u32,
}
impl<'a> MessageRead<'a> for BillingItem<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.id = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(18) => msg.item = Some(r.read_message::<UserPoint>(bytes)?),
Ok(26) => msg.label = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(32) => msg.price_yen = r.read_uint32(bytes)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for BillingItem<'a> {
fn get_size(&self) -> usize {
0
+ if self.id == "" { 0 } else { 1 + sizeof_len((&self.id).len()) }
+ self.item.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ if self.label == "" { 0 } else { 1 + sizeof_len((&self.label).len()) }
+ if self.price_yen == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.price_yen) as u64) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.id != "" { w.write_with_tag(10, |w| w.write_string(&**&self.id))?; }
if let Some(ref s) = self.item { w.write_with_tag(18, |w| w.write_message(s))?; }
if self.label != "" { w.write_with_tag(26, |w| w.write_string(&**&self.label))?; }
if self.price_yen != 0u32 { w.write_with_tag(32, |w| w.write_uint32(*&self.price_yen))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Chapter<'a> {
pub id: u32,
pub main_name: Cow<'a, str>,
pub sub_name: Cow<'a, str>,
pub image_url: Cow<'a, str>,
pub point_consumption: Option<PointConsumption>,
pub end_of_rental_period: u32,
pub number_of_comments: u32,
pub publishing_type: mod_Chapter::PublishingType,
pub published_date: Cow<'a, str>,
pub advance_published_date: Cow<'a, str>,
pub badge: mod_Chapter::Badge,
pub already_viewed: bool,
pub first_page_image_url: Cow<'a, str>,
pub number_of_user_likes: u32,
pub title_id: u32,
}
impl<'a> MessageRead<'a> for Chapter<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.id = r.read_uint32(bytes)?,
Ok(18) => msg.main_name = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(26) => msg.sub_name = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(34) => msg.image_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(42) => msg.point_consumption = Some(r.read_message::<PointConsumption>(bytes)?),
Ok(48) => msg.end_of_rental_period = r.read_uint32(bytes)?,
Ok(56) => msg.number_of_comments = r.read_uint32(bytes)?,
Ok(64) => msg.publishing_type = r.read_enum(bytes)?,
Ok(74) => msg.published_date = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(82) => msg.advance_published_date = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(88) => msg.badge = r.read_enum(bytes)?,
Ok(96) => msg.already_viewed = r.read_bool(bytes)?,
Ok(106) => msg.first_page_image_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(112) => msg.number_of_user_likes = r.read_uint32(bytes)?,
Ok(120) => msg.title_id = r.read_uint32(bytes)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Chapter<'a> {
fn get_size(&self) -> usize {
0
+ if self.id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.id) as u64) }
+ if self.main_name == "" { 0 } else { 1 + sizeof_len((&self.main_name).len()) }
+ if self.sub_name == "" { 0 } else { 1 + sizeof_len((&self.sub_name).len()) }
+ if self.image_url == "" { 0 } else { 1 + sizeof_len((&self.image_url).len()) }
+ self.point_consumption.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ if self.end_of_rental_period == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.end_of_rental_period) as u64) }
+ if self.number_of_comments == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.number_of_comments) as u64) }
+ if self.publishing_type == reader::mod_Chapter::PublishingType::REGULAR { 0 } else { 1 + sizeof_varint(*(&self.publishing_type) as u64) }
+ if self.published_date == "" { 0 } else { 1 + sizeof_len((&self.published_date).len()) }
+ if self.advance_published_date == "" { 0 } else { 1 + sizeof_len((&self.advance_published_date).len()) }
+ if self.badge == reader::mod_Chapter::Badge::NONE { 0 } else { 1 + sizeof_varint(*(&self.badge) as u64) }
+ if self.already_viewed == false { 0 } else { 1 + sizeof_varint(*(&self.already_viewed) as u64) }
+ if self.first_page_image_url == "" { 0 } else { 1 + sizeof_len((&self.first_page_image_url).len()) }
+ if self.number_of_user_likes == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.number_of_user_likes) as u64) }
+ if self.title_id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.title_id) as u64) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.id != 0u32 { w.write_with_tag(8, |w| w.write_uint32(*&self.id))?; }
if self.main_name != "" { w.write_with_tag(18, |w| w.write_string(&**&self.main_name))?; }
if self.sub_name != "" { w.write_with_tag(26, |w| w.write_string(&**&self.sub_name))?; }
if self.image_url != "" { w.write_with_tag(34, |w| w.write_string(&**&self.image_url))?; }
if let Some(ref s) = self.point_consumption { w.write_with_tag(42, |w| w.write_message(s))?; }
if self.end_of_rental_period != 0u32 { w.write_with_tag(48, |w| w.write_uint32(*&self.end_of_rental_period))?; }
if self.number_of_comments != 0u32 { w.write_with_tag(56, |w| w.write_uint32(*&self.number_of_comments))?; }
if self.publishing_type != reader::mod_Chapter::PublishingType::REGULAR { w.write_with_tag(64, |w| w.write_enum(*&self.publishing_type as i32))?; }
if self.published_date != "" { w.write_with_tag(74, |w| w.write_string(&**&self.published_date))?; }
if self.advance_published_date != "" { w.write_with_tag(82, |w| w.write_string(&**&self.advance_published_date))?; }
if self.badge != reader::mod_Chapter::Badge::NONE { w.write_with_tag(88, |w| w.write_enum(*&self.badge as i32))?; }
if self.already_viewed != false { w.write_with_tag(96, |w| w.write_bool(*&self.already_viewed))?; }
if self.first_page_image_url != "" { w.write_with_tag(106, |w| w.write_string(&**&self.first_page_image_url))?; }
if self.number_of_user_likes != 0u32 { w.write_with_tag(112, |w| w.write_uint32(*&self.number_of_user_likes))?; }
if self.title_id != 0u32 { w.write_with_tag(120, |w| w.write_uint32(*&self.title_id))?; }
Ok(())
}
}
pub mod mod_Chapter {
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum PublishingType {
REGULAR = 0,
ADVANCE = 1,
FREE = 2,
}
impl Default for PublishingType {
fn default() -> Self {
PublishingType::REGULAR
}
}
impl From<i32> for PublishingType {
fn from(i: i32) -> Self {
match i {
0 => PublishingType::REGULAR,
1 => PublishingType::ADVANCE,
2 => PublishingType::FREE,
_ => Self::default(),
}
}
}
impl<'a> From<&'a str> for PublishingType {
fn from(s: &'a str) -> Self {
match s {
"REGULAR" => PublishingType::REGULAR,
"ADVANCE" => PublishingType::ADVANCE,
"FREE" => PublishingType::FREE,
_ => Self::default(),
}
}
}
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum Badge {
NONE = 0,
UPDATE = 1,
}
impl Default for Badge {
fn default() -> Self {
Badge::NONE
}
}
impl From<i32> for Badge {
fn from(i: i32) -> Self {
match i {
0 => Badge::NONE,
1 => Badge::UPDATE,
_ => Self::default(),
}
}
}
impl<'a> From<&'a str> for Badge {
fn from(s: &'a str) -> Self {
match s {
"NONE" => Badge::NONE,
"UPDATE" => Badge::UPDATE,
_ => Self::default(),
}
}
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct ChapterGroup<'a> {
pub volume: Option<Volume<'a>>,
pub chapters: Vec<Chapter<'a>>,
}
impl<'a> MessageRead<'a> for ChapterGroup<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.volume = Some(r.read_message::<Volume>(bytes)?),
Ok(26) => msg.chapters.push(r.read_message::<Chapter>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for ChapterGroup<'a> {
fn get_size(&self) -> usize {
0
+ self.volume.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.chapters.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.volume { w.write_with_tag(10, |w| w.write_message(s))?; }
for s in &self.chapters { w.write_with_tag(26, |w| w.write_message(s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Comment<'a> {
pub id: u32,
pub index: u32,
pub is_my_comment: bool,
pub already_liked: bool,
pub number_of_likes: u32,
pub body: Cow<'a, str>,
pub created: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for Comment<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.id = r.read_uint32(bytes)?,
Ok(16) => msg.index = r.read_uint32(bytes)?,
Ok(24) => msg.is_my_comment = r.read_bool(bytes)?,
Ok(32) => msg.already_liked = r.read_bool(bytes)?,
Ok(40) => msg.number_of_likes = r.read_uint32(bytes)?,
Ok(50) => msg.body = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(58) => msg.created = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Comment<'a> {
fn get_size(&self) -> usize {
0
+ if self.id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.id) as u64) }
+ if self.index == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.index) as u64) }
+ if self.is_my_comment == false { 0 } else { 1 + sizeof_varint(*(&self.is_my_comment) as u64) }
+ if self.already_liked == false { 0 } else { 1 + sizeof_varint(*(&self.already_liked) as u64) }
+ if self.number_of_likes == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.number_of_likes) as u64) }
+ if self.body == "" { 0 } else { 1 + sizeof_len((&self.body).len()) }
+ if self.created == "" { 0 } else { 1 + sizeof_len((&self.created).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.id != 0u32 { w.write_with_tag(8, |w| w.write_uint32(*&self.id))?; }
if self.index != 0u32 { w.write_with_tag(16, |w| w.write_uint32(*&self.index))?; }
if self.is_my_comment != false { w.write_with_tag(24, |w| w.write_bool(*&self.is_my_comment))?; }
if self.already_liked != false { w.write_with_tag(32, |w| w.write_bool(*&self.already_liked))?; }
if self.number_of_likes != 0u32 { w.write_with_tag(40, |w| w.write_uint32(*&self.number_of_likes))?; }
if self.body != "" { w.write_with_tag(50, |w| w.write_string(&**&self.body))?; }
if self.created != "" { w.write_with_tag(58, |w| w.write_string(&**&self.created))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct MangaPage<'a> {
pub content: mod_MangaPage::OneOfcontent<'a>,
}
impl<'a> MessageRead<'a> for MangaPage<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.content = mod_MangaPage::OneOfcontent::image(r.read_message::<mod_MangaPage::Image>(bytes)?),
Ok(18) => msg.content = mod_MangaPage::OneOfcontent::web_view(r.read_message::<mod_MangaPage::WebView>(bytes)?),
Ok(26) => msg.content = mod_MangaPage::OneOfcontent::advertisement(r.read_message::<AdNetworkList>(bytes)?),
Ok(34) => msg.content = mod_MangaPage::OneOfcontent::last_page(r.read_message::<mod_MangaPage::LastPage>(bytes)?),
Ok(42) => msg.content = mod_MangaPage::OneOfcontent::link_image(r.read_message::<mod_MangaPage::LinkImage>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for MangaPage<'a> {
fn get_size(&self) -> usize {
0
+ match self.content {
mod_MangaPage::OneOfcontent::image(ref m) => 1 + sizeof_len((m).get_size()),
mod_MangaPage::OneOfcontent::web_view(ref m) => 1 + sizeof_len((m).get_size()),
mod_MangaPage::OneOfcontent::advertisement(ref m) => 1 + sizeof_len((m).get_size()),
mod_MangaPage::OneOfcontent::last_page(ref m) => 1 + sizeof_len((m).get_size()),
mod_MangaPage::OneOfcontent::link_image(ref m) => 1 + sizeof_len((m).get_size()),
mod_MangaPage::OneOfcontent::None => 0,
} }
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
match self.content { mod_MangaPage::OneOfcontent::image(ref m) => { w.write_with_tag(10, |w| w.write_message(m))? },
mod_MangaPage::OneOfcontent::web_view(ref m) => { w.write_with_tag(18, |w| w.write_message(m))? },
mod_MangaPage::OneOfcontent::advertisement(ref m) => { w.write_with_tag(26, |w| w.write_message(m))? },
mod_MangaPage::OneOfcontent::last_page(ref m) => { w.write_with_tag(34, |w| w.write_message(m))? },
mod_MangaPage::OneOfcontent::link_image(ref m) => { w.write_with_tag(42, |w| w.write_message(m))? },
mod_MangaPage::OneOfcontent::None => {},
} Ok(())
}
}
pub mod mod_MangaPage {
use std::borrow::Cow;
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Image<'a> {
pub image_url: Cow<'a, str>,
pub height: u32,
pub width: u32,
}
impl<'a> MessageRead<'a> for Image<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.image_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(24) => msg.height = r.read_uint32(bytes)?,
Ok(32) => msg.width = r.read_uint32(bytes)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Image<'a> {
fn get_size(&self) -> usize {
0
+ if self.image_url == "" { 0 } else { 1 + sizeof_len((&self.image_url).len()) }
+ if self.height == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.height) as u64) }
+ if self.width == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.width) as u64) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.image_url != "" { w.write_with_tag(10, |w| w.write_string(&**&self.image_url))?; }
if self.height != 0u32 { w.write_with_tag(24, |w| w.write_uint32(*&self.height))?; }
if self.width != 0u32 { w.write_with_tag(32, |w| w.write_uint32(*&self.width))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct WebView<'a> {
pub url: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for WebView<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for WebView<'a> {
fn get_size(&self) -> usize {
0
+ if self.url == "" { 0 } else { 1 + sizeof_len((&self.url).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.url != "" { w.write_with_tag(10, |w| w.write_string(&**&self.url))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct LastPage<'a> {
pub current_chapter: Option<Chapter<'a>>,
pub next_chapter: Option<Chapter<'a>>,
pub advertisement: Option<AdNetworkList<'a>>,
pub sns: Option<Sns<'a>>,
pub is_bookmarked: bool,
pub is_liked: bool,
pub recommended_titles: Vec<Title<'a>>,
pub questionnaire_url: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for LastPage<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.current_chapter = Some(r.read_message::<Chapter>(bytes)?),
Ok(18) => msg.next_chapter = Some(r.read_message::<Chapter>(bytes)?),
Ok(26) => msg.advertisement = Some(r.read_message::<AdNetworkList>(bytes)?),
Ok(34) => msg.sns = Some(r.read_message::<Sns>(bytes)?),
Ok(40) => msg.is_bookmarked = r.read_bool(bytes)?,
Ok(48) => msg.is_liked = r.read_bool(bytes)?,
Ok(58) => msg.recommended_titles.push(r.read_message::<Title>(bytes)?),
Ok(66) => msg.questionnaire_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for LastPage<'a> {
fn get_size(&self) -> usize {
0
+ self.current_chapter.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.next_chapter.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.advertisement.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.sns.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ if self.is_bookmarked == false { 0 } else { 1 + sizeof_varint(*(&self.is_bookmarked) as u64) }
+ if self.is_liked == false { 0 } else { 1 + sizeof_varint(*(&self.is_liked) as u64) }
+ self.recommended_titles.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+ if self.questionnaire_url == "" { 0 } else { 1 + sizeof_len((&self.questionnaire_url).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.current_chapter { w.write_with_tag(10, |w| w.write_message(s))?; }
if let Some(ref s) = self.next_chapter { w.write_with_tag(18, |w| w.write_message(s))?; }
if let Some(ref s) = self.advertisement { w.write_with_tag(26, |w| w.write_message(s))?; }
if let Some(ref s) = self.sns { w.write_with_tag(34, |w| w.write_message(s))?; }
if self.is_bookmarked != false { w.write_with_tag(40, |w| w.write_bool(*&self.is_bookmarked))?; }
if self.is_liked != false { w.write_with_tag(48, |w| w.write_bool(*&self.is_liked))?; }
for s in &self.recommended_titles { w.write_with_tag(58, |w| w.write_message(s))?; }
if self.questionnaire_url != "" { w.write_with_tag(66, |w| w.write_string(&**&self.questionnaire_url))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct LinkImage<'a> {
pub image_url: Cow<'a, str>,
pub url: Cow<'a, str>,
pub height: u32,
pub width: u32,
}
impl<'a> MessageRead<'a> for LinkImage<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.image_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(18) => msg.url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(24) => msg.height = r.read_uint32(bytes)?,
Ok(32) => msg.width = r.read_uint32(bytes)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for LinkImage<'a> {
fn get_size(&self) -> usize {
0
+ if self.image_url == "" { 0 } else { 1 + sizeof_len((&self.image_url).len()) }
+ if self.url == "" { 0 } else { 1 + sizeof_len((&self.url).len()) }
+ if self.height == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.height) as u64) }
+ if self.width == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.width) as u64) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.image_url != "" { w.write_with_tag(10, |w| w.write_string(&**&self.image_url))?; }
if self.url != "" { w.write_with_tag(18, |w| w.write_string(&**&self.url))?; }
if self.height != 0u32 { w.write_with_tag(24, |w| w.write_uint32(*&self.height))?; }
if self.width != 0u32 { w.write_with_tag(32, |w| w.write_uint32(*&self.width))?; }
Ok(())
}
}
#[derive(Debug, PartialEq, Clone)]
pub enum OneOfcontent<'a> {
image(mod_MangaPage::Image<'a>),
web_view(mod_MangaPage::WebView<'a>),
advertisement(AdNetworkList<'a>),
last_page(mod_MangaPage::LastPage<'a>),
link_image(mod_MangaPage::LinkImage<'a>),
None,
}
impl<'a> Default for OneOfcontent<'a> {
fn default() -> Self {
OneOfcontent::None
}
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct PointConsumption {
pub type_pb: mod_PointConsumption::Type,
pub amount: u32,
pub ad_enabled: bool,
}
impl<'a> MessageRead<'a> for PointConsumption {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.type_pb = r.read_enum(bytes)?,
Ok(16) => msg.amount = r.read_uint32(bytes)?,
Ok(24) => msg.ad_enabled = r.read_bool(bytes)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for PointConsumption {
fn get_size(&self) -> usize {
0
+ if self.type_pb == reader::mod_PointConsumption::Type::NONE { 0 } else { 1 + sizeof_varint(*(&self.type_pb) as u64) }
+ if self.amount == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.amount) as u64) }
+ if self.ad_enabled == false { 0 } else { 1 + sizeof_varint(*(&self.ad_enabled) as u64) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.type_pb != reader::mod_PointConsumption::Type::NONE { w.write_with_tag(8, |w| w.write_enum(*&self.type_pb as i32))?; }
if self.amount != 0u32 { w.write_with_tag(16, |w| w.write_uint32(*&self.amount))?; }
if self.ad_enabled != false { w.write_with_tag(24, |w| w.write_bool(*&self.ad_enabled))?; }
Ok(())
}
}
pub mod mod_PointConsumption {
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum Type {
NONE = 0,
ANY_ITEMS = 1,
EVENT_OR_PAID = 2,
PAID_ONLY = 3,
}
impl Default for Type {
fn default() -> Self {
Type::NONE
}
}
impl From<i32> for Type {
fn from(i: i32) -> Self {
match i {
0 => Type::NONE,
1 => Type::ANY_ITEMS,
2 => Type::EVENT_OR_PAID,
3 => Type::PAID_ONLY,
_ => Self::default(),
}
}
}
impl<'a> From<&'a str> for Type {
fn from(s: &'a str) -> Self {
match s {
"NONE" => Type::NONE,
"ANY_ITEMS" => Type::ANY_ITEMS,
"EVENT_OR_PAID" => Type::EVENT_OR_PAID,
"PAID_ONLY" => Type::PAID_ONLY,
_ => Self::default(),
}
}
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct PointHistory<'a> {
pub detail: Cow<'a, str>,
pub item: Option<UserPoint>,
pub created: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for PointHistory<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.detail = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(18) => msg.item = Some(r.read_message::<UserPoint>(bytes)?),
Ok(26) => msg.created = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for PointHistory<'a> {
fn get_size(&self) -> usize {
0
+ if self.detail == "" { 0 } else { 1 + sizeof_len((&self.detail).len()) }
+ self.item.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ if self.created == "" { 0 } else { 1 + sizeof_len((&self.created).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.detail != "" { w.write_with_tag(10, |w| w.write_string(&**&self.detail))?; }
if let Some(ref s) = self.item { w.write_with_tag(18, |w| w.write_message(s))?; }
if self.created != "" { w.write_with_tag(26, |w| w.write_string(&**&self.created))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Popup<'a> {
pub os_default: Option<mod_Popup::OSDefaultPopup<'a>>,
pub app_default: Option<mod_Popup::AppDefaultPopup<'a>>,
pub move_reward: Option<mod_Popup::MovieRewardPopup<'a>>,
}
impl<'a> MessageRead<'a> for Popup<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.os_default = Some(r.read_message::<mod_Popup::OSDefaultPopup>(bytes)?),
Ok(18) => msg.app_default = Some(r.read_message::<mod_Popup::AppDefaultPopup>(bytes)?),
Ok(26) => msg.move_reward = Some(r.read_message::<mod_Popup::MovieRewardPopup>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Popup<'a> {
fn get_size(&self) -> usize {
0
+ self.os_default.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.app_default.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.move_reward.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.os_default { w.write_with_tag(10, |w| w.write_message(s))?; }
if let Some(ref s) = self.app_default { w.write_with_tag(18, |w| w.write_message(s))?; }
if let Some(ref s) = self.move_reward { w.write_with_tag(26, |w| w.write_message(s))?; }
Ok(())
}
}
pub mod mod_Popup {
use std::borrow::Cow;
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Button<'a> {
pub text: Cow<'a, str>,
pub url: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for Button<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.text = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(18) => msg.url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Button<'a> {
fn get_size(&self) -> usize {
0
+ if self.text == "" { 0 } else { 1 + sizeof_len((&self.text).len()) }
+ if self.url == "" { 0 } else { 1 + sizeof_len((&self.url).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.text != "" { w.write_with_tag(10, |w| w.write_string(&**&self.text))?; }
if self.url != "" { w.write_with_tag(18, |w| w.write_string(&**&self.url))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Information {
pub popup_id: u32,
pub title_id: u32,
pub chapter_id: u32,
}
impl<'a> MessageRead<'a> for Information {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.popup_id = r.read_uint32(bytes)?,
Ok(16) => msg.title_id = r.read_uint32(bytes)?,
Ok(24) => msg.chapter_id = r.read_uint32(bytes)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for Information {
fn get_size(&self) -> usize {
0
+ if self.popup_id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.popup_id) as u64) }
+ if self.title_id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.title_id) as u64) }
+ if self.chapter_id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.chapter_id) as u64) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.popup_id != 0u32 { w.write_with_tag(8, |w| w.write_uint32(*&self.popup_id))?; }
if self.title_id != 0u32 { w.write_with_tag(16, |w| w.write_uint32(*&self.title_id))?; }
if self.chapter_id != 0u32 { w.write_with_tag(24, |w| w.write_uint32(*&self.chapter_id))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct OSDefaultPopup<'a> {
pub subject: Cow<'a, str>,
pub body: Cow<'a, str>,
pub ok_button: Option<mod_Popup::Button<'a>>,
pub neutral_button: Option<mod_Popup::Button<'a>>,
pub cancel_button: Option<mod_Popup::Button<'a>>,
pub popup_info: Option<mod_Popup::Information>,
}
impl<'a> MessageRead<'a> for OSDefaultPopup<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.subject = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(18) => msg.body = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(26) => msg.ok_button = Some(r.read_message::<mod_Popup::Button>(bytes)?),
Ok(34) => msg.neutral_button = Some(r.read_message::<mod_Popup::Button>(bytes)?),
Ok(42) => msg.cancel_button = Some(r.read_message::<mod_Popup::Button>(bytes)?),
Ok(50) => msg.popup_info = Some(r.read_message::<mod_Popup::Information>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for OSDefaultPopup<'a> {
fn get_size(&self) -> usize {
0
+ if self.subject == "" { 0 } else { 1 + sizeof_len((&self.subject).len()) }
+ if self.body == "" { 0 } else { 1 + sizeof_len((&self.body).len()) }
+ self.ok_button.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.neutral_button.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.cancel_button.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.popup_info.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.subject != "" { w.write_with_tag(10, |w| w.write_string(&**&self.subject))?; }
if self.body != "" { w.write_with_tag(18, |w| w.write_string(&**&self.body))?; }
if let Some(ref s) = self.ok_button { w.write_with_tag(26, |w| w.write_message(s))?; }
if let Some(ref s) = self.neutral_button { w.write_with_tag(34, |w| w.write_message(s))?; }
if let Some(ref s) = self.cancel_button { w.write_with_tag(42, |w| w.write_message(s))?; }
if let Some(ref s) = self.popup_info { w.write_with_tag(50, |w| w.write_message(s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct AppDefaultPopup<'a> {
pub subject: Cow<'a, str>,
pub body: Cow<'a, str>,
pub image_url: Cow<'a, str>,
pub ok_button: Option<mod_Popup::Button<'a>>,
pub cancel_button: Option<mod_Popup::Button<'a>>,
pub popup_info: Option<mod_Popup::Information>,
}
impl<'a> MessageRead<'a> for AppDefaultPopup<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.subject = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(18) => msg.body = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(26) => msg.image_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(34) => msg.ok_button = Some(r.read_message::<mod_Popup::Button>(bytes)?),
Ok(42) => msg.cancel_button = Some(r.read_message::<mod_Popup::Button>(bytes)?),
Ok(50) => msg.popup_info = Some(r.read_message::<mod_Popup::Information>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for AppDefaultPopup<'a> {
fn get_size(&self) -> usize {
0
+ if self.subject == "" { 0 } else { 1 + sizeof_len((&self.subject).len()) }
+ if self.body == "" { 0 } else { 1 + sizeof_len((&self.body).len()) }
+ if self.image_url == "" { 0 } else { 1 + sizeof_len((&self.image_url).len()) }
+ self.ok_button.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.cancel_button.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.popup_info.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.subject != "" { w.write_with_tag(10, |w| w.write_string(&**&self.subject))?; }
if self.body != "" { w.write_with_tag(18, |w| w.write_string(&**&self.body))?; }
if self.image_url != "" { w.write_with_tag(26, |w| w.write_string(&**&self.image_url))?; }
if let Some(ref s) = self.ok_button { w.write_with_tag(34, |w| w.write_message(s))?; }
if let Some(ref s) = self.cancel_button { w.write_with_tag(42, |w| w.write_message(s))?; }
if let Some(ref s) = self.popup_info { w.write_with_tag(50, |w| w.write_message(s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct MovieRewardPopup<'a> {
pub subject: Cow<'a, str>,
pub body: Cow<'a, str>,
pub image_url: Cow<'a, str>,
pub ad_networks: Option<AdNetworkList<'a>>,
pub ok_button: Option<mod_Popup::Button<'a>>,
pub cancel_button: Option<mod_Popup::Button<'a>>,
pub popup_info: Option<mod_Popup::Information>,
}
impl<'a> MessageRead<'a> for MovieRewardPopup<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.subject = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(18) => msg.body = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(26) => msg.image_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(34) => msg.ad_networks = Some(r.read_message::<AdNetworkList>(bytes)?),
Ok(42) => msg.ok_button = Some(r.read_message::<mod_Popup::Button>(bytes)?),
Ok(50) => msg.cancel_button = Some(r.read_message::<mod_Popup::Button>(bytes)?),
Ok(58) => msg.popup_info = Some(r.read_message::<mod_Popup::Information>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for MovieRewardPopup<'a> {
fn get_size(&self) -> usize {
0
+ if self.subject == "" { 0 } else { 1 + sizeof_len((&self.subject).len()) }
+ if self.body == "" { 0 } else { 1 + sizeof_len((&self.body).len()) }
+ if self.image_url == "" { 0 } else { 1 + sizeof_len((&self.image_url).len()) }
+ self.ad_networks.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.ok_button.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.cancel_button.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.popup_info.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.subject != "" { w.write_with_tag(10, |w| w.write_string(&**&self.subject))?; }
if self.body != "" { w.write_with_tag(18, |w| w.write_string(&**&self.body))?; }
if self.image_url != "" { w.write_with_tag(26, |w| w.write_string(&**&self.image_url))?; }
if let Some(ref s) = self.ad_networks { w.write_with_tag(34, |w| w.write_message(s))?; }
if let Some(ref s) = self.ok_button { w.write_with_tag(42, |w| w.write_message(s))?; }
if let Some(ref s) = self.cancel_button { w.write_with_tag(50, |w| w.write_message(s))?; }
if let Some(ref s) = self.popup_info { w.write_with_tag(58, |w| w.write_message(s))?; }
Ok(())
}
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Profile {
pub sex: mod_Profile::Sex,
pub year: i32,
pub month: i32,
}
impl<'a> MessageRead<'a> for Profile {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.sex = r.read_enum(bytes)?,
Ok(16) => msg.year = r.read_int32(bytes)?,
Ok(24) => msg.month = r.read_int32(bytes)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for Profile {
fn get_size(&self) -> usize {
0
+ if self.sex == reader::mod_Profile::Sex::OTHER { 0 } else { 1 + sizeof_varint(*(&self.sex) as u64) }
+ if self.year == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.year) as u64) }
+ if self.month == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.month) as u64) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.sex != reader::mod_Profile::Sex::OTHER { w.write_with_tag(8, |w| w.write_enum(*&self.sex as i32))?; }
if self.year != 0i32 { w.write_with_tag(16, |w| w.write_int32(*&self.year))?; }
if self.month != 0i32 { w.write_with_tag(24, |w| w.write_int32(*&self.month))?; }
Ok(())
}
}
pub mod mod_Profile {
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum Sex {
OTHER = 0,
MALE = 1,
FEMALE = 2,
}
impl Default for Sex {
fn default() -> Self {
Sex::OTHER
}
}
impl From<i32> for Sex {
fn from(i: i32) -> Self {
match i {
0 => Sex::OTHER,
1 => Sex::MALE,
2 => Sex::FEMALE,
_ => Self::default(),
}
}
}
impl<'a> From<&'a str> for Sex {
fn from(s: &'a str) -> Self {
match s {
"OTHER" => Sex::OTHER,
"MALE" => Sex::MALE,
"FEMALE" => Sex::FEMALE,
_ => Self::default(),
}
}
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Ranking<'a> {
pub type_pb: mod_Ranking::Type,
pub titles: Vec<Title<'a>>,
}
impl<'a> MessageRead<'a> for Ranking<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.type_pb = r.read_enum(bytes)?,
Ok(18) => msg.titles.push(r.read_message::<Title>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Ranking<'a> {
fn get_size(&self) -> usize {
0
+ if self.type_pb == reader::mod_Ranking::Type::UNKNOWN { 0 } else { 1 + sizeof_varint(*(&self.type_pb) as u64) }
+ self.titles.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.type_pb != reader::mod_Ranking::Type::UNKNOWN { w.write_with_tag(8, |w| w.write_enum(*&self.type_pb as i32))?; }
for s in &self.titles { w.write_with_tag(18, |w| w.write_message(s))?; }
Ok(())
}
}
pub mod mod_Ranking {
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum Type {
UNKNOWN = 0,
TREND = 1,
POPULAR = 2,
MALE = 3,
FEMALE = 4,
}
impl Default for Type {
fn default() -> Self {
Type::UNKNOWN
}
}
impl From<i32> for Type {
fn from(i: i32) -> Self {
match i {
0 => Type::UNKNOWN,
1 => Type::TREND,
2 => Type::POPULAR,
3 => Type::MALE,
4 => Type::FEMALE,
_ => Self::default(),
}
}
}
impl<'a> From<&'a str> for Type {
fn from(s: &'a str) -> Self {
match s {
"UNKNOWN" => Type::UNKNOWN,
"TREND" => Type::TREND,
"POPULAR" => Type::POPULAR,
"MALE" => Type::MALE,
"FEMALE" => Type::FEMALE,
_ => Self::default(),
}
}
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Sns<'a> {
pub body: Cow<'a, str>,
pub url: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for Sns<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.body = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(18) => msg.url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Sns<'a> {
fn get_size(&self) -> usize {
0
+ if self.body == "" { 0 } else { 1 + sizeof_len((&self.body).len()) }
+ if self.url == "" { 0 } else { 1 + sizeof_len((&self.url).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.body != "" { w.write_with_tag(10, |w| w.write_string(&**&self.body))?; }
if self.url != "" { w.write_with_tag(18, |w| w.write_string(&**&self.url))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Tag<'a> {
pub id: u32,
pub name: Cow<'a, str>,
pub image_url: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for Tag<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.id = r.read_uint32(bytes)?,
Ok(18) => msg.name = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(26) => msg.image_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Tag<'a> {
fn get_size(&self) -> usize {
0
+ if self.id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.id) as u64) }
+ if self.name == "" { 0 } else { 1 + sizeof_len((&self.name).len()) }
+ if self.image_url == "" { 0 } else { 1 + sizeof_len((&self.image_url).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.id != 0u32 { w.write_with_tag(8, |w| w.write_uint32(*&self.id))?; }
if self.name != "" { w.write_with_tag(18, |w| w.write_string(&**&self.name))?; }
if self.image_url != "" { w.write_with_tag(26, |w| w.write_string(&**&self.image_url))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct TitleGroup<'a> {
pub id: u32,
pub name: Cow<'a, str>,
pub titles: Vec<Title<'a>>,
}
impl<'a> MessageRead<'a> for TitleGroup<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.id = r.read_uint32(bytes)?,
Ok(18) => msg.name = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(26) => msg.titles.push(r.read_message::<Title>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for TitleGroup<'a> {
fn get_size(&self) -> usize {
0
+ if self.id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.id) as u64) }
+ if self.name == "" { 0 } else { 1 + sizeof_len((&self.name).len()) }
+ self.titles.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.id != 0u32 { w.write_with_tag(8, |w| w.write_uint32(*&self.id))?; }
if self.name != "" { w.write_with_tag(18, |w| w.write_string(&**&self.name))?; }
for s in &self.titles { w.write_with_tag(26, |w| w.write_message(s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct AllChaptersListView<'a> {
pub title: Option<Title<'a>>,
pub chapters: Vec<ChapterGroup<'a>>,
}
impl<'a> MessageRead<'a> for AllChaptersListView<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.title = Some(r.read_message::<Title>(bytes)?),
Ok(18) => msg.chapters.push(r.read_message::<ChapterGroup>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for AllChaptersListView<'a> {
fn get_size(&self) -> usize {
0
+ self.title.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.chapters.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.title { w.write_with_tag(10, |w| w.write_message(s))?; }
for s in &self.chapters { w.write_with_tag(18, |w| w.write_message(s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct BackgroundDownloadView<'a> {
pub image_urls: Vec<Cow<'a, str>>,
}
impl<'a> MessageRead<'a> for BackgroundDownloadView<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.image_urls.push(r.read_string(bytes).map(Cow::Borrowed)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for BackgroundDownloadView<'a> {
fn get_size(&self) -> usize {
0
+ self.image_urls.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
for s in &self.image_urls { w.write_with_tag(10, |w| w.write_string(&**s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct BillingItemListView<'a> {
pub billing_items: Vec<BillingItem<'a>>,
pub reward_url: Cow<'a, str>,
pub movie_ad: Option<AdNetworkList<'a>>,
pub registered: bool,
}
impl<'a> MessageRead<'a> for BillingItemListView<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.billing_items.push(r.read_message::<BillingItem>(bytes)?),
Ok(18) => msg.reward_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(26) => msg.movie_ad = Some(r.read_message::<AdNetworkList>(bytes)?),
Ok(32) => msg.registered = r.read_bool(bytes)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for BillingItemListView<'a> {
fn get_size(&self) -> usize {
0
+ self.billing_items.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+ if self.reward_url == "" { 0 } else { 1 + sizeof_len((&self.reward_url).len()) }
+ self.movie_ad.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ if self.registered == false { 0 } else { 1 + sizeof_varint(*(&self.registered) as u64) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
for s in &self.billing_items { w.write_with_tag(10, |w| w.write_message(s))?; }
if self.reward_url != "" { w.write_with_tag(18, |w| w.write_string(&**&self.reward_url))?; }
if let Some(ref s) = self.movie_ad { w.write_with_tag(26, |w| w.write_message(s))?; }
if self.registered != false { w.write_with_tag(32, |w| w.write_bool(*&self.registered))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct BridgeTransIdView {
pub bridge_trans_id: u32,
}
impl<'a> MessageRead<'a> for BridgeTransIdView {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.bridge_trans_id = r.read_uint32(bytes)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for BridgeTransIdView {
fn get_size(&self) -> usize {
0
+ if self.bridge_trans_id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.bridge_trans_id) as u64) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.bridge_trans_id != 0u32 { w.write_with_tag(8, |w| w.write_uint32(*&self.bridge_trans_id))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct CommentListView<'a> {
pub comments: Vec<Comment<'a>>,
pub can_post: bool,
}
impl<'a> MessageRead<'a> for CommentListView<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.comments.push(r.read_message::<Comment>(bytes)?),
Ok(24) => msg.can_post = r.read_bool(bytes)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for CommentListView<'a> {
fn get_size(&self) -> usize {
0
+ self.comments.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+ if self.can_post == false { 0 } else { 1 + sizeof_varint(*(&self.can_post) as u64) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
for s in &self.comments { w.write_with_tag(10, |w| w.write_message(s))?; }
if self.can_post != false { w.write_with_tag(24, |w| w.write_bool(*&self.can_post))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct CommentPostView {
pub status: mod_CommentPostView::Status,
}
impl<'a> MessageRead<'a> for CommentPostView {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.status = r.read_enum(bytes)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for CommentPostView {
fn get_size(&self) -> usize {
0
+ if self.status == reader::mod_CommentPostView::Status::SUCCESS { 0 } else { 1 + sizeof_varint(*(&self.status) as u64) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.status != reader::mod_CommentPostView::Status::SUCCESS { w.write_with_tag(8, |w| w.write_enum(*&self.status as i32))?; }
Ok(())
}
}
pub mod mod_CommentPostView {
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum Status {
SUCCESS = 0,
RATE_LIMIT = 1,
CHARACTERS_LIMIT = 2,
NG_WORD = 3,
VOID_BODY = 4,
}
impl Default for Status {
fn default() -> Self {
Status::SUCCESS
}
}
impl From<i32> for Status {
fn from(i: i32) -> Self {
match i {
0 => Status::SUCCESS,
1 => Status::RATE_LIMIT,
2 => Status::CHARACTERS_LIMIT,
3 => Status::NG_WORD,
4 => Status::VOID_BODY,
_ => Self::default(),
}
}
}
impl<'a> From<&'a str> for Status {
fn from(s: &'a str) -> Self {
match s {
"SUCCESS" => Status::SUCCESS,
"RATE_LIMIT" => Status::RATE_LIMIT,
"CHARACTERS_LIMIT" => Status::CHARACTERS_LIMIT,
"NG_WORD" => Status::NG_WORD,
"VOID_BODY" => Status::VOID_BODY,
_ => Self::default(),
}
}
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct DeviceView<'a> {
pub user_secret: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for DeviceView<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.user_secret = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for DeviceView<'a> {
fn get_size(&self) -> usize {
0
+ if self.user_secret == "" { 0 } else { 1 + sizeof_len((&self.user_secret).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.user_secret != "" { w.write_with_tag(10, |w| w.write_string(&**&self.user_secret))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct FeaturedTitleListView<'a> {
pub image_url: Cow<'a, str>,
pub name: Cow<'a, str>,
pub description: Cow<'a, str>,
pub titles: Vec<Title<'a>>,
pub tag_id: u32,
}
impl<'a> MessageRead<'a> for FeaturedTitleListView<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.image_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(18) => msg.name = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(26) => msg.description = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(34) => msg.titles.push(r.read_message::<Title>(bytes)?),
Ok(40) => msg.tag_id = r.read_uint32(bytes)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for FeaturedTitleListView<'a> {
fn get_size(&self) -> usize {
0
+ if self.image_url == "" { 0 } else { 1 + sizeof_len((&self.image_url).len()) }
+ if self.name == "" { 0 } else { 1 + sizeof_len((&self.name).len()) }
+ if self.description == "" { 0 } else { 1 + sizeof_len((&self.description).len()) }
+ self.titles.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+ if self.tag_id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.tag_id) as u64) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.image_url != "" { w.write_with_tag(10, |w| w.write_string(&**&self.image_url))?; }
if self.name != "" { w.write_with_tag(18, |w| w.write_string(&**&self.name))?; }
if self.description != "" { w.write_with_tag(26, |w| w.write_string(&**&self.description))?; }
for s in &self.titles { w.write_with_tag(34, |w| w.write_message(s))?; }
if self.tag_id != 0u32 { w.write_with_tag(40, |w| w.write_uint32(*&self.tag_id))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct HomeView<'a> {
pub top_banners: Vec<Banner<'a>>,
pub sub_banners: Vec<Banner<'a>>,
pub updated_titles: Vec<Title<'a>>,
pub featured_titles: Option<TitleGroup<'a>>,
pub rankings: Vec<Ranking<'a>>,
pub newly_published_volumes: Option<VolumeGroup<'a>>,
pub popup: Option<Popup<'a>>,
}
impl<'a> MessageRead<'a> for HomeView<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.top_banners.push(r.read_message::<Banner>(bytes)?),
Ok(18) => msg.sub_banners.push(r.read_message::<Banner>(bytes)?),
Ok(26) => msg.updated_titles.push(r.read_message::<Title>(bytes)?),
Ok(34) => msg.featured_titles = Some(r.read_message::<TitleGroup>(bytes)?),
Ok(42) => msg.rankings.push(r.read_message::<Ranking>(bytes)?),
Ok(58) => msg.newly_published_volumes = Some(r.read_message::<VolumeGroup>(bytes)?),
Ok(66) => msg.popup = Some(r.read_message::<Popup>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for HomeView<'a> {
fn get_size(&self) -> usize {
0
+ self.top_banners.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+ self.sub_banners.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+ self.updated_titles.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+ self.featured_titles.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.rankings.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+ self.newly_published_volumes.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.popup.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
for s in &self.top_banners { w.write_with_tag(10, |w| w.write_message(s))?; }
for s in &self.sub_banners { w.write_with_tag(18, |w| w.write_message(s))?; }
for s in &self.updated_titles { w.write_with_tag(26, |w| w.write_message(s))?; }
if let Some(ref s) = self.featured_titles { w.write_with_tag(34, |w| w.write_message(s))?; }
for s in &self.rankings { w.write_with_tag(42, |w| w.write_message(s))?; }
if let Some(ref s) = self.newly_published_volumes { w.write_with_tag(58, |w| w.write_message(s))?; }
if let Some(ref s) = self.popup { w.write_with_tag(66, |w| w.write_message(s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct MangaViewerView<'a> {
pub pages: Vec<MangaPage<'a>>,
pub title: Option<Title<'a>>,
}
impl<'a> MessageRead<'a> for MangaViewerView<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.pages.push(r.read_message::<MangaPage>(bytes)?),
Ok(18) => msg.title = Some(r.read_message::<Title>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for MangaViewerView<'a> {
fn get_size(&self) -> usize {
0
+ self.pages.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+ self.title.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
for s in &self.pages { w.write_with_tag(10, |w| w.write_message(s))?; }
if let Some(ref s) = self.title { w.write_with_tag(18, |w| w.write_message(s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct MyPageView<'a> {
pub tag_name: Cow<'a, str>,
pub keyword: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for MyPageView<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.tag_name = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(18) => msg.keyword = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for MyPageView<'a> {
fn get_size(&self) -> usize {
0
+ if self.tag_name == "" { 0 } else { 1 + sizeof_len((&self.tag_name).len()) }
+ if self.keyword == "" { 0 } else { 1 + sizeof_len((&self.keyword).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.tag_name != "" { w.write_with_tag(10, |w| w.write_string(&**&self.tag_name))?; }
if self.keyword != "" { w.write_with_tag(18, |w| w.write_string(&**&self.keyword))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct NovelViewerView<'a> {
pub url: Cow<'a, str>,
pub current_chapter: Option<Chapter<'a>>,
pub next_chapter: Option<Chapter<'a>>,
pub sns: Option<Sns<'a>>,
pub title: Option<Title<'a>>,
}
impl<'a> MessageRead<'a> for NovelViewerView<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(18) => msg.current_chapter = Some(r.read_message::<Chapter>(bytes)?),
Ok(34) => msg.next_chapter = Some(r.read_message::<Chapter>(bytes)?),
Ok(42) => msg.sns = Some(r.read_message::<Sns>(bytes)?),
Ok(50) => msg.title = Some(r.read_message::<Title>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for NovelViewerView<'a> {
fn get_size(&self) -> usize {
0
+ if self.url == "" { 0 } else { 1 + sizeof_len((&self.url).len()) }
+ self.current_chapter.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.next_chapter.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.sns.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.title.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.url != "" { w.write_with_tag(10, |w| w.write_string(&**&self.url))?; }
if let Some(ref s) = self.current_chapter { w.write_with_tag(18, |w| w.write_message(s))?; }
if let Some(ref s) = self.next_chapter { w.write_with_tag(34, |w| w.write_message(s))?; }
if let Some(ref s) = self.sns { w.write_with_tag(42, |w| w.write_message(s))?; }
if let Some(ref s) = self.title { w.write_with_tag(50, |w| w.write_message(s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct PointHistoryView<'a> {
pub logs: Vec<PointHistory<'a>>,
}
impl<'a> MessageRead<'a> for PointHistoryView<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.logs.push(r.read_message::<PointHistory>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for PointHistoryView<'a> {
fn get_size(&self) -> usize {
0
+ self.logs.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
for s in &self.logs { w.write_with_tag(10, |w| w.write_message(s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct ProfileView {
pub profile: Option<Profile>,
}
impl<'a> MessageRead<'a> for ProfileView {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.profile = Some(r.read_message::<Profile>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for ProfileView {
fn get_size(&self) -> usize {
0
+ self.profile.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.profile { w.write_with_tag(10, |w| w.write_message(s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct QuestionnaireView<'a> {
pub name: Cow<'a, str>,
pub description: Cow<'a, str>,
pub end_of_time: u32,
pub sections: Vec<mod_QuestionnaireView::Section<'a>>,
pub has_answered: bool,
}
impl<'a> MessageRead<'a> for QuestionnaireView<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.name = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(18) => msg.description = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(24) => msg.end_of_time = r.read_uint32(bytes)?,
Ok(34) => msg.sections.push(r.read_message::<mod_QuestionnaireView::Section>(bytes)?),
Ok(40) => msg.has_answered = r.read_bool(bytes)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for QuestionnaireView<'a> {
fn get_size(&self) -> usize {
0
+ if self.name == "" { 0 } else { 1 + sizeof_len((&self.name).len()) }
+ if self.description == "" { 0 } else { 1 + sizeof_len((&self.description).len()) }
+ if self.end_of_time == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.end_of_time) as u64) }
+ self.sections.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+ if self.has_answered == false { 0 } else { 1 + sizeof_varint(*(&self.has_answered) as u64) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.name != "" { w.write_with_tag(10, |w| w.write_string(&**&self.name))?; }
if self.description != "" { w.write_with_tag(18, |w| w.write_string(&**&self.description))?; }
if self.end_of_time != 0u32 { w.write_with_tag(24, |w| w.write_uint32(*&self.end_of_time))?; }
for s in &self.sections { w.write_with_tag(34, |w| w.write_message(s))?; }
if self.has_answered != false { w.write_with_tag(40, |w| w.write_bool(*&self.has_answered))?; }
Ok(())
}
}
pub mod mod_QuestionnaireView {
use std::borrow::Cow;
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Section<'a> {
pub id: u32,
pub body: Cow<'a, str>,
pub limitation: u32,
pub is_mandatory: bool,
pub selection: mod_QuestionnaireView::mod_Section::OneOfselection<'a>,
}
impl<'a> MessageRead<'a> for Section<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.id = r.read_uint32(bytes)?,
Ok(18) => msg.body = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(48) => msg.limitation = r.read_uint32(bytes)?,
Ok(64) => msg.is_mandatory = r.read_bool(bytes)?,
Ok(26) => msg.selection = mod_QuestionnaireView::mod_Section::OneOfselection::normal(r.read_message::<mod_QuestionnaireView::mod_Section::NormalSelection>(bytes)?),
Ok(34) => msg.selection = mod_QuestionnaireView::mod_Section::OneOfselection::thumbnail(r.read_message::<mod_QuestionnaireView::mod_Section::ThumbnailSelection>(bytes)?),
Ok(42) => msg.selection = mod_QuestionnaireView::mod_Section::OneOfselection::image_only(r.read_message::<mod_QuestionnaireView::mod_Section::ImageOnlySelection>(bytes)?),
Ok(58) => msg.selection = mod_QuestionnaireView::mod_Section::OneOfselection::freeform(r.read_message::<mod_QuestionnaireView::mod_Section::FreeForm>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Section<'a> {
fn get_size(&self) -> usize {
0
+ if self.id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.id) as u64) }
+ if self.body == "" { 0 } else { 1 + sizeof_len((&self.body).len()) }
+ if self.limitation == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.limitation) as u64) }
+ if self.is_mandatory == false { 0 } else { 1 + sizeof_varint(*(&self.is_mandatory) as u64) }
+ match self.selection {
mod_QuestionnaireView::mod_Section::OneOfselection::normal(ref m) => 1 + sizeof_len((m).get_size()),
mod_QuestionnaireView::mod_Section::OneOfselection::thumbnail(ref m) => 1 + sizeof_len((m).get_size()),
mod_QuestionnaireView::mod_Section::OneOfselection::image_only(ref m) => 1 + sizeof_len((m).get_size()),
mod_QuestionnaireView::mod_Section::OneOfselection::freeform(ref m) => 1 + sizeof_len((m).get_size()),
mod_QuestionnaireView::mod_Section::OneOfselection::None => 0,
} }
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.id != 0u32 { w.write_with_tag(8, |w| w.write_uint32(*&self.id))?; }
if self.body != "" { w.write_with_tag(18, |w| w.write_string(&**&self.body))?; }
if self.limitation != 0u32 { w.write_with_tag(48, |w| w.write_uint32(*&self.limitation))?; }
if self.is_mandatory != false { w.write_with_tag(64, |w| w.write_bool(*&self.is_mandatory))?; }
match self.selection { mod_QuestionnaireView::mod_Section::OneOfselection::normal(ref m) => { w.write_with_tag(26, |w| w.write_message(m))? },
mod_QuestionnaireView::mod_Section::OneOfselection::thumbnail(ref m) => { w.write_with_tag(34, |w| w.write_message(m))? },
mod_QuestionnaireView::mod_Section::OneOfselection::image_only(ref m) => { w.write_with_tag(42, |w| w.write_message(m))? },
mod_QuestionnaireView::mod_Section::OneOfselection::freeform(ref m) => { w.write_with_tag(58, |w| w.write_message(m))? },
mod_QuestionnaireView::mod_Section::OneOfselection::None => {},
} Ok(())
}
}
pub mod mod_Section {
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct NormalSelection<'a> {
pub answers: Vec<mod_QuestionnaireView::mod_Section::mod_NormalSelection::Answer<'a>>,
}
impl<'a> MessageRead<'a> for NormalSelection<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.answers.push(r.read_message::<mod_QuestionnaireView::mod_Section::mod_NormalSelection::Answer>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for NormalSelection<'a> {
fn get_size(&self) -> usize {
0
+ self.answers.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
for s in &self.answers { w.write_with_tag(10, |w| w.write_message(s))?; }
Ok(())
}
}
pub mod mod_NormalSelection {
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Answer<'a> {
pub answer: mod_QuestionnaireView::mod_Section::mod_NormalSelection::mod_Answer::OneOfanswer<'a>,
}
impl<'a> MessageRead<'a> for Answer<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.answer = mod_QuestionnaireView::mod_Section::mod_NormalSelection::mod_Answer::OneOfanswer::choice(r.read_message::<mod_QuestionnaireView::mod_Section::mod_NormalSelection::mod_Answer::Choice>(bytes)?),
Ok(18) => msg.answer = mod_QuestionnaireView::mod_Section::mod_NormalSelection::mod_Answer::OneOfanswer::freeform(r.read_message::<mod_QuestionnaireView::mod_Section::mod_NormalSelection::mod_Answer::Freeform>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Answer<'a> {
fn get_size(&self) -> usize {
0
+ match self.answer {
mod_QuestionnaireView::mod_Section::mod_NormalSelection::mod_Answer::OneOfanswer::choice(ref m) => 1 + sizeof_len((m).get_size()),
mod_QuestionnaireView::mod_Section::mod_NormalSelection::mod_Answer::OneOfanswer::freeform(ref m) => 1 + sizeof_len((m).get_size()),
mod_QuestionnaireView::mod_Section::mod_NormalSelection::mod_Answer::OneOfanswer::None => 0,
} }
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
match self.answer { mod_QuestionnaireView::mod_Section::mod_NormalSelection::mod_Answer::OneOfanswer::choice(ref m) => { w.write_with_tag(10, |w| w.write_message(m))? },
mod_QuestionnaireView::mod_Section::mod_NormalSelection::mod_Answer::OneOfanswer::freeform(ref m) => { w.write_with_tag(18, |w| w.write_message(m))? },
mod_QuestionnaireView::mod_Section::mod_NormalSelection::mod_Answer::OneOfanswer::None => {},
} Ok(())
}
}
pub mod mod_Answer {
use std::borrow::Cow;
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Choice<'a> {
pub id: u32,
pub body: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for Choice<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.id = r.read_uint32(bytes)?,
Ok(18) => msg.body = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Choice<'a> {
fn get_size(&self) -> usize {
0
+ if self.id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.id) as u64) }
+ if self.body == "" { 0 } else { 1 + sizeof_len((&self.body).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.id != 0u32 { w.write_with_tag(8, |w| w.write_uint32(*&self.id))?; }
if self.body != "" { w.write_with_tag(18, |w| w.write_string(&**&self.body))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Freeform<'a> {
pub body: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for Freeform<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.body = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Freeform<'a> {
fn get_size(&self) -> usize {
0
+ if self.body == "" { 0 } else { 1 + sizeof_len((&self.body).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.body != "" { w.write_with_tag(10, |w| w.write_string(&**&self.body))?; }
Ok(())
}
}
#[derive(Debug, PartialEq, Clone)]
pub enum OneOfanswer<'a> {
choice(mod_QuestionnaireView::mod_Section::mod_NormalSelection::mod_Answer::Choice<'a>),
freeform(mod_QuestionnaireView::mod_Section::mod_NormalSelection::mod_Answer::Freeform<'a>),
None,
}
impl<'a> Default for OneOfanswer<'a> {
fn default() -> Self {
OneOfanswer::None
}
}
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct ThumbnailSelection<'a> {
pub answers: Vec<mod_QuestionnaireView::mod_Section::mod_ThumbnailSelection::Answer<'a>>,
}
impl<'a> MessageRead<'a> for ThumbnailSelection<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.answers.push(r.read_message::<mod_QuestionnaireView::mod_Section::mod_ThumbnailSelection::Answer>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for ThumbnailSelection<'a> {
fn get_size(&self) -> usize {
0
+ self.answers.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
for s in &self.answers { w.write_with_tag(10, |w| w.write_message(s))?; }
Ok(())
}
}
pub mod mod_ThumbnailSelection {
use std::borrow::Cow;
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Answer<'a> {
pub id: u32,
pub body: Cow<'a, str>,
pub image_url: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for Answer<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.id = r.read_uint32(bytes)?,
Ok(18) => msg.body = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(26) => msg.image_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Answer<'a> {
fn get_size(&self) -> usize {
0
+ if self.id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.id) as u64) }
+ if self.body == "" { 0 } else { 1 + sizeof_len((&self.body).len()) }
+ if self.image_url == "" { 0 } else { 1 + sizeof_len((&self.image_url).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.id != 0u32 { w.write_with_tag(8, |w| w.write_uint32(*&self.id))?; }
if self.body != "" { w.write_with_tag(18, |w| w.write_string(&**&self.body))?; }
if self.image_url != "" { w.write_with_tag(26, |w| w.write_string(&**&self.image_url))?; }
Ok(())
}
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct ImageOnlySelection<'a> {
pub answers: Vec<mod_QuestionnaireView::mod_Section::mod_ImageOnlySelection::Answer<'a>>,
}
impl<'a> MessageRead<'a> for ImageOnlySelection<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.answers.push(r.read_message::<mod_QuestionnaireView::mod_Section::mod_ImageOnlySelection::Answer>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for ImageOnlySelection<'a> {
fn get_size(&self) -> usize {
0
+ self.answers.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
for s in &self.answers { w.write_with_tag(10, |w| w.write_message(s))?; }
Ok(())
}
}
pub mod mod_ImageOnlySelection {
use std::borrow::Cow;
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Answer<'a> {
pub id: u32,
pub body: Cow<'a, str>,
pub image_url: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for Answer<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.id = r.read_uint32(bytes)?,
Ok(18) => msg.body = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(26) => msg.image_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Answer<'a> {
fn get_size(&self) -> usize {
0
+ if self.id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.id) as u64) }
+ if self.body == "" { 0 } else { 1 + sizeof_len((&self.body).len()) }
+ if self.image_url == "" { 0 } else { 1 + sizeof_len((&self.image_url).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.id != 0u32 { w.write_with_tag(8, |w| w.write_uint32(*&self.id))?; }
if self.body != "" { w.write_with_tag(18, |w| w.write_string(&**&self.body))?; }
if self.image_url != "" { w.write_with_tag(26, |w| w.write_string(&**&self.image_url))?; }
Ok(())
}
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct FreeForm { }
impl<'a> MessageRead<'a> for FreeForm {
fn from_reader(r: &mut BytesReader, _: &[u8]) -> Result<Self> {
r.read_to_end();
Ok(Self::default())
}
}
impl MessageWrite for FreeForm { }
#[derive(Debug, PartialEq, Clone)]
pub enum OneOfselection<'a> {
normal(mod_QuestionnaireView::mod_Section::NormalSelection<'a>),
thumbnail(mod_QuestionnaireView::mod_Section::ThumbnailSelection<'a>),
image_only(mod_QuestionnaireView::mod_Section::ImageOnlySelection<'a>),
freeform(mod_QuestionnaireView::mod_Section::FreeForm),
None,
}
impl<'a> Default for OneOfselection<'a> {
fn default() -> Self {
OneOfselection::None
}
}
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct RankingView<'a> {
pub rankings: Vec<Ranking<'a>>,
}
impl<'a> MessageRead<'a> for RankingView<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.rankings.push(r.read_message::<Ranking>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for RankingView<'a> {
fn get_size(&self) -> usize {
0
+ self.rankings.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
for s in &self.rankings { w.write_with_tag(10, |w| w.write_message(s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct SearchView<'a> {
pub tags: Vec<Tag<'a>>,
pub title_groups: Vec<TitleGroup<'a>>,
}
impl<'a> MessageRead<'a> for SearchView<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.tags.push(r.read_message::<Tag>(bytes)?),
Ok(18) => msg.title_groups.push(r.read_message::<TitleGroup>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for SearchView<'a> {
fn get_size(&self) -> usize {
0
+ self.tags.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+ self.title_groups.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
for s in &self.tags { w.write_with_tag(10, |w| w.write_message(s))?; }
for s in &self.title_groups { w.write_with_tag(18, |w| w.write_message(s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct TitleDetailView<'a> {
pub title: Option<Title<'a>>,
pub next_update_info: Cow<'a, str>,
pub main_thumbnail_url: Cow<'a, str>,
pub long_description: Cow<'a, str>,
pub copyright: Cow<'a, str>,
pub banners: Vec<Banner<'a>>,
pub chapters: Vec<ChapterGroup<'a>>,
pub is_bookmarked: bool,
pub sns: Option<Sns<'a>>,
pub is_free_title: bool,
}
impl<'a> MessageRead<'a> for TitleDetailView<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.title = Some(r.read_message::<Title>(bytes)?),
Ok(18) => msg.next_update_info = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(26) => msg.main_thumbnail_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(34) => msg.long_description = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(42) => msg.copyright = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(50) => msg.banners.push(r.read_message::<Banner>(bytes)?),
Ok(58) => msg.chapters.push(r.read_message::<ChapterGroup>(bytes)?),
Ok(64) => msg.is_bookmarked = r.read_bool(bytes)?,
Ok(74) => msg.sns = Some(r.read_message::<Sns>(bytes)?),
Ok(80) => msg.is_free_title = r.read_bool(bytes)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for TitleDetailView<'a> {
fn get_size(&self) -> usize {
0
+ self.title.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ if self.next_update_info == "" { 0 } else { 1 + sizeof_len((&self.next_update_info).len()) }
+ if self.main_thumbnail_url == "" { 0 } else { 1 + sizeof_len((&self.main_thumbnail_url).len()) }
+ if self.long_description == "" { 0 } else { 1 + sizeof_len((&self.long_description).len()) }
+ if self.copyright == "" { 0 } else { 1 + sizeof_len((&self.copyright).len()) }
+ self.banners.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+ self.chapters.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+ if self.is_bookmarked == false { 0 } else { 1 + sizeof_varint(*(&self.is_bookmarked) as u64) }
+ self.sns.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ if self.is_free_title == false { 0 } else { 1 + sizeof_varint(*(&self.is_free_title) as u64) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.title { w.write_with_tag(10, |w| w.write_message(s))?; }
if self.next_update_info != "" { w.write_with_tag(18, |w| w.write_string(&**&self.next_update_info))?; }
if self.main_thumbnail_url != "" { w.write_with_tag(26, |w| w.write_string(&**&self.main_thumbnail_url))?; }
if self.long_description != "" { w.write_with_tag(34, |w| w.write_string(&**&self.long_description))?; }
if self.copyright != "" { w.write_with_tag(42, |w| w.write_string(&**&self.copyright))?; }
for s in &self.banners { w.write_with_tag(50, |w| w.write_message(s))?; }
for s in &self.chapters { w.write_with_tag(58, |w| w.write_message(s))?; }
if self.is_bookmarked != false { w.write_with_tag(64, |w| w.write_bool(*&self.is_bookmarked))?; }
if let Some(ref s) = self.sns { w.write_with_tag(74, |w| w.write_message(s))?; }
if self.is_free_title != false { w.write_with_tag(80, |w| w.write_bool(*&self.is_free_title))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct TitleListView<'a> {
pub picked_up_title: Option<Title<'a>>,
pub titles: Vec<Title<'a>>,
}
impl<'a> MessageRead<'a> for TitleListView<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.picked_up_title = Some(r.read_message::<Title>(bytes)?),
Ok(18) => msg.titles.push(r.read_message::<Title>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for TitleListView<'a> {
fn get_size(&self) -> usize {
0
+ self.picked_up_title.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.titles.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.picked_up_title { w.write_with_tag(10, |w| w.write_message(s))?; }
for s in &self.titles { w.write_with_tag(18, |w| w.write_message(s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct WebMangaViewerView<'a> {
pub pages: Vec<mod_WebMangaViewerView::WebMangaPage<'a>>,
pub last_page: Option<mod_WebMangaViewerView::LastPage<'a>>,
pub title: Option<Title<'a>>,
pub if_left_start: bool,
pub title_detail_url: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for WebMangaViewerView<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.pages.push(r.read_message::<mod_WebMangaViewerView::WebMangaPage>(bytes)?),
Ok(18) => msg.last_page = Some(r.read_message::<mod_WebMangaViewerView::LastPage>(bytes)?),
Ok(26) => msg.title = Some(r.read_message::<Title>(bytes)?),
Ok(32) => msg.if_left_start = r.read_bool(bytes)?,
Ok(42) => msg.title_detail_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for WebMangaViewerView<'a> {
fn get_size(&self) -> usize {
0
+ self.pages.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
+ self.last_page.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.title.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ if self.if_left_start == false { 0 } else { 1 + sizeof_varint(*(&self.if_left_start) as u64) }
+ if self.title_detail_url == "" { 0 } else { 1 + sizeof_len((&self.title_detail_url).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
for s in &self.pages { w.write_with_tag(10, |w| w.write_message(s))?; }
if let Some(ref s) = self.last_page { w.write_with_tag(18, |w| w.write_message(s))?; }
if let Some(ref s) = self.title { w.write_with_tag(26, |w| w.write_message(s))?; }
if self.if_left_start != false { w.write_with_tag(32, |w| w.write_bool(*&self.if_left_start))?; }
if self.title_detail_url != "" { w.write_with_tag(42, |w| w.write_string(&**&self.title_detail_url))?; }
Ok(())
}
}
pub mod mod_WebMangaViewerView {
use std::borrow::Cow;
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct WebMangaPage<'a> {
pub content: mod_WebMangaViewerView::mod_WebMangaPage::OneOfcontent<'a>,
}
impl<'a> MessageRead<'a> for WebMangaPage<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.content = mod_WebMangaViewerView::mod_WebMangaPage::OneOfcontent::image(r.read_message::<mod_WebMangaViewerView::mod_WebMangaPage::Image>(bytes)?),
Ok(18) => msg.content = mod_WebMangaViewerView::mod_WebMangaPage::OneOfcontent::link_image(r.read_message::<mod_WebMangaViewerView::mod_WebMangaPage::LinkImage>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for WebMangaPage<'a> {
fn get_size(&self) -> usize {
0
+ match self.content {
mod_WebMangaViewerView::mod_WebMangaPage::OneOfcontent::image(ref m) => 1 + sizeof_len((m).get_size()),
mod_WebMangaViewerView::mod_WebMangaPage::OneOfcontent::link_image(ref m) => 1 + sizeof_len((m).get_size()),
mod_WebMangaViewerView::mod_WebMangaPage::OneOfcontent::None => 0,
} }
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
match self.content { mod_WebMangaViewerView::mod_WebMangaPage::OneOfcontent::image(ref m) => { w.write_with_tag(10, |w| w.write_message(m))? },
mod_WebMangaViewerView::mod_WebMangaPage::OneOfcontent::link_image(ref m) => { w.write_with_tag(18, |w| w.write_message(m))? },
mod_WebMangaViewerView::mod_WebMangaPage::OneOfcontent::None => {},
} Ok(())
}
}
pub mod mod_WebMangaPage {
use std::borrow::Cow;
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Image<'a> {
pub image_url: Cow<'a, str>,
pub encryption_key: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for Image<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.image_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(18) => msg.encryption_key = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Image<'a> {
fn get_size(&self) -> usize {
0
+ if self.image_url == "" { 0 } else { 1 + sizeof_len((&self.image_url).len()) }
+ if self.encryption_key == "" { 0 } else { 1 + sizeof_len((&self.encryption_key).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.image_url != "" { w.write_with_tag(10, |w| w.write_string(&**&self.image_url))?; }
if self.encryption_key != "" { w.write_with_tag(18, |w| w.write_string(&**&self.encryption_key))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct LinkImage<'a> {
pub image_url: Cow<'a, str>,
pub url: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for LinkImage<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.image_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(18) => msg.url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for LinkImage<'a> {
fn get_size(&self) -> usize {
0
+ if self.image_url == "" { 0 } else { 1 + sizeof_len((&self.image_url).len()) }
+ if self.url == "" { 0 } else { 1 + sizeof_len((&self.url).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.image_url != "" { w.write_with_tag(10, |w| w.write_string(&**&self.image_url))?; }
if self.url != "" { w.write_with_tag(18, |w| w.write_string(&**&self.url))?; }
Ok(())
}
}
#[derive(Debug, PartialEq, Clone)]
pub enum OneOfcontent<'a> {
image(mod_WebMangaViewerView::mod_WebMangaPage::Image<'a>),
link_image(mod_WebMangaViewerView::mod_WebMangaPage::LinkImage<'a>),
None,
}
impl<'a> Default for OneOfcontent<'a> {
fn default() -> Self {
OneOfcontent::None
}
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct LastPage<'a> {
pub next_chapter: Option<Chapter<'a>>,
pub impresstion_form_url: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for LastPage<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.next_chapter = Some(r.read_message::<Chapter>(bytes)?),
Ok(18) => msg.impresstion_form_url = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for LastPage<'a> {
fn get_size(&self) -> usize {
0
+ self.next_chapter.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ if self.impresstion_form_url == "" { 0 } else { 1 + sizeof_len((&self.impresstion_form_url).len()) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.next_chapter { w.write_with_tag(10, |w| w.write_message(s))?; }
if self.impresstion_form_url != "" { w.write_with_tag(18, |w| w.write_string(&**&self.impresstion_form_url))?; }
Ok(())
}
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Response<'a> {
pub server_time: u32,
pub debug_info: Vec<Cow<'a, str>>,
pub result: mod_Response::OneOfresult<'a>,
}
impl<'a> MessageRead<'a> for Response<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(24) => msg.server_time = r.read_uint32(bytes)?,
Ok(34) => msg.debug_info.push(r.read_string(bytes).map(Cow::Borrowed)?),
Ok(10) => msg.result = mod_Response::OneOfresult::success(r.read_message::<mod_Response::SuccessResult>(bytes)?),
Ok(18) => msg.result = mod_Response::OneOfresult::error(r.read_message::<mod_Response::ErrorResult>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Response<'a> {
fn get_size(&self) -> usize {
0
+ if self.server_time == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.server_time) as u64) }
+ self.debug_info.iter().map(|s| 1 + sizeof_len((s).len())).sum::<usize>()
+ match self.result {
mod_Response::OneOfresult::success(ref m) => 1 + sizeof_len((m).get_size()),
mod_Response::OneOfresult::error(ref m) => 1 + sizeof_len((m).get_size()),
mod_Response::OneOfresult::None => 0,
} }
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.server_time != 0u32 { w.write_with_tag(24, |w| w.write_uint32(*&self.server_time))?; }
for s in &self.debug_info { w.write_with_tag(34, |w| w.write_string(&**s))?; }
match self.result { mod_Response::OneOfresult::success(ref m) => { w.write_with_tag(10, |w| w.write_message(m))? },
mod_Response::OneOfresult::error(ref m) => { w.write_with_tag(18, |w| w.write_message(m))? },
mod_Response::OneOfresult::None => {},
} Ok(())
}
}
pub mod mod_Response {
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct ErrorResult<'a> {
pub popup: Option<Popup<'a>>,
pub user_item: Option<UserPoint>,
pub action: mod_Response::mod_ErrorResult::Action,
}
impl<'a> MessageRead<'a> for ErrorResult<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.popup = Some(r.read_message::<Popup>(bytes)?),
Ok(18) => msg.user_item = Some(r.read_message::<UserPoint>(bytes)?),
Ok(24) => msg.action = r.read_enum(bytes)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for ErrorResult<'a> {
fn get_size(&self) -> usize {
0
+ self.popup.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.user_item.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ if self.action == reader::mod_Response::mod_ErrorResult::Action::DEFAULT { 0 } else { 1 + sizeof_varint(*(&self.action) as u64) }
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.popup { w.write_with_tag(10, |w| w.write_message(s))?; }
if let Some(ref s) = self.user_item { w.write_with_tag(18, |w| w.write_message(s))?; }
if self.action != reader::mod_Response::mod_ErrorResult::Action::DEFAULT { w.write_with_tag(24, |w| w.write_enum(*&self.action as i32))?; }
Ok(())
}
}
pub mod mod_ErrorResult {
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum Action {
DEFAULT = 0,
MAINTENANCE = 1,
ITEM_UPDATE = 2,
USER_REGISTER = 3,
}
impl Default for Action {
fn default() -> Self {
Action::DEFAULT
}
}
impl From<i32> for Action {
fn from(i: i32) -> Self {
match i {
0 => Action::DEFAULT,
1 => Action::MAINTENANCE,
2 => Action::ITEM_UPDATE,
3 => Action::USER_REGISTER,
_ => Self::default(),
}
}
}
impl<'a> From<&'a str> for Action {
fn from(s: &'a str) -> Self {
match s {
"DEFAULT" => Action::DEFAULT,
"MAINTENANCE" => Action::MAINTENANCE,
"ITEM_UPDATE" => Action::ITEM_UPDATE,
"USER_REGISTER" => Action::USER_REGISTER,
_ => Self::default(),
}
}
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct SuccessResult<'a> {
pub user_item: Option<UserPoint>,
pub notification: Option<mod_Response::mod_SuccessResult::Notification<'a>>,
pub view: mod_Response::mod_SuccessResult::OneOfview<'a>,
}
impl<'a> MessageRead<'a> for SuccessResult<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.user_item = Some(r.read_message::<UserPoint>(bytes)?),
Ok(18) => msg.notification = Some(r.read_message::<mod_Response::mod_SuccessResult::Notification>(bytes)?),
Ok(34) => msg.view = mod_Response::mod_SuccessResult::OneOfview::background_download(r.read_message::<BackgroundDownloadView>(bytes)?),
Ok(42) => msg.view = mod_Response::mod_SuccessResult::OneOfview::billing_item_list(r.read_message::<BillingItemListView>(bytes)?),
Ok(50) => msg.view = mod_Response::mod_SuccessResult::OneOfview::comment_list(r.read_message::<CommentListView>(bytes)?),
Ok(58) => msg.view = mod_Response::mod_SuccessResult::OneOfview::home(r.read_message::<HomeView>(bytes)?),
Ok(66) => msg.view = mod_Response::mod_SuccessResult::OneOfview::manga_viewer(r.read_message::<MangaViewerView>(bytes)?),
Ok(74) => msg.view = mod_Response::mod_SuccessResult::OneOfview::novel_viewer(r.read_message::<NovelViewerView>(bytes)?),
Ok(82) => msg.view = mod_Response::mod_SuccessResult::OneOfview::point_history(r.read_message::<PointHistoryView>(bytes)?),
Ok(90) => msg.view = mod_Response::mod_SuccessResult::OneOfview::title_detail(r.read_message::<TitleDetailView>(bytes)?),
Ok(98) => msg.view = mod_Response::mod_SuccessResult::OneOfview::title_list(r.read_message::<TitleListView>(bytes)?),
Ok(106) => msg.view = mod_Response::mod_SuccessResult::OneOfview::profile(r.read_message::<ProfileView>(bytes)?),
Ok(114) => msg.view = mod_Response::mod_SuccessResult::OneOfview::device(r.read_message::<DeviceView>(bytes)?),
Ok(122) => msg.view = mod_Response::mod_SuccessResult::OneOfview::ranking(r.read_message::<RankingView>(bytes)?),
Ok(130) => msg.view = mod_Response::mod_SuccessResult::OneOfview::all_chapters_list(r.read_message::<AllChaptersListView>(bytes)?),
Ok(138) => msg.view = mod_Response::mod_SuccessResult::OneOfview::featured_title_list(r.read_message::<FeaturedTitleListView>(bytes)?),
Ok(146) => msg.view = mod_Response::mod_SuccessResult::OneOfview::search(r.read_message::<SearchView>(bytes)?),
Ok(154) => msg.view = mod_Response::mod_SuccessResult::OneOfview::bridge_trans_id(r.read_message::<BridgeTransIdView>(bytes)?),
Ok(162) => msg.view = mod_Response::mod_SuccessResult::OneOfview::questionnaire(r.read_message::<QuestionnaireView>(bytes)?),
Ok(170) => msg.view = mod_Response::mod_SuccessResult::OneOfview::my_page(r.read_message::<MyPageView>(bytes)?),
Ok(178) => msg.view = mod_Response::mod_SuccessResult::OneOfview::comment_post(r.read_message::<CommentPostView>(bytes)?),
Ok(186) => msg.view = mod_Response::mod_SuccessResult::OneOfview::web_manga_viewer(r.read_message::<WebMangaViewerView>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for SuccessResult<'a> {
fn get_size(&self) -> usize {
0
+ self.user_item.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ self.notification.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
+ match self.view {
mod_Response::mod_SuccessResult::OneOfview::background_download(ref m) => 1 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::billing_item_list(ref m) => 1 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::comment_list(ref m) => 1 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::home(ref m) => 1 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::manga_viewer(ref m) => 1 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::novel_viewer(ref m) => 1 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::point_history(ref m) => 1 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::title_detail(ref m) => 1 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::title_list(ref m) => 1 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::profile(ref m) => 1 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::device(ref m) => 1 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::ranking(ref m) => 1 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::all_chapters_list(ref m) => 2 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::featured_title_list(ref m) => 2 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::search(ref m) => 2 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::bridge_trans_id(ref m) => 2 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::questionnaire(ref m) => 2 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::my_page(ref m) => 2 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::comment_post(ref m) => 2 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::web_manga_viewer(ref m) => 2 + sizeof_len((m).get_size()),
mod_Response::mod_SuccessResult::OneOfview::None => 0,
} }
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.user_item { w.write_with_tag(10, |w| w.write_message(s))?; }
if let Some(ref s) = self.notification { w.write_with_tag(18, |w| w.write_message(s))?; }
match self.view { mod_Response::mod_SuccessResult::OneOfview::background_download(ref m) => { w.write_with_tag(34, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::billing_item_list(ref m) => { w.write_with_tag(42, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::comment_list(ref m) => { w.write_with_tag(50, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::home(ref m) => { w.write_with_tag(58, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::manga_viewer(ref m) => { w.write_with_tag(66, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::novel_viewer(ref m) => { w.write_with_tag(74, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::point_history(ref m) => { w.write_with_tag(82, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::title_detail(ref m) => { w.write_with_tag(90, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::title_list(ref m) => { w.write_with_tag(98, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::profile(ref m) => { w.write_with_tag(106, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::device(ref m) => { w.write_with_tag(114, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::ranking(ref m) => { w.write_with_tag(122, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::all_chapters_list(ref m) => { w.write_with_tag(130, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::featured_title_list(ref m) => { w.write_with_tag(138, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::search(ref m) => { w.write_with_tag(146, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::bridge_trans_id(ref m) => { w.write_with_tag(154, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::questionnaire(ref m) => { w.write_with_tag(162, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::my_page(ref m) => { w.write_with_tag(170, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::comment_post(ref m) => { w.write_with_tag(178, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::web_manga_viewer(ref m) => { w.write_with_tag(186, |w| w.write_message(m))? },
mod_Response::mod_SuccessResult::OneOfview::None => {},
} Ok(())
}
}
pub mod mod_SuccessResult {
use std::borrow::Cow;
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Notification<'a> {
pub subject: Cow<'a, str>,
pub point: Option<UserPoint>,
}
impl<'a> MessageRead<'a> for Notification<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.subject = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(18) => msg.point = Some(r.read_message::<UserPoint>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Notification<'a> {
fn get_size(&self) -> usize {
0
+ if self.subject == "" { 0 } else { 1 + sizeof_len((&self.subject).len()) }
+ self.point.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
}
fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
if self.subject != "" { w.write_with_tag(10, |w| w.write_string(&**&self.subject))?; }
if let Some(ref s) = self.point { w.write_with_tag(18, |w| w.write_message(s))?; }
Ok(())
}
}
#[derive(Debug, PartialEq, Clone)]
pub enum OneOfview<'a> {
background_download(BackgroundDownloadView<'a>),
billing_item_list(BillingItemListView<'a>),
comment_list(CommentListView<'a>),
home(HomeView<'a>),
manga_viewer(MangaViewerView<'a>),
novel_viewer(NovelViewerView<'a>),
point_history(PointHistoryView<'a>),
title_detail(TitleDetailView<'a>),
title_list(TitleListView<'a>),
profile(ProfileView),
device(DeviceView<'a>),
ranking(RankingView<'a>),
all_chapters_list(AllChaptersListView<'a>),
featured_title_list(FeaturedTitleListView<'a>),
search(SearchView<'a>),
bridge_trans_id(BridgeTransIdView),
questionnaire(QuestionnaireView<'a>),
my_page(MyPageView<'a>),
comment_post(CommentPostView),
web_manga_viewer(WebMangaViewerView<'a>),
None,
}
impl<'a> Default for OneOfview<'a> {
fn default() -> Self {
OneOfview::None
}
}
}
#[derive(Debug, PartialEq, Clone)]
pub enum OneOfresult<'a> {
success(mod_Response::SuccessResult<'a>),
error(mod_Response::ErrorResult<'a>),
None,
}
impl<'a> Default for OneOfresult<'a> {
fn default() -> Self {
OneOfresult::None
}
}
}