mangaplus_parser/builds/zeen3/mangaplus-parser/target/debug/build/mangaplus-parser-72cae2a5ea8a2d0e/out/

reader.rs

use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result};
use quick_protobuf::sizeofs::*;
use serde::{Serialize, Deserialize};
use super::*;

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct Popup {
    pub os_default: Option<mod_Popup::OSDefault>,
    pub app_default: Option<mod_Popup::AppDefault>,
}

impl<'a> MessageRead<'a> for Popup {
    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::OSDefault>(bytes)?),
                Ok(18) => msg.app_default = Some(r.read_message::<mod_Popup::AppDefault>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for Popup {
    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()))
    }

    fn write_message<W: WriterBackend>(&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))?; }
        Ok(())
    }
}

pub mod mod_Popup {

use super::*;

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct AppDefault {
    pub image_url: String,
    pub action: Option<TransitionAction>,
}

impl<'a> MessageRead<'a> for AppDefault {
    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)?.to_owned(),
                Ok(18) => msg.action = Some(r.read_message::<TransitionAction>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for AppDefault {
    fn get_size(&self) -> usize {
        0
        + if self.image_url == String::default() { 0 } else { 1 + sizeof_len((&self.image_url).len()) }
        + self.action.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.image_url != String::default() { w.write_with_tag(10, |w| w.write_string(&**&self.image_url))?; }
        if let Some(ref s) = self.action { w.write_with_tag(18, |w| w.write_message(s))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct Button {
    pub text: String,
    pub action: Option<TransitionAction>,
}

impl<'a> MessageRead<'a> for Button {
    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)?.to_owned(),
                Ok(18) => msg.action = Some(r.read_message::<TransitionAction>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for Button {
    fn get_size(&self) -> usize {
        0
        + if self.text == String::default() { 0 } else { 1 + sizeof_len((&self.text).len()) }
        + self.action.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.text != String::default() { w.write_with_tag(10, |w| w.write_string(&**&self.text))?; }
        if let Some(ref s) = self.action { w.write_with_tag(18, |w| w.write_message(s))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct OSDefault {
    pub subject: String,
    pub body: String,
    pub ok_button: Option<mod_Popup::Button>,
    pub neautral_button: Option<mod_Popup::Button>,
    pub cancel_button: Option<mod_Popup::Button>,
}

impl<'a> MessageRead<'a> for OSDefault {
    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)?.to_owned(),
                Ok(18) => msg.body = r.read_string(bytes)?.to_owned(),
                Ok(26) => msg.ok_button = Some(r.read_message::<mod_Popup::Button>(bytes)?),
                Ok(34) => msg.neautral_button = Some(r.read_message::<mod_Popup::Button>(bytes)?),
                Ok(42) => msg.cancel_button = Some(r.read_message::<mod_Popup::Button>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for OSDefault {
    fn get_size(&self) -> usize {
        0
        + if self.subject == String::default() { 0 } else { 1 + sizeof_len((&self.subject).len()) }
        + if self.body == String::default() { 0 } else { 1 + sizeof_len((&self.body).len()) }
        + self.ok_button.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
        + self.neautral_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()))
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.subject != String::default() { w.write_with_tag(10, |w| w.write_string(&**&self.subject))?; }
        if self.body != String::default() { 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.neautral_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))?; }
        Ok(())
    }
}

}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct HomeView {
    pub top_banners: Vec<Banner>,
    pub groups: Vec<UpdatedTitleGroup>,
    pub popup: Option<Popup>,
}

impl<'a> MessageRead<'a> for HomeView {
    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.groups.push(r.read_message::<UpdatedTitleGroup>(bytes)?),
                Ok(74) => msg.popup = Some(r.read_message::<Popup>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for HomeView {
    fn get_size(&self) -> usize {
        0
        + self.top_banners.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
        + self.groups.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
        + self.popup.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
    }

    fn write_message<W: WriterBackend>(&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.groups { w.write_with_tag(18, |w| w.write_message(s))?; }
        if let Some(ref s) = self.popup { w.write_with_tag(74, |w| w.write_message(s))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct Feedback {
    pub time_stamp: u32,
    pub body: String,
    pub response_type: mod_Feedback::ResponseType,
}

impl<'a> MessageRead<'a> for Feedback {
    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.time_stamp = r.read_uint32(bytes)?,
                Ok(18) => msg.body = r.read_string(bytes)?.to_owned(),
                Ok(24) => msg.response_type = r.read_enum(bytes)?,
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for Feedback {
    fn get_size(&self) -> usize {
        0
        + if self.time_stamp == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.time_stamp) as u64) }
        + if self.body == String::default() { 0 } else { 1 + sizeof_len((&self.body).len()) }
        + if self.response_type == reader::mod_Feedback::ResponseType::QUESTION { 0 } else { 1 + sizeof_varint(*(&self.response_type) as u64) }
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.time_stamp != 0u32 { w.write_with_tag(8, |w| w.write_uint32(*&self.time_stamp))?; }
        if self.body != String::default() { w.write_with_tag(18, |w| w.write_string(&**&self.body))?; }
        if self.response_type != reader::mod_Feedback::ResponseType::QUESTION { w.write_with_tag(24, |w| w.write_enum(*&self.response_type as i32))?; }
        Ok(())
    }
}

pub mod mod_Feedback {



use super::*;#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[derive(Serialize, Deserialize)]
pub enum ResponseType {
    QUESTION = 0,
    ANSWER = 1,
}

impl Default for ResponseType {
    fn default() -> Self {
        ResponseType::QUESTION
    }
}

impl From<i32> for ResponseType {
    fn from(i: i32) -> Self {
        match i {
            0 => ResponseType::QUESTION,
            1 => ResponseType::ANSWER,
            _ => Self::default(),
        }
    }
}

impl<'a> From<&'a str> for ResponseType {
    fn from(s: &'a str) -> Self {
        match s {
            "QUESTION" => ResponseType::QUESTION,
            "ANSWER" => ResponseType::ANSWER,
            _ => Self::default(),
        }
    }
}

}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct FeedbackView {
    pub feedback_list: Vec<Feedback>,
}

impl<'a> MessageRead<'a> for FeedbackView {
    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.feedback_list.push(r.read_message::<Feedback>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for FeedbackView {
    fn get_size(&self) -> usize {
        0
        + self.feedback_list.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        for s in &self.feedback_list { w.write_with_tag(10, |w| w.write_message(s))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct RegistrationData {
    pub device_secret: String,
}

impl<'a> MessageRead<'a> for RegistrationData {
    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.device_secret = r.read_string(bytes)?.to_owned(),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for RegistrationData {
    fn get_size(&self) -> usize {
        0
        + if self.device_secret == String::default() { 0 } else { 1 + sizeof_len((&self.device_secret).len()) }
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.device_secret != String::default() { w.write_with_tag(10, |w| w.write_string(&**&self.device_secret))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct Sns {
    pub body: String,
    pub url: String,
}

impl<'a> MessageRead<'a> for Sns {
    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)?.to_owned(),
                Ok(18) => msg.url = r.read_string(bytes)?.to_owned(),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for Sns {
    fn get_size(&self) -> usize {
        0
        + if self.body == String::default() { 0 } else { 1 + sizeof_len((&self.body).len()) }
        + if self.url == String::default() { 0 } else { 1 + sizeof_len((&self.url).len()) }
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.body != String::default() { w.write_with_tag(10, |w| w.write_string(&**&self.body))?; }
        if self.url != String::default() { w.write_with_tag(18, |w| w.write_string(&**&self.url))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct Chapter {
    pub title_id: u32,
    pub chapter_id: u32,
    pub name: String,
    pub sub_title: String,
    pub thumbnail_url: String,
    pub start_time_stamp: u32,
    pub end_time_stamp: u32,
    pub already_viewed: bool,
    pub is_vertical_only: bool,
}

impl<'a> MessageRead<'a> for Chapter {
    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(16) => msg.chapter_id = r.read_uint32(bytes)?,
                Ok(26) => msg.name = r.read_string(bytes)?.to_owned(),
                Ok(34) => msg.sub_title = r.read_string(bytes)?.to_owned(),
                Ok(42) => msg.thumbnail_url = r.read_string(bytes)?.to_owned(),
                Ok(48) => msg.start_time_stamp = r.read_uint32(bytes)?,
                Ok(56) => msg.end_time_stamp = r.read_uint32(bytes)?,
                Ok(64) => msg.already_viewed = r.read_bool(bytes)?,
                Ok(72) => msg.is_vertical_only = r.read_bool(bytes)?,
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for Chapter {
    fn get_size(&self) -> usize {
        0
        + 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) }
        + if self.name == String::default() { 0 } else { 1 + sizeof_len((&self.name).len()) }
        + if self.sub_title == String::default() { 0 } else { 1 + sizeof_len((&self.sub_title).len()) }
        + if self.thumbnail_url == String::default() { 0 } else { 1 + sizeof_len((&self.thumbnail_url).len()) }
        + if self.start_time_stamp == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.start_time_stamp) as u64) }
        + if self.end_time_stamp == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.end_time_stamp) as u64) }
        + if self.already_viewed == false { 0 } else { 1 + sizeof_varint(*(&self.already_viewed) as u64) }
        + if self.is_vertical_only == false { 0 } else { 1 + sizeof_varint(*(&self.is_vertical_only) as u64) }
    }

    fn write_message<W: WriterBackend>(&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.chapter_id != 0u32 { w.write_with_tag(16, |w| w.write_uint32(*&self.chapter_id))?; }
        if self.name != String::default() { w.write_with_tag(26, |w| w.write_string(&**&self.name))?; }
        if self.sub_title != String::default() { w.write_with_tag(34, |w| w.write_string(&**&self.sub_title))?; }
        if self.thumbnail_url != String::default() { w.write_with_tag(42, |w| w.write_string(&**&self.thumbnail_url))?; }
        if self.start_time_stamp != 0u32 { w.write_with_tag(48, |w| w.write_uint32(*&self.start_time_stamp))?; }
        if self.end_time_stamp != 0u32 { w.write_with_tag(56, |w| w.write_uint32(*&self.end_time_stamp))?; }
        if self.already_viewed != false { w.write_with_tag(64, |w| w.write_bool(*&self.already_viewed))?; }
        if self.is_vertical_only != false { w.write_with_tag(72, |w| w.write_bool(*&self.is_vertical_only))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct AdNetwork {
    pub Network: mod_AdNetwork::OneOfNetwork,
}

impl<'a> MessageRead<'a> for AdNetwork {
    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.Network = mod_AdNetwork::OneOfNetwork::facebook(r.read_message::<mod_AdNetwork::Facebook>(bytes)?),
                Ok(18) => msg.Network = mod_AdNetwork::OneOfNetwork::admob(r.read_message::<mod_AdNetwork::Admob>(bytes)?),
                Ok(26) => msg.Network = mod_AdNetwork::OneOfNetwork::adsense(r.read_message::<mod_AdNetwork::Adsense>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for AdNetwork {
    fn get_size(&self) -> usize {
        0
        + match self.Network {
            mod_AdNetwork::OneOfNetwork::facebook(ref m) => 1 + sizeof_len((m).get_size()),
            mod_AdNetwork::OneOfNetwork::admob(ref m) => 1 + sizeof_len((m).get_size()),
            mod_AdNetwork::OneOfNetwork::adsense(ref m) => 1 + sizeof_len((m).get_size()),
            mod_AdNetwork::OneOfNetwork::None => 0,
    }    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        match self.Network {            mod_AdNetwork::OneOfNetwork::facebook(ref m) => { w.write_with_tag(10, |w| w.write_message(m))? },
            mod_AdNetwork::OneOfNetwork::admob(ref m) => { w.write_with_tag(18, |w| w.write_message(m))? },
            mod_AdNetwork::OneOfNetwork::adsense(ref m) => { w.write_with_tag(26, |w| w.write_message(m))? },
            mod_AdNetwork::OneOfNetwork::None => {},
    }        Ok(())
    }
}

pub mod mod_AdNetwork {

use super::*;

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct Facebook {
    pub placementID: String,
}

impl<'a> MessageRead<'a> for Facebook {
    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.placementID = r.read_string(bytes)?.to_owned(),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for Facebook {
    fn get_size(&self) -> usize {
        0
        + if self.placementID == String::default() { 0 } else { 1 + sizeof_len((&self.placementID).len()) }
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.placementID != String::default() { w.write_with_tag(10, |w| w.write_string(&**&self.placementID))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct Admob {
    pub unitID: String,
}

impl<'a> MessageRead<'a> for Admob {
    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.unitID = r.read_string(bytes)?.to_owned(),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for Admob {
    fn get_size(&self) -> usize {
        0
        + if self.unitID == String::default() { 0 } else { 1 + sizeof_len((&self.unitID).len()) }
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.unitID != String::default() { w.write_with_tag(10, |w| w.write_string(&**&self.unitID))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct Adsense {
    pub unitID: String,
}

impl<'a> MessageRead<'a> for Adsense {
    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.unitID = r.read_string(bytes)?.to_owned(),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for Adsense {
    fn get_size(&self) -> usize {
        0
        + if self.unitID == String::default() { 0 } else { 1 + sizeof_len((&self.unitID).len()) }
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.unitID != String::default() { w.write_with_tag(10, |w| w.write_string(&**&self.unitID))?; }
        Ok(())
    }
}

#[derive(Debug, PartialEq, Clone)]
#[derive(Serialize, Deserialize)]
pub enum OneOfNetwork {
    facebook(mod_AdNetwork::Facebook),
    admob(mod_AdNetwork::Admob),
    adsense(mod_AdNetwork::Adsense),
    None,
}

impl Default for OneOfNetwork {
    fn default() -> Self {
        OneOfNetwork::None
    }
}

}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct AdNetworkList {
    pub ad_networks: Vec<AdNetwork>,
}

impl<'a> MessageRead<'a> for AdNetworkList {
    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 MessageWrite for AdNetworkList {
    fn get_size(&self) -> usize {
        0
        + self.ad_networks.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        for s in &self.ad_networks { w.write_with_tag(10, |w| w.write_message(s))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct Page {
    pub data: mod_Page::OneOfdata,
}

impl<'a> MessageRead<'a> for Page {
    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.data = mod_Page::OneOfdata::manga_page(r.read_message::<mod_Page::MangaPage>(bytes)?),
                Ok(18) => msg.data = mod_Page::OneOfdata::banner_list(r.read_message::<mod_Page::BannerList>(bytes)?),
                Ok(26) => msg.data = mod_Page::OneOfdata::last_page(r.read_message::<mod_Page::LastPage>(bytes)?),
                Ok(34) => msg.data = mod_Page::OneOfdata::advertisement(r.read_message::<AdNetworkList>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for Page {
    fn get_size(&self) -> usize {
        0
        + match self.data {
            mod_Page::OneOfdata::manga_page(ref m) => 1 + sizeof_len((m).get_size()),
            mod_Page::OneOfdata::banner_list(ref m) => 1 + sizeof_len((m).get_size()),
            mod_Page::OneOfdata::last_page(ref m) => 1 + sizeof_len((m).get_size()),
            mod_Page::OneOfdata::advertisement(ref m) => 1 + sizeof_len((m).get_size()),
            mod_Page::OneOfdata::None => 0,
    }    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        match self.data {            mod_Page::OneOfdata::manga_page(ref m) => { w.write_with_tag(10, |w| w.write_message(m))? },
            mod_Page::OneOfdata::banner_list(ref m) => { w.write_with_tag(18, |w| w.write_message(m))? },
            mod_Page::OneOfdata::last_page(ref m) => { w.write_with_tag(26, |w| w.write_message(m))? },
            mod_Page::OneOfdata::advertisement(ref m) => { w.write_with_tag(34, |w| w.write_message(m))? },
            mod_Page::OneOfdata::None => {},
    }        Ok(())
    }
}

pub mod mod_Page {

use super::*;

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct BannerList {
    pub banner_title: String,
    pub banners: Vec<Banner>,
}

impl<'a> MessageRead<'a> for BannerList {
    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.banner_title = r.read_string(bytes)?.to_owned(),
                Ok(18) => msg.banners.push(r.read_message::<Banner>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for BannerList {
    fn get_size(&self) -> usize {
        0
        + if self.banner_title == String::default() { 0 } else { 1 + sizeof_len((&self.banner_title).len()) }
        + self.banners.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.banner_title != String::default() { w.write_with_tag(10, |w| w.write_string(&**&self.banner_title))?; }
        for s in &self.banners { w.write_with_tag(18, |w| w.write_message(s))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct MangaPage {
    pub image_url: String,
    pub width: u32,
    pub height: u32,
    pub type_pb: mod_Page::PageType,
    pub encryption_key: String,
}

impl<'a> MessageRead<'a> for MangaPage {
    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)?.to_owned(),
                Ok(16) => msg.width = r.read_uint32(bytes)?,
                Ok(24) => msg.height = r.read_uint32(bytes)?,
                Ok(32) => msg.type_pb = r.read_enum(bytes)?,
                Ok(42) => msg.encryption_key = r.read_string(bytes)?.to_owned(),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for MangaPage {
    fn get_size(&self) -> usize {
        0
        + if self.image_url == String::default() { 0 } else { 1 + sizeof_len((&self.image_url).len()) }
        + if self.width == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.width) as u64) }
        + if self.height == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.height) as u64) }
        + if self.type_pb == reader::mod_Page::PageType::SINGLE { 0 } else { 1 + sizeof_varint(*(&self.type_pb) as u64) }
        + if self.encryption_key == String::default() { 0 } else { 1 + sizeof_len((&self.encryption_key).len()) }
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.image_url != String::default() { w.write_with_tag(10, |w| w.write_string(&**&self.image_url))?; }
        if self.width != 0u32 { w.write_with_tag(16, |w| w.write_uint32(*&self.width))?; }
        if self.height != 0u32 { w.write_with_tag(24, |w| w.write_uint32(*&self.height))?; }
        if self.type_pb != reader::mod_Page::PageType::SINGLE { w.write_with_tag(32, |w| w.write_enum(*&self.type_pb as i32))?; }
        if self.encryption_key != String::default() { w.write_with_tag(42, |w| w.write_string(&**&self.encryption_key))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct LastPage {
    pub current_chapter: Option<Chapter>,
    pub next_chapter: Option<Chapter>,
    pub top_comments: Vec<Comment>,
    pub is_subscribed: bool,
    pub next_time_stamp: u32,
    pub chapter_type: i32,
}

impl<'a> MessageRead<'a> for LastPage {
    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.top_comments.push(r.read_message::<Comment>(bytes)?),
                Ok(32) => msg.is_subscribed = r.read_bool(bytes)?,
                Ok(40) => msg.next_time_stamp = r.read_uint32(bytes)?,
                Ok(48) => msg.chapter_type = r.read_int32(bytes)?,
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for LastPage {
    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.top_comments.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
        + if self.is_subscribed == false { 0 } else { 1 + sizeof_varint(*(&self.is_subscribed) as u64) }
        + if self.next_time_stamp == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.next_time_stamp) as u64) }
        + if self.chapter_type == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.chapter_type) as u64) }
    }

    fn write_message<W: WriterBackend>(&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))?; }
        for s in &self.top_comments { w.write_with_tag(26, |w| w.write_message(s))?; }
        if self.is_subscribed != false { w.write_with_tag(32, |w| w.write_bool(*&self.is_subscribed))?; }
        if self.next_time_stamp != 0u32 { w.write_with_tag(40, |w| w.write_uint32(*&self.next_time_stamp))?; }
        if self.chapter_type != 0i32 { w.write_with_tag(48, |w| w.write_int32(*&self.chapter_type))?; }
        Ok(())
    }
}


use super::*;#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[derive(Serialize, Deserialize)]
pub enum PageType {
    SINGLE = 0,
    LEFT = 1,
    RIGHT = 2,
    DOUBLE = 3,
}

impl Default for PageType {
    fn default() -> Self {
        PageType::SINGLE
    }
}

impl From<i32> for PageType {
    fn from(i: i32) -> Self {
        match i {
            0 => PageType::SINGLE,
            1 => PageType::LEFT,
            2 => PageType::RIGHT,
            3 => PageType::DOUBLE,
            _ => Self::default(),
        }
    }
}

impl<'a> From<&'a str> for PageType {
    fn from(s: &'a str) -> Self {
        match s {
            "SINGLE" => PageType::SINGLE,
            "LEFT" => PageType::LEFT,
            "RIGHT" => PageType::RIGHT,
            "DOUBLE" => PageType::DOUBLE,
            _ => Self::default(),
        }
    }
}


use super::*;#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[derive(Serialize, Deserialize)]
pub enum ChapterType {
    LATEST = 0,
    SEQUENCE = 1,
    NOSEQUENCE = 2,
}

impl Default for ChapterType {
    fn default() -> Self {
        ChapterType::LATEST
    }
}

impl From<i32> for ChapterType {
    fn from(i: i32) -> Self {
        match i {
            0 => ChapterType::LATEST,
            1 => ChapterType::SEQUENCE,
            2 => ChapterType::NOSEQUENCE,
            _ => Self::default(),
        }
    }
}

impl<'a> From<&'a str> for ChapterType {
    fn from(s: &'a str) -> Self {
        match s {
            "LATEST" => ChapterType::LATEST,
            "SEQUENCE" => ChapterType::SEQUENCE,
            "NOSEQUENCE" => ChapterType::NOSEQUENCE,
            _ => Self::default(),
        }
    }
}

#[derive(Debug, PartialEq, Clone)]
#[derive(Serialize, Deserialize)]
pub enum OneOfdata {
    manga_page(mod_Page::MangaPage),
    banner_list(mod_Page::BannerList),
    last_page(mod_Page::LastPage),
    advertisement(AdNetworkList),
    None,
}

impl Default for OneOfdata {
    fn default() -> Self {
        OneOfdata::None
    }
}

}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct MangaViewer {
    pub pages: Vec<Page>,
    pub chapter_id: u32,
    pub chapters: Vec<Chapter>,
    pub sns: Option<Sns>,
    pub title_name: String,
    pub chapter_name: String,
    pub number_of_comments: i32,
    pub is_vertical_only: bool,
    pub title_id: u32,
    pub start_from_right: bool,
}

impl<'a> MessageRead<'a> for MangaViewer {
    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::<Page>(bytes)?),
                Ok(16) => msg.chapter_id = r.read_uint32(bytes)?,
                Ok(26) => msg.chapters.push(r.read_message::<Chapter>(bytes)?),
                Ok(34) => msg.sns = Some(r.read_message::<Sns>(bytes)?),
                Ok(42) => msg.title_name = r.read_string(bytes)?.to_owned(),
                Ok(50) => msg.chapter_name = r.read_string(bytes)?.to_owned(),
                Ok(56) => msg.number_of_comments = r.read_int32(bytes)?,
                Ok(64) => msg.is_vertical_only = r.read_bool(bytes)?,
                Ok(72) => msg.title_id = r.read_uint32(bytes)?,
                Ok(80) => msg.start_from_right = r.read_bool(bytes)?,
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for MangaViewer {
    fn get_size(&self) -> usize {
        0
        + self.pages.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
        + if self.chapter_id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.chapter_id) as u64) }
        + self.chapters.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
        + self.sns.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
        + if self.title_name == String::default() { 0 } else { 1 + sizeof_len((&self.title_name).len()) }
        + if self.chapter_name == String::default() { 0 } else { 1 + sizeof_len((&self.chapter_name).len()) }
        + if self.number_of_comments == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.number_of_comments) as u64) }
        + if self.is_vertical_only == false { 0 } else { 1 + sizeof_varint(*(&self.is_vertical_only) as u64) }
        + if self.title_id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.title_id) as u64) }
        + if self.start_from_right == false { 0 } else { 1 + sizeof_varint(*(&self.start_from_right) as u64) }
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        for s in &self.pages { w.write_with_tag(10, |w| w.write_message(s))?; }
        if self.chapter_id != 0u32 { w.write_with_tag(16, |w| w.write_uint32(*&self.chapter_id))?; }
        for s in &self.chapters { 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.title_name != String::default() { w.write_with_tag(42, |w| w.write_string(&**&self.title_name))?; }
        if self.chapter_name != String::default() { w.write_with_tag(50, |w| w.write_string(&**&self.chapter_name))?; }
        if self.number_of_comments != 0i32 { w.write_with_tag(56, |w| w.write_int32(*&self.number_of_comments))?; }
        if self.is_vertical_only != false { w.write_with_tag(64, |w| w.write_bool(*&self.is_vertical_only))?; }
        if self.title_id != 0u32 { w.write_with_tag(72, |w| w.write_uint32(*&self.title_id))?; }
        if self.start_from_right != false { w.write_with_tag(80, |w| w.write_bool(*&self.start_from_right))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct Title {
    pub title_id: u32,
    pub name: String,
    pub author: String,
    pub portait_image_url: String,
    pub landscape_image_url: String,
    pub view_count: u32,
    pub language: mod_Title::Language,
}

impl<'a> MessageRead<'a> for Title {
    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.name = r.read_string(bytes)?.to_owned(),
                Ok(26) => msg.author = r.read_string(bytes)?.to_owned(),
                Ok(34) => msg.portait_image_url = r.read_string(bytes)?.to_owned(),
                Ok(42) => msg.landscape_image_url = r.read_string(bytes)?.to_owned(),
                Ok(48) => msg.view_count = r.read_uint32(bytes)?,
                Ok(56) => msg.language = r.read_enum(bytes)?,
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for Title {
    fn get_size(&self) -> usize {
        0
        + if self.title_id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.title_id) as u64) }
        + if self.name == String::default() { 0 } else { 1 + sizeof_len((&self.name).len()) }
        + if self.author == String::default() { 0 } else { 1 + sizeof_len((&self.author).len()) }
        + if self.portait_image_url == String::default() { 0 } else { 1 + sizeof_len((&self.portait_image_url).len()) }
        + if self.landscape_image_url == String::default() { 0 } else { 1 + sizeof_len((&self.landscape_image_url).len()) }
        + if self.view_count == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.view_count) as u64) }
        + if self.language == reader::mod_Title::Language::ENGLISH { 0 } else { 1 + sizeof_varint(*(&self.language) as u64) }
    }

    fn write_message<W: WriterBackend>(&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.name != String::default() { w.write_with_tag(18, |w| w.write_string(&**&self.name))?; }
        if self.author != String::default() { w.write_with_tag(26, |w| w.write_string(&**&self.author))?; }
        if self.portait_image_url != String::default() { w.write_with_tag(34, |w| w.write_string(&**&self.portait_image_url))?; }
        if self.landscape_image_url != String::default() { w.write_with_tag(42, |w| w.write_string(&**&self.landscape_image_url))?; }
        if self.view_count != 0u32 { w.write_with_tag(48, |w| w.write_uint32(*&self.view_count))?; }
        if self.language != reader::mod_Title::Language::ENGLISH { w.write_with_tag(56, |w| w.write_enum(*&self.language as i32))?; }
        Ok(())
    }
}

pub mod mod_Title {



use super::*;#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[derive(Serialize, Deserialize)]
pub enum Language {
    ENGLISH = 0,
    SPANISH = 1,
}

impl Default for Language {
    fn default() -> Self {
        Language::ENGLISH
    }
}

impl From<i32> for Language {
    fn from(i: i32) -> Self {
        match i {
            0 => Language::ENGLISH,
            1 => Language::SPANISH,
            _ => Self::default(),
        }
    }
}

impl<'a> From<&'a str> for Language {
    fn from(s: &'a str) -> Self {
        match s {
            "ENGLISH" => Language::ENGLISH,
            "SPANISH" => Language::SPANISH,
            _ => Self::default(),
        }
    }
}

}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct TitleDetailView {
    pub title: Option<Title>,
    pub title_image_url: String,
    pub overview: String,
    pub background_image_url: String,
    pub next_time_stamp: u32,
    pub update_timing: mod_TitleDetailView::UpdateTiming,
    pub viewing_period_description: String,
    pub non_appearance_info: String,
    pub first_chapter_list: Vec<Chapter>,
    pub last_chapter_list: Vec<Chapter>,
    pub banners: Vec<Banner>,
    pub recommended_title_list: Vec<Title>,
    pub sns: Option<Sns>,
    pub is_simul_released: bool,
    pub is_subscribed: bool,
    pub rating: mod_TitleDetailView::Rating,
    pub chapters_descending: bool,
    pub number_of_views: u32,
}

impl<'a> MessageRead<'a> for TitleDetailView {
    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.title_image_url = r.read_string(bytes)?.to_owned(),
                Ok(26) => msg.overview = r.read_string(bytes)?.to_owned(),
                Ok(34) => msg.background_image_url = r.read_string(bytes)?.to_owned(),
                Ok(40) => msg.next_time_stamp = r.read_uint32(bytes)?,
                Ok(48) => msg.update_timing = r.read_enum(bytes)?,
                Ok(58) => msg.viewing_period_description = r.read_string(bytes)?.to_owned(),
                Ok(66) => msg.non_appearance_info = r.read_string(bytes)?.to_owned(),
                Ok(74) => msg.first_chapter_list.push(r.read_message::<Chapter>(bytes)?),
                Ok(82) => msg.last_chapter_list.push(r.read_message::<Chapter>(bytes)?),
                Ok(90) => msg.banners.push(r.read_message::<Banner>(bytes)?),
                Ok(98) => msg.recommended_title_list.push(r.read_message::<Title>(bytes)?),
                Ok(106) => msg.sns = Some(r.read_message::<Sns>(bytes)?),
                Ok(112) => msg.is_simul_released = r.read_bool(bytes)?,
                Ok(120) => msg.is_subscribed = r.read_bool(bytes)?,
                Ok(128) => msg.rating = r.read_enum(bytes)?,
                Ok(136) => msg.chapters_descending = r.read_bool(bytes)?,
                Ok(144) => msg.number_of_views = r.read_uint32(bytes)?,
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for TitleDetailView {
    fn get_size(&self) -> usize {
        0
        + self.title.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
        + if self.title_image_url == String::default() { 0 } else { 1 + sizeof_len((&self.title_image_url).len()) }
        + if self.overview == String::default() { 0 } else { 1 + sizeof_len((&self.overview).len()) }
        + if self.background_image_url == String::default() { 0 } else { 1 + sizeof_len((&self.background_image_url).len()) }
        + if self.next_time_stamp == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.next_time_stamp) as u64) }
        + if self.update_timing == reader::mod_TitleDetailView::UpdateTiming::NOT_REGULARLY { 0 } else { 1 + sizeof_varint(*(&self.update_timing) as u64) }
        + if self.viewing_period_description == String::default() { 0 } else { 1 + sizeof_len((&self.viewing_period_description).len()) }
        + if self.non_appearance_info == String::default() { 0 } else { 1 + sizeof_len((&self.non_appearance_info).len()) }
        + self.first_chapter_list.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
        + self.last_chapter_list.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
        + self.banners.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
        + self.recommended_title_list.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
        + self.sns.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
        + if self.is_simul_released == false { 0 } else { 1 + sizeof_varint(*(&self.is_simul_released) as u64) }
        + if self.is_subscribed == false { 0 } else { 1 + sizeof_varint(*(&self.is_subscribed) as u64) }
        + if self.rating == reader::mod_TitleDetailView::Rating::ALLAGE { 0 } else { 2 + sizeof_varint(*(&self.rating) as u64) }
        + if self.chapters_descending == false { 0 } else { 2 + sizeof_varint(*(&self.chapters_descending) as u64) }
        + if self.number_of_views == 0u32 { 0 } else { 2 + sizeof_varint(*(&self.number_of_views) as u64) }
    }

    fn write_message<W: WriterBackend>(&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.title_image_url != String::default() { w.write_with_tag(18, |w| w.write_string(&**&self.title_image_url))?; }
        if self.overview != String::default() { w.write_with_tag(26, |w| w.write_string(&**&self.overview))?; }
        if self.background_image_url != String::default() { w.write_with_tag(34, |w| w.write_string(&**&self.background_image_url))?; }
        if self.next_time_stamp != 0u32 { w.write_with_tag(40, |w| w.write_uint32(*&self.next_time_stamp))?; }
        if self.update_timing != reader::mod_TitleDetailView::UpdateTiming::NOT_REGULARLY { w.write_with_tag(48, |w| w.write_enum(*&self.update_timing as i32))?; }
        if self.viewing_period_description != String::default() { w.write_with_tag(58, |w| w.write_string(&**&self.viewing_period_description))?; }
        if self.non_appearance_info != String::default() { w.write_with_tag(66, |w| w.write_string(&**&self.non_appearance_info))?; }
        for s in &self.first_chapter_list { w.write_with_tag(74, |w| w.write_message(s))?; }
        for s in &self.last_chapter_list { w.write_with_tag(82, |w| w.write_message(s))?; }
        for s in &self.banners { w.write_with_tag(90, |w| w.write_message(s))?; }
        for s in &self.recommended_title_list { w.write_with_tag(98, |w| w.write_message(s))?; }
        if let Some(ref s) = self.sns { w.write_with_tag(106, |w| w.write_message(s))?; }
        if self.is_simul_released != false { w.write_with_tag(112, |w| w.write_bool(*&self.is_simul_released))?; }
        if self.is_subscribed != false { w.write_with_tag(120, |w| w.write_bool(*&self.is_subscribed))?; }
        if self.rating != reader::mod_TitleDetailView::Rating::ALLAGE { w.write_with_tag(128, |w| w.write_enum(*&self.rating as i32))?; }
        if self.chapters_descending != false { w.write_with_tag(136, |w| w.write_bool(*&self.chapters_descending))?; }
        if self.number_of_views != 0u32 { w.write_with_tag(144, |w| w.write_uint32(*&self.number_of_views))?; }
        Ok(())
    }
}

pub mod mod_TitleDetailView {



use super::*;#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[derive(Serialize, Deserialize)]
pub enum Rating {
    ALLAGE = 0,
    TEEN = 1,
    TEENPLUS = 2,
    MATURE = 3,
}

impl Default for Rating {
    fn default() -> Self {
        Rating::ALLAGE
    }
}

impl From<i32> for Rating {
    fn from(i: i32) -> Self {
        match i {
            0 => Rating::ALLAGE,
            1 => Rating::TEEN,
            2 => Rating::TEENPLUS,
            3 => Rating::MATURE,
            _ => Self::default(),
        }
    }
}

impl<'a> From<&'a str> for Rating {
    fn from(s: &'a str) -> Self {
        match s {
            "ALLAGE" => Rating::ALLAGE,
            "TEEN" => Rating::TEEN,
            "TEENPLUS" => Rating::TEENPLUS,
            "MATURE" => Rating::MATURE,
            _ => Self::default(),
        }
    }
}


use super::*;#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[derive(Serialize, Deserialize)]
pub enum UpdateTiming {
    NOT_REGULARLY = 0,
    MONDAY = 1,
    TUESDAY = 2,
    WEDNESDAY = 3,
    THURSDAY = 4,
    FRIDAY = 5,
    SATURDAY = 6,
    SUNDAY = 7,
    DAY = 8,
}

impl Default for UpdateTiming {
    fn default() -> Self {
        UpdateTiming::NOT_REGULARLY
    }
}

impl From<i32> for UpdateTiming {
    fn from(i: i32) -> Self {
        match i {
            0 => UpdateTiming::NOT_REGULARLY,
            1 => UpdateTiming::MONDAY,
            2 => UpdateTiming::TUESDAY,
            3 => UpdateTiming::WEDNESDAY,
            4 => UpdateTiming::THURSDAY,
            5 => UpdateTiming::FRIDAY,
            6 => UpdateTiming::SATURDAY,
            7 => UpdateTiming::SUNDAY,
            8 => UpdateTiming::DAY,
            _ => Self::default(),
        }
    }
}

impl<'a> From<&'a str> for UpdateTiming {
    fn from(s: &'a str) -> Self {
        match s {
            "NOT_REGULARLY" => UpdateTiming::NOT_REGULARLY,
            "MONDAY" => UpdateTiming::MONDAY,
            "TUESDAY" => UpdateTiming::TUESDAY,
            "WEDNESDAY" => UpdateTiming::WEDNESDAY,
            "THURSDAY" => UpdateTiming::THURSDAY,
            "FRIDAY" => UpdateTiming::FRIDAY,
            "SATURDAY" => UpdateTiming::SATURDAY,
            "SUNDAY" => UpdateTiming::SUNDAY,
            "DAY" => UpdateTiming::DAY,
            _ => Self::default(),
        }
    }
}

}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct UpdatedTitle {
    pub title: Option<Title>,
    pub chapter_id: u32,
    pub chapter_name: String,
    pub chapter_sub_title: String,
    pub is_latest: bool,
    pub is_vertical_only: bool,
}

impl<'a> MessageRead<'a> for UpdatedTitle {
    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(16) => msg.chapter_id = r.read_uint32(bytes)?,
                Ok(26) => msg.chapter_name = r.read_string(bytes)?.to_owned(),
                Ok(34) => msg.chapter_sub_title = r.read_string(bytes)?.to_owned(),
                Ok(40) => msg.is_latest = r.read_bool(bytes)?,
                Ok(48) => msg.is_vertical_only = r.read_bool(bytes)?,
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for UpdatedTitle {
    fn get_size(&self) -> usize {
        0
        + self.title.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
        + if self.chapter_id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.chapter_id) as u64) }
        + if self.chapter_name == String::default() { 0 } else { 1 + sizeof_len((&self.chapter_name).len()) }
        + if self.chapter_sub_title == String::default() { 0 } else { 1 + sizeof_len((&self.chapter_sub_title).len()) }
        + if self.is_latest == false { 0 } else { 1 + sizeof_varint(*(&self.is_latest) as u64) }
        + if self.is_vertical_only == false { 0 } else { 1 + sizeof_varint(*(&self.is_vertical_only) as u64) }
    }

    fn write_message<W: WriterBackend>(&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.chapter_id != 0u32 { w.write_with_tag(16, |w| w.write_uint32(*&self.chapter_id))?; }
        if self.chapter_name != String::default() { w.write_with_tag(26, |w| w.write_string(&**&self.chapter_name))?; }
        if self.chapter_sub_title != String::default() { w.write_with_tag(34, |w| w.write_string(&**&self.chapter_sub_title))?; }
        if self.is_latest != false { w.write_with_tag(40, |w| w.write_bool(*&self.is_latest))?; }
        if self.is_vertical_only != false { w.write_with_tag(48, |w| w.write_bool(*&self.is_vertical_only))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct UpdateProfileResultView {
    pub result: mod_UpdateProfileResultView::UpdateResult,
}

impl<'a> MessageRead<'a> for UpdateProfileResultView {
    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.result = r.read_enum(bytes)?,
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for UpdateProfileResultView {
    fn get_size(&self) -> usize {
        0
        + if self.result == reader::mod_UpdateProfileResultView::UpdateResult::SUCCESS { 0 } else { 1 + sizeof_varint(*(&self.result) as u64) }
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.result != reader::mod_UpdateProfileResultView::UpdateResult::SUCCESS { w.write_with_tag(8, |w| w.write_enum(*&self.result as i32))?; }
        Ok(())
    }
}

pub mod mod_UpdateProfileResultView {



use super::*;#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[derive(Serialize, Deserialize)]
pub enum UpdateResult {
    SUCCESS = 0,
    DUPLICATED = 1,
    NG_WORD = 2,
}

impl Default for UpdateResult {
    fn default() -> Self {
        UpdateResult::SUCCESS
    }
}

impl From<i32> for UpdateResult {
    fn from(i: i32) -> Self {
        match i {
            0 => UpdateResult::SUCCESS,
            1 => UpdateResult::DUPLICATED,
            2 => UpdateResult::NG_WORD,
            _ => Self::default(),
        }
    }
}

impl<'a> From<&'a str> for UpdateResult {
    fn from(s: &'a str) -> Self {
        match s {
            "SUCCESS" => UpdateResult::SUCCESS,
            "DUPLICATED" => UpdateResult::DUPLICATED,
            "NG_WORD" => UpdateResult::NG_WORD,
            _ => Self::default(),
        }
    }
}

}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct UpdatedTitleGroup {
    pub group_name: String,
    pub titles: Vec<UpdatedTitle>,
}

impl<'a> MessageRead<'a> for UpdatedTitleGroup {
    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.group_name = r.read_string(bytes)?.to_owned(),
                Ok(18) => msg.titles.push(r.read_message::<UpdatedTitle>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for UpdatedTitleGroup {
    fn get_size(&self) -> usize {
        0
        + if self.group_name == String::default() { 0 } else { 1 + sizeof_len((&self.group_name).len()) }
        + self.titles.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.group_name != String::default() { w.write_with_tag(10, |w| w.write_string(&**&self.group_name))?; }
        for s in &self.titles { w.write_with_tag(18, |w| w.write_message(s))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct TransitionAction {
    pub method: mod_TransitionAction::PresentationMethod,
    pub url: String,
}

impl<'a> MessageRead<'a> for TransitionAction {
    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.method = r.read_enum(bytes)?,
                Ok(18) => msg.url = r.read_string(bytes)?.to_owned(),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for TransitionAction {
    fn get_size(&self) -> usize {
        0
        + if self.method == reader::mod_TransitionAction::PresentationMethod::PUSH { 0 } else { 1 + sizeof_varint(*(&self.method) as u64) }
        + if self.url == String::default() { 0 } else { 1 + sizeof_len((&self.url).len()) }
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.method != reader::mod_TransitionAction::PresentationMethod::PUSH { w.write_with_tag(8, |w| w.write_enum(*&self.method as i32))?; }
        if self.url != String::default() { w.write_with_tag(18, |w| w.write_string(&**&self.url))?; }
        Ok(())
    }
}

pub mod mod_TransitionAction {



use super::*;#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[derive(Serialize, Deserialize)]
pub enum PresentationMethod {
    PUSH = 0,
    MODAL = 1,
    EXTERNAL = 2,
}

impl Default for PresentationMethod {
    fn default() -> Self {
        PresentationMethod::PUSH
    }
}

impl From<i32> for PresentationMethod {
    fn from(i: i32) -> Self {
        match i {
            0 => PresentationMethod::PUSH,
            1 => PresentationMethod::MODAL,
            2 => PresentationMethod::EXTERNAL,
            _ => Self::default(),
        }
    }
}

impl<'a> From<&'a str> for PresentationMethod {
    fn from(s: &'a str) -> Self {
        match s {
            "PUSH" => PresentationMethod::PUSH,
            "MODAL" => PresentationMethod::MODAL,
            "EXTERNAL" => PresentationMethod::EXTERNAL,
            _ => Self::default(),
        }
    }
}

}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct Banner {
    pub image_url: String,
    pub action: Option<TransitionAction>,
    pub id: u32,
}

impl<'a> MessageRead<'a> for Banner {
    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)?.to_owned(),
                Ok(18) => msg.action = Some(r.read_message::<TransitionAction>(bytes)?),
                Ok(24) => msg.id = r.read_uint32(bytes)?,
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for Banner {
    fn get_size(&self) -> usize {
        0
        + if self.image_url == String::default() { 0 } else { 1 + sizeof_len((&self.image_url).len()) }
        + self.action.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
        + if self.id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.id) as u64) }
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.image_url != String::default() { w.write_with_tag(10, |w| w.write_string(&**&self.image_url))?; }
        if let Some(ref s) = self.action { w.write_with_tag(18, |w| w.write_message(s))?; }
        if self.id != 0u32 { w.write_with_tag(24, |w| w.write_uint32(*&self.id))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct WebHomeView {
    pub top_banners: Vec<Banner>,
    pub groups: Vec<UpdatedTitleGroup>,
    pub ranking: Vec<Title>,
}

impl<'a> MessageRead<'a> for WebHomeView {
    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.groups.push(r.read_message::<UpdatedTitleGroup>(bytes)?),
                Ok(26) => msg.ranking.push(r.read_message::<Title>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for WebHomeView {
    fn get_size(&self) -> usize {
        0
        + self.top_banners.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
        + self.groups.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
        + self.ranking.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
    }

    fn write_message<W: WriterBackend>(&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.groups { w.write_with_tag(18, |w| w.write_message(s))?; }
        for s in &self.ranking { w.write_with_tag(26, |w| w.write_message(s))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct TitleList {
    pub listName: String,
    pub featured_titles: Vec<Title>,
}

impl<'a> MessageRead<'a> for TitleList {
    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.listName = r.read_string(bytes)?.to_owned(),
                Ok(18) => msg.featured_titles.push(r.read_message::<Title>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for TitleList {
    fn get_size(&self) -> usize {
        0
        + if self.listName == String::default() { 0 } else { 1 + sizeof_len((&self.listName).len()) }
        + self.featured_titles.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.listName != String::default() { w.write_with_tag(10, |w| w.write_string(&**&self.listName))?; }
        for s in &self.featured_titles { w.write_with_tag(18, |w| w.write_message(s))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct FeaturedTitlesView {
    pub main_banner: Option<Banner>,
    pub sub_banner_1: Option<Banner>,
    pub sub_banner_2: Option<Banner>,
    pub contents: Vec<mod_FeaturedTitlesView::Contents>,
}

impl<'a> MessageRead<'a> for FeaturedTitlesView {
    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.main_banner = Some(r.read_message::<Banner>(bytes)?),
                Ok(18) => msg.sub_banner_1 = Some(r.read_message::<Banner>(bytes)?),
                Ok(26) => msg.sub_banner_2 = Some(r.read_message::<Banner>(bytes)?),
                Ok(34) => msg.contents.push(r.read_message::<mod_FeaturedTitlesView::Contents>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for FeaturedTitlesView {
    fn get_size(&self) -> usize {
        0
        + self.main_banner.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
        + self.sub_banner_1.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
        + self.sub_banner_2.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
        + self.contents.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if let Some(ref s) = self.main_banner { w.write_with_tag(10, |w| w.write_message(s))?; }
        if let Some(ref s) = self.sub_banner_1 { w.write_with_tag(18, |w| w.write_message(s))?; }
        if let Some(ref s) = self.sub_banner_2 { w.write_with_tag(26, |w| w.write_message(s))?; }
        for s in &self.contents { w.write_with_tag(34, |w| w.write_message(s))?; }
        Ok(())
    }
}

pub mod mod_FeaturedTitlesView {

use super::*;

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct Contents {
    pub data: mod_FeaturedTitlesView::mod_Contents::OneOfdata,
}

impl<'a> MessageRead<'a> for Contents {
    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.data = mod_FeaturedTitlesView::mod_Contents::OneOfdata::banner(r.read_message::<Banner>(bytes)?),
                Ok(18) => msg.data = mod_FeaturedTitlesView::mod_Contents::OneOfdata::title_list(r.read_message::<TitleList>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for Contents {
    fn get_size(&self) -> usize {
        0
        + match self.data {
            mod_FeaturedTitlesView::mod_Contents::OneOfdata::banner(ref m) => 1 + sizeof_len((m).get_size()),
            mod_FeaturedTitlesView::mod_Contents::OneOfdata::title_list(ref m) => 1 + sizeof_len((m).get_size()),
            mod_FeaturedTitlesView::mod_Contents::OneOfdata::None => 0,
    }    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        match self.data {            mod_FeaturedTitlesView::mod_Contents::OneOfdata::banner(ref m) => { w.write_with_tag(10, |w| w.write_message(m))? },
            mod_FeaturedTitlesView::mod_Contents::OneOfdata::title_list(ref m) => { w.write_with_tag(18, |w| w.write_message(m))? },
            mod_FeaturedTitlesView::mod_Contents::OneOfdata::None => {},
    }        Ok(())
    }
}

pub mod mod_Contents {

use super::*;

#[derive(Debug, PartialEq, Clone)]
#[derive(Serialize, Deserialize)]
pub enum OneOfdata {
    banner(Banner),
    title_list(TitleList),
    None,
}

impl Default for OneOfdata {
    fn default() -> Self {
        OneOfdata::None
    }
}

}

}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct ProfileSettingsView {
    pub icon_list: Vec<CommentIcon>,
    pub user_name: String,
    pub my_icon: Option<CommentIcon>,
}

impl<'a> MessageRead<'a> for ProfileSettingsView {
    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.icon_list.push(r.read_message::<CommentIcon>(bytes)?),
                Ok(18) => msg.user_name = r.read_string(bytes)?.to_owned(),
                Ok(26) => msg.my_icon = Some(r.read_message::<CommentIcon>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for ProfileSettingsView {
    fn get_size(&self) -> usize {
        0
        + self.icon_list.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
        + if self.user_name == String::default() { 0 } else { 1 + sizeof_len((&self.user_name).len()) }
        + self.my_icon.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        for s in &self.icon_list { w.write_with_tag(10, |w| w.write_message(s))?; }
        if self.user_name != String::default() { w.write_with_tag(18, |w| w.write_string(&**&self.user_name))?; }
        if let Some(ref s) = self.my_icon { w.write_with_tag(26, |w| w.write_message(s))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct Comment {
    pub id: u32,
    pub index: u32,
    pub user_name: String,
    pub icon_url: String,
    pub is_my_comment: bool,
    pub already_liked: bool,
    pub number_of_likes: u32,
    pub body: String,
    pub created: u32,
}

impl<'a> MessageRead<'a> for Comment {
    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(26) => msg.user_name = r.read_string(bytes)?.to_owned(),
                Ok(34) => msg.icon_url = r.read_string(bytes)?.to_owned(),
                Ok(48) => msg.is_my_comment = r.read_bool(bytes)?,
                Ok(56) => msg.already_liked = r.read_bool(bytes)?,
                Ok(72) => msg.number_of_likes = r.read_uint32(bytes)?,
                Ok(82) => msg.body = r.read_string(bytes)?.to_owned(),
                Ok(88) => msg.created = r.read_uint32(bytes)?,
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for Comment {
    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.user_name == String::default() { 0 } else { 1 + sizeof_len((&self.user_name).len()) }
        + if self.icon_url == String::default() { 0 } else { 1 + sizeof_len((&self.icon_url).len()) }
        + 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 == String::default() { 0 } else { 1 + sizeof_len((&self.body).len()) }
        + if self.created == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.created) as u64) }
    }

    fn write_message<W: WriterBackend>(&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.user_name != String::default() { w.write_with_tag(26, |w| w.write_string(&**&self.user_name))?; }
        if self.icon_url != String::default() { w.write_with_tag(34, |w| w.write_string(&**&self.icon_url))?; }
        if self.is_my_comment != false { w.write_with_tag(48, |w| w.write_bool(*&self.is_my_comment))?; }
        if self.already_liked != false { w.write_with_tag(56, |w| w.write_bool(*&self.already_liked))?; }
        if self.number_of_likes != 0u32 { w.write_with_tag(72, |w| w.write_uint32(*&self.number_of_likes))?; }
        if self.body != String::default() { w.write_with_tag(82, |w| w.write_string(&**&self.body))?; }
        if self.created != 0u32 { w.write_with_tag(88, |w| w.write_uint32(*&self.created))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct CommentIcon {
    pub id: u32,
    pub image_url: String,
}

impl<'a> MessageRead<'a> for CommentIcon {
    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)?.to_owned(),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for CommentIcon {
    fn get_size(&self) -> usize {
        0
        + if self.id == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.id) as u64) }
        + if self.image_url == String::default() { 0 } else { 1 + sizeof_len((&self.image_url).len()) }
    }

    fn write_message<W: WriterBackend>(&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 != String::default() { w.write_with_tag(18, |w| w.write_string(&**&self.image_url))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct CommentListView {
    pub comments: Vec<Comment>,
    pub if_set_user_name: bool,
}

impl<'a> MessageRead<'a> for CommentListView {
    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(16) => msg.if_set_user_name = r.read_bool(bytes)?,
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for CommentListView {
    fn get_size(&self) -> usize {
        0
        + self.comments.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
        + if self.if_set_user_name == false { 0 } else { 1 + sizeof_varint(*(&self.if_set_user_name) as u64) }
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        for s in &self.comments { w.write_with_tag(10, |w| w.write_message(s))?; }
        if self.if_set_user_name != false { w.write_with_tag(16, |w| w.write_bool(*&self.if_set_user_name))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct InitialView {
    pub gdpr_agreement_required: bool,
    pub english_titles_count: u32,
    pub spanish_titles_count: u32,
}

impl<'a> MessageRead<'a> for InitialView {
    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.gdpr_agreement_required = r.read_bool(bytes)?,
                Ok(16) => msg.english_titles_count = r.read_uint32(bytes)?,
                Ok(24) => msg.spanish_titles_count = r.read_uint32(bytes)?,
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for InitialView {
    fn get_size(&self) -> usize {
        0
        + if self.gdpr_agreement_required == false { 0 } else { 1 + sizeof_varint(*(&self.gdpr_agreement_required) as u64) }
        + if self.english_titles_count == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.english_titles_count) as u64) }
        + if self.spanish_titles_count == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.spanish_titles_count) as u64) }
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.gdpr_agreement_required != false { w.write_with_tag(8, |w| w.write_bool(*&self.gdpr_agreement_required))?; }
        if self.english_titles_count != 0u32 { w.write_with_tag(16, |w| w.write_uint32(*&self.english_titles_count))?; }
        if self.spanish_titles_count != 0u32 { w.write_with_tag(24, |w| w.write_uint32(*&self.spanish_titles_count))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct SettingsView {
    pub my_icon: Option<CommentIcon>,
    pub user_name: String,
    pub notice_of_news_and_events: bool,
    pub notice_of_updates_of_subscribed_titles: bool,
    pub english_titles_count: u32,
    pub spanish_titles_count: u32,
}

impl<'a> MessageRead<'a> for SettingsView {
    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.my_icon = Some(r.read_message::<CommentIcon>(bytes)?),
                Ok(18) => msg.user_name = r.read_string(bytes)?.to_owned(),
                Ok(24) => msg.notice_of_news_and_events = r.read_bool(bytes)?,
                Ok(32) => msg.notice_of_updates_of_subscribed_titles = r.read_bool(bytes)?,
                Ok(40) => msg.english_titles_count = r.read_uint32(bytes)?,
                Ok(48) => msg.spanish_titles_count = r.read_uint32(bytes)?,
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for SettingsView {
    fn get_size(&self) -> usize {
        0
        + self.my_icon.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
        + if self.user_name == String::default() { 0 } else { 1 + sizeof_len((&self.user_name).len()) }
        + if self.notice_of_news_and_events == false { 0 } else { 1 + sizeof_varint(*(&self.notice_of_news_and_events) as u64) }
        + if self.notice_of_updates_of_subscribed_titles == false { 0 } else { 1 + sizeof_varint(*(&self.notice_of_updates_of_subscribed_titles) as u64) }
        + if self.english_titles_count == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.english_titles_count) as u64) }
        + if self.spanish_titles_count == 0u32 { 0 } else { 1 + sizeof_varint(*(&self.spanish_titles_count) as u64) }
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if let Some(ref s) = self.my_icon { w.write_with_tag(10, |w| w.write_message(s))?; }
        if self.user_name != String::default() { w.write_with_tag(18, |w| w.write_string(&**&self.user_name))?; }
        if self.notice_of_news_and_events != false { w.write_with_tag(24, |w| w.write_bool(*&self.notice_of_news_and_events))?; }
        if self.notice_of_updates_of_subscribed_titles != false { w.write_with_tag(32, |w| w.write_bool(*&self.notice_of_updates_of_subscribed_titles))?; }
        if self.english_titles_count != 0u32 { w.write_with_tag(40, |w| w.write_uint32(*&self.english_titles_count))?; }
        if self.spanish_titles_count != 0u32 { w.write_with_tag(48, |w| w.write_uint32(*&self.spanish_titles_count))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct TitleRankingView {
    pub titles: Vec<Title>,
}

impl<'a> MessageRead<'a> for TitleRankingView {
    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.titles.push(r.read_message::<Title>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for TitleRankingView {
    fn get_size(&self) -> usize {
        0
        + self.titles.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        for s in &self.titles { w.write_with_tag(10, |w| w.write_message(s))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct AllTitlesView {
    pub titles: Vec<Title>,
}

impl<'a> MessageRead<'a> for AllTitlesView {
    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.titles.push(r.read_message::<Title>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for AllTitlesView {
    fn get_size(&self) -> usize {
        0
        + self.titles.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        for s in &self.titles { w.write_with_tag(10, |w| w.write_message(s))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct SubscribedTitlesView {
    pub titles: Vec<Title>,
}

impl<'a> MessageRead<'a> for SubscribedTitlesView {
    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.titles.push(r.read_message::<Title>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for SubscribedTitlesView {
    fn get_size(&self) -> usize {
        0
        + self.titles.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        for s in &self.titles { w.write_with_tag(10, |w| w.write_message(s))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct ServiceAnnouncement {
    pub title: String,
    pub body: String,
    pub date: i32,
}

impl<'a> MessageRead<'a> for ServiceAnnouncement {
    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 = r.read_string(bytes)?.to_owned(),
                Ok(18) => msg.body = r.read_string(bytes)?.to_owned(),
                Ok(24) => msg.date = r.read_int32(bytes)?,
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for ServiceAnnouncement {
    fn get_size(&self) -> usize {
        0
        + if self.title == String::default() { 0 } else { 1 + sizeof_len((&self.title).len()) }
        + if self.body == String::default() { 0 } else { 1 + sizeof_len((&self.body).len()) }
        + if self.date == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.date) as u64) }
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.title != String::default() { w.write_with_tag(10, |w| w.write_string(&**&self.title))?; }
        if self.body != String::default() { w.write_with_tag(18, |w| w.write_string(&**&self.body))?; }
        if self.date != 0i32 { w.write_with_tag(24, |w| w.write_int32(*&self.date))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct ServiceAnnouncementsView {
    pub service_announcements: Vec<ServiceAnnouncement>,
}

impl<'a> MessageRead<'a> for ServiceAnnouncementsView {
    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.service_announcements.push(r.read_message::<ServiceAnnouncement>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for ServiceAnnouncementsView {
    fn get_size(&self) -> usize {
        0
        + self.service_announcements.iter().map(|s| 1 + sizeof_len((s).get_size())).sum::<usize>()
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        for s in &self.service_announcements { w.write_with_tag(10, |w| w.write_message(s))?; }
        Ok(())
    }
}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct SuccessResult {
    pub is_featured_updated: bool,
    pub data: mod_SuccessResult::OneOfdata,
}

impl<'a> MessageRead<'a> for SuccessResult {
    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.is_featured_updated = r.read_bool(bytes)?,
                Ok(18) => msg.data = mod_SuccessResult::OneOfdata::registeration_data(r.read_message::<RegistrationData>(bytes)?),
                Ok(26) => msg.data = mod_SuccessResult::OneOfdata::home_view(r.read_message::<HomeView>(bytes)?),
                Ok(34) => msg.data = mod_SuccessResult::OneOfdata::featured_titles_view(r.read_message::<FeaturedTitlesView>(bytes)?),
                Ok(42) => msg.data = mod_SuccessResult::OneOfdata::all_titles_view(r.read_message::<AllTitlesView>(bytes)?),
                Ok(50) => msg.data = mod_SuccessResult::OneOfdata::title_ranking_view(r.read_message::<TitleRankingView>(bytes)?),
                Ok(58) => msg.data = mod_SuccessResult::OneOfdata::subscribed_titles_view(r.read_message::<SubscribedTitlesView>(bytes)?),
                Ok(66) => msg.data = mod_SuccessResult::OneOfdata::title_detail_view(r.read_message::<TitleDetailView>(bytes)?),
                Ok(74) => msg.data = mod_SuccessResult::OneOfdata::comment_list_view(r.read_message::<CommentListView>(bytes)?),
                Ok(82) => msg.data = mod_SuccessResult::OneOfdata::manga_viewer(r.read_message::<MangaViewer>(bytes)?),
                Ok(90) => msg.data = mod_SuccessResult::OneOfdata::web_home_view(r.read_message::<WebHomeView>(bytes)?),
                Ok(98) => msg.data = mod_SuccessResult::OneOfdata::settings_view(r.read_message::<SettingsView>(bytes)?),
                Ok(106) => msg.data = mod_SuccessResult::OneOfdata::profile_settings_view(r.read_message::<ProfileSettingsView>(bytes)?),
                Ok(114) => msg.data = mod_SuccessResult::OneOfdata::update_profile_result_view(r.read_message::<UpdateProfileResultView>(bytes)?),
                Ok(122) => msg.data = mod_SuccessResult::OneOfdata::service_announcements_view(r.read_message::<ServiceAnnouncementsView>(bytes)?),
                Ok(130) => msg.data = mod_SuccessResult::OneOfdata::initial_view(r.read_message::<InitialView>(bytes)?),
                Ok(138) => msg.data = mod_SuccessResult::OneOfdata::feedback_view(r.read_message::<FeedbackView>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for SuccessResult {
    fn get_size(&self) -> usize {
        0
        + if self.is_featured_updated == false { 0 } else { 1 + sizeof_varint(*(&self.is_featured_updated) as u64) }
        + match self.data {
            mod_SuccessResult::OneOfdata::registeration_data(ref m) => 1 + sizeof_len((m).get_size()),
            mod_SuccessResult::OneOfdata::home_view(ref m) => 1 + sizeof_len((m).get_size()),
            mod_SuccessResult::OneOfdata::featured_titles_view(ref m) => 1 + sizeof_len((m).get_size()),
            mod_SuccessResult::OneOfdata::all_titles_view(ref m) => 1 + sizeof_len((m).get_size()),
            mod_SuccessResult::OneOfdata::title_ranking_view(ref m) => 1 + sizeof_len((m).get_size()),
            mod_SuccessResult::OneOfdata::subscribed_titles_view(ref m) => 1 + sizeof_len((m).get_size()),
            mod_SuccessResult::OneOfdata::title_detail_view(ref m) => 1 + sizeof_len((m).get_size()),
            mod_SuccessResult::OneOfdata::comment_list_view(ref m) => 1 + sizeof_len((m).get_size()),
            mod_SuccessResult::OneOfdata::manga_viewer(ref m) => 1 + sizeof_len((m).get_size()),
            mod_SuccessResult::OneOfdata::web_home_view(ref m) => 1 + sizeof_len((m).get_size()),
            mod_SuccessResult::OneOfdata::settings_view(ref m) => 1 + sizeof_len((m).get_size()),
            mod_SuccessResult::OneOfdata::profile_settings_view(ref m) => 1 + sizeof_len((m).get_size()),
            mod_SuccessResult::OneOfdata::update_profile_result_view(ref m) => 1 + sizeof_len((m).get_size()),
            mod_SuccessResult::OneOfdata::service_announcements_view(ref m) => 1 + sizeof_len((m).get_size()),
            mod_SuccessResult::OneOfdata::initial_view(ref m) => 2 + sizeof_len((m).get_size()),
            mod_SuccessResult::OneOfdata::feedback_view(ref m) => 2 + sizeof_len((m).get_size()),
            mod_SuccessResult::OneOfdata::None => 0,
    }    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.is_featured_updated != false { w.write_with_tag(8, |w| w.write_bool(*&self.is_featured_updated))?; }
        match self.data {            mod_SuccessResult::OneOfdata::registeration_data(ref m) => { w.write_with_tag(18, |w| w.write_message(m))? },
            mod_SuccessResult::OneOfdata::home_view(ref m) => { w.write_with_tag(26, |w| w.write_message(m))? },
            mod_SuccessResult::OneOfdata::featured_titles_view(ref m) => { w.write_with_tag(34, |w| w.write_message(m))? },
            mod_SuccessResult::OneOfdata::all_titles_view(ref m) => { w.write_with_tag(42, |w| w.write_message(m))? },
            mod_SuccessResult::OneOfdata::title_ranking_view(ref m) => { w.write_with_tag(50, |w| w.write_message(m))? },
            mod_SuccessResult::OneOfdata::subscribed_titles_view(ref m) => { w.write_with_tag(58, |w| w.write_message(m))? },
            mod_SuccessResult::OneOfdata::title_detail_view(ref m) => { w.write_with_tag(66, |w| w.write_message(m))? },
            mod_SuccessResult::OneOfdata::comment_list_view(ref m) => { w.write_with_tag(74, |w| w.write_message(m))? },
            mod_SuccessResult::OneOfdata::manga_viewer(ref m) => { w.write_with_tag(82, |w| w.write_message(m))? },
            mod_SuccessResult::OneOfdata::web_home_view(ref m) => { w.write_with_tag(90, |w| w.write_message(m))? },
            mod_SuccessResult::OneOfdata::settings_view(ref m) => { w.write_with_tag(98, |w| w.write_message(m))? },
            mod_SuccessResult::OneOfdata::profile_settings_view(ref m) => { w.write_with_tag(106, |w| w.write_message(m))? },
            mod_SuccessResult::OneOfdata::update_profile_result_view(ref m) => { w.write_with_tag(114, |w| w.write_message(m))? },
            mod_SuccessResult::OneOfdata::service_announcements_view(ref m) => { w.write_with_tag(122, |w| w.write_message(m))? },
            mod_SuccessResult::OneOfdata::initial_view(ref m) => { w.write_with_tag(130, |w| w.write_message(m))? },
            mod_SuccessResult::OneOfdata::feedback_view(ref m) => { w.write_with_tag(138, |w| w.write_message(m))? },
            mod_SuccessResult::OneOfdata::None => {},
    }        Ok(())
    }
}

pub mod mod_SuccessResult {

use super::*;

#[derive(Debug, PartialEq, Clone)]
#[derive(Serialize, Deserialize)]
pub enum OneOfdata {
    registeration_data(RegistrationData),
    home_view(HomeView),
    featured_titles_view(FeaturedTitlesView),
    all_titles_view(AllTitlesView),
    title_ranking_view(TitleRankingView),
    subscribed_titles_view(SubscribedTitlesView),
    title_detail_view(TitleDetailView),
    comment_list_view(CommentListView),
    manga_viewer(MangaViewer),
    web_home_view(WebHomeView),
    settings_view(SettingsView),
    profile_settings_view(ProfileSettingsView),
    update_profile_result_view(UpdateProfileResultView),
    service_announcements_view(ServiceAnnouncementsView),
    initial_view(InitialView),
    feedback_view(FeedbackView),
    None,
}

impl Default for OneOfdata {
    fn default() -> Self {
        OneOfdata::None
    }
}

}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct ErrorResult {
    pub action: mod_ErrorResult::Action,
    pub english_popup: Option<mod_Popup::OSDefault>,
    pub spanish_popup: Option<mod_Popup::OSDefault>,
    pub debug_info: String,
}

impl<'a> MessageRead<'a> for ErrorResult {
    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.action = r.read_enum(bytes)?,
                Ok(18) => msg.english_popup = Some(r.read_message::<mod_Popup::OSDefault>(bytes)?),
                Ok(26) => msg.spanish_popup = Some(r.read_message::<mod_Popup::OSDefault>(bytes)?),
                Ok(34) => msg.debug_info = r.read_string(bytes)?.to_owned(),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for ErrorResult {
    fn get_size(&self) -> usize {
        0
        + if self.action == reader::mod_ErrorResult::Action::DEFAULT { 0 } else { 1 + sizeof_varint(*(&self.action) as u64) }
        + self.english_popup.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
        + self.spanish_popup.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
        + if self.debug_info == String::default() { 0 } else { 1 + sizeof_len((&self.debug_info).len()) }
    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        if self.action != reader::mod_ErrorResult::Action::DEFAULT { w.write_with_tag(8, |w| w.write_enum(*&self.action as i32))?; }
        if let Some(ref s) = self.english_popup { w.write_with_tag(18, |w| w.write_message(s))?; }
        if let Some(ref s) = self.spanish_popup { w.write_with_tag(26, |w| w.write_message(s))?; }
        if self.debug_info != String::default() { w.write_with_tag(34, |w| w.write_string(&**&self.debug_info))?; }
        Ok(())
    }
}

pub mod mod_ErrorResult {



use super::*;#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[derive(Serialize, Deserialize)]
pub enum Action {
    DEFAULT = 0,
    UNAUTHORIZED = 1,
    MAINTAINENCE = 2,
    GEOIP_BLOCKING = 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::UNAUTHORIZED,
            2 => Action::MAINTAINENCE,
            3 => Action::GEOIP_BLOCKING,
            _ => Self::default(),
        }
    }
}

impl<'a> From<&'a str> for Action {
    fn from(s: &'a str) -> Self {
        match s {
            "DEFAULT" => Action::DEFAULT,
            "UNAUTHORIZED" => Action::UNAUTHORIZED,
            "MAINTAINENCE" => Action::MAINTAINENCE,
            "GEOIP_BLOCKING" => Action::GEOIP_BLOCKING,
            _ => Self::default(),
        }
    }
}

}

#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
pub struct Response {
    pub data: mod_Response::OneOfdata,
}

impl<'a> MessageRead<'a> for Response {
    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.data = mod_Response::OneOfdata::success(r.read_message::<SuccessResult>(bytes)?),
                Ok(18) => msg.data = mod_Response::OneOfdata::error(r.read_message::<ErrorResult>(bytes)?),
                Ok(t) => { r.read_unknown(bytes, t)?; }
                Err(e) => return Err(e),
            }
        }
        Ok(msg)
    }
}

impl MessageWrite for Response {
    fn get_size(&self) -> usize {
        0
        + match self.data {
            mod_Response::OneOfdata::success(ref m) => 1 + sizeof_len((m).get_size()),
            mod_Response::OneOfdata::error(ref m) => 1 + sizeof_len((m).get_size()),
            mod_Response::OneOfdata::None => 0,
    }    }

    fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
        match self.data {            mod_Response::OneOfdata::success(ref m) => { w.write_with_tag(10, |w| w.write_message(m))? },
            mod_Response::OneOfdata::error(ref m) => { w.write_with_tag(18, |w| w.write_message(m))? },
            mod_Response::OneOfdata::None => {},
    }        Ok(())
    }
}

pub mod mod_Response {

use super::*;

#[derive(Debug, PartialEq, Clone)]
#[derive(Serialize, Deserialize)]
pub enum OneOfdata {
    success(SuccessResult),
    error(ErrorResult),
    None,
}

impl Default for OneOfdata {
    fn default() -> Self {
        OneOfdata::None
    }
}

}