fav_core 0.0.1-alpha2

// This file is generated by rust-protobuf 3.3.0. Do not edit
// .proto file is parsed by pure
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_results)]
#![allow(unused_mut)]

//! Generated file from `data.proto`

/// Generated files are compatible only with the same version
/// of protobuf runtime.
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_3_0;

// @@protoc_insertion_point(message:data.Msg)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Msg {
    // special fields
    // @@protoc_insertion_point(special_field:data.Msg.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a Msg {
    fn default() -> &'a Msg {
        <Msg as ::protobuf::Message>::default_instance()
    }
}

impl Msg {
    pub fn new() -> Msg {
        ::std::default::Default::default()
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(0);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Msg>(
            "Msg",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for Msg {
    const NAME: &'static str = "Msg";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> Msg {
        Msg::new()
    }

    fn clear(&mut self) {
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Msg {
        static instance: Msg = Msg {
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Msg {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("Msg").unwrap()).clone()
    }
}

impl ::std::fmt::Display for Msg {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Msg {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:data.Conf)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Conf {
    // message fields
    // @@protoc_insertion_point(field:data.Conf.headers)
    pub headers: ::protobuf::MessageField<Headers>,
    // special fields
    // @@protoc_insertion_point(special_field:data.Conf.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a Conf {
    fn default() -> &'a Conf {
        <Conf as ::protobuf::Message>::default_instance()
    }
}

impl Conf {
    pub fn new() -> Conf {
        ::std::default::Default::default()
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(1);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Headers>(
            "headers",
            |m: &Conf| { &m.headers },
            |m: &mut Conf| { &mut m.headers },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Conf>(
            "Conf",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for Conf {
    const NAME: &'static str = "Conf";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.headers)?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.headers.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.headers.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> Conf {
        Conf::new()
    }

    fn clear(&mut self) {
        self.headers.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Conf {
        static instance: Conf = Conf {
            headers: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Conf {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("Conf").unwrap()).clone()
    }
}

impl ::std::fmt::Display for Conf {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Conf {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:data.Headers)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Headers {
    // message fields
    // @@protoc_insertion_point(field:data.Headers.user_agent)
    pub user_agent: ::std::string::String,
    // @@protoc_insertion_point(field:data.Headers.referer)
    pub referer: ::std::string::String,
    // @@protoc_insertion_point(field:data.Headers.cookies)
    pub cookies: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:data.Headers.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a Headers {
    fn default() -> &'a Headers {
        <Headers as ::protobuf::Message>::default_instance()
    }
}

impl Headers {
    pub fn new() -> Headers {
        ::std::default::Default::default()
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(3);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "user_agent",
            |m: &Headers| { &m.user_agent },
            |m: &mut Headers| { &mut m.user_agent },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "referer",
            |m: &Headers| { &m.referer },
            |m: &mut Headers| { &mut m.referer },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_map_simpler_accessor::<_, _, _>(
            "cookies",
            |m: &Headers| { &m.cookies },
            |m: &mut Headers| { &mut m.cookies },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Headers>(
            "Headers",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for Headers {
    const NAME: &'static str = "Headers";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.user_agent = is.read_string()?;
                },
                18 => {
                    self.referer = is.read_string()?;
                },
                26 => {
                    let len = is.read_raw_varint32()?;
                    let old_limit = is.push_limit(len as u64)?;
                    let mut key = ::std::default::Default::default();
                    let mut value = ::std::default::Default::default();
                    while let Some(tag) = is.read_raw_tag_or_eof()? {
                        match tag {
                            10 => key = is.read_string()?,
                            18 => value = is.read_string()?,
                            _ => ::protobuf::rt::skip_field_for_tag(tag, is)?,
                        };
                    }
                    is.pop_limit(old_limit);
                    self.cookies.insert(key, value);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if !self.user_agent.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.user_agent);
        }
        if !self.referer.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.referer);
        }
        for (k, v) in &self.cookies {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(entry_size) + entry_size
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if !self.user_agent.is_empty() {
            os.write_string(1, &self.user_agent)?;
        }
        if !self.referer.is_empty() {
            os.write_string(2, &self.referer)?;
        }
        for (k, v) in &self.cookies {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            os.write_raw_varint32(26)?; // Tag.
            os.write_raw_varint32(entry_size as u32)?;
            os.write_string(1, &k)?;
            os.write_string(2, &v)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> Headers {
        Headers::new()
    }

    fn clear(&mut self) {
        self.user_agent.clear();
        self.referer.clear();
        self.cookies.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Headers {
        static instance: ::protobuf::rt::Lazy<Headers> = ::protobuf::rt::Lazy::new();
        instance.get(Headers::new)
    }
}

impl ::protobuf::MessageFull for Headers {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("Headers").unwrap()).clone()
    }
}

impl ::std::fmt::Display for Headers {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Headers {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:data.App)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct App {
    // message fields
    // @@protoc_insertion_point(field:data.App.sets)
    pub sets: ::std::vec::Vec<TestResSet>,
    // special fields
    // @@protoc_insertion_point(special_field:data.App.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a App {
    fn default() -> &'a App {
        <App as ::protobuf::Message>::default_instance()
    }
}

impl App {
    pub fn new() -> App {
        ::std::default::Default::default()
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(1);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "sets",
            |m: &App| { &m.sets },
            |m: &mut App| { &mut m.sets },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<App>(
            "App",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for App {
    const NAME: &'static str = "App";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.sets.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.sets {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        for v in &self.sets {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> App {
        App::new()
    }

    fn clear(&mut self) {
        self.sets.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static App {
        static instance: App = App {
            sets: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for App {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("App").unwrap()).clone()
    }
}

impl ::std::fmt::Display for App {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for App {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:data.TestResSet)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct TestResSet {
    // message fields
    // @@protoc_insertion_point(field:data.TestResSet.id)
    pub id: i32,
    // @@protoc_insertion_point(field:data.TestResSet.name)
    pub name: ::std::string::String,
    // @@protoc_insertion_point(field:data.TestResSet.sets)
    pub sets: ::std::vec::Vec<TestRes>,
    // @@protoc_insertion_point(field:data.TestResSet.uppers)
    pub uppers: ::std::vec::Vec<TestUpper>,
    // special fields
    // @@protoc_insertion_point(special_field:data.TestResSet.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a TestResSet {
    fn default() -> &'a TestResSet {
        <TestResSet as ::protobuf::Message>::default_instance()
    }
}

impl TestResSet {
    pub fn new() -> TestResSet {
        ::std::default::Default::default()
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(4);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "id",
            |m: &TestResSet| { &m.id },
            |m: &mut TestResSet| { &mut m.id },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "name",
            |m: &TestResSet| { &m.name },
            |m: &mut TestResSet| { &mut m.name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "sets",
            |m: &TestResSet| { &m.sets },
            |m: &mut TestResSet| { &mut m.sets },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "uppers",
            |m: &TestResSet| { &m.uppers },
            |m: &mut TestResSet| { &mut m.uppers },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<TestResSet>(
            "TestResSet",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for TestResSet {
    const NAME: &'static str = "TestResSet";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.id = is.read_int32()?;
                },
                18 => {
                    self.name = is.read_string()?;
                },
                26 => {
                    self.sets.push(is.read_message()?);
                },
                34 => {
                    self.uppers.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if self.id != 0 {
            my_size += ::protobuf::rt::int32_size(1, self.id);
        }
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.name);
        }
        for value in &self.sets {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.uppers {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if self.id != 0 {
            os.write_int32(1, self.id)?;
        }
        if !self.name.is_empty() {
            os.write_string(2, &self.name)?;
        }
        for v in &self.sets {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        for v in &self.uppers {
            ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> TestResSet {
        TestResSet::new()
    }

    fn clear(&mut self) {
        self.id = 0;
        self.name.clear();
        self.sets.clear();
        self.uppers.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static TestResSet {
        static instance: TestResSet = TestResSet {
            id: 0,
            name: ::std::string::String::new(),
            sets: ::std::vec::Vec::new(),
            uppers: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for TestResSet {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("TestResSet").unwrap()).clone()
    }
}

impl ::std::fmt::Display for TestResSet {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for TestResSet {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:data.TestRes)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct TestRes {
    // message fields
    // @@protoc_insertion_point(field:data.TestRes.id)
    pub id: i32,
    // @@protoc_insertion_point(field:data.TestRes.name)
    pub name: ::std::string::String,
    // @@protoc_insertion_point(field:data.TestRes.status)
    pub status: i32,
    // @@protoc_insertion_point(field:data.TestRes.uppers)
    pub uppers: ::std::vec::Vec<TestUpper>,
    // special fields
    // @@protoc_insertion_point(special_field:data.TestRes.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a TestRes {
    fn default() -> &'a TestRes {
        <TestRes as ::protobuf::Message>::default_instance()
    }
}

impl TestRes {
    pub fn new() -> TestRes {
        ::std::default::Default::default()
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(4);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "id",
            |m: &TestRes| { &m.id },
            |m: &mut TestRes| { &mut m.id },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "name",
            |m: &TestRes| { &m.name },
            |m: &mut TestRes| { &mut m.name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "status",
            |m: &TestRes| { &m.status },
            |m: &mut TestRes| { &mut m.status },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "uppers",
            |m: &TestRes| { &m.uppers },
            |m: &mut TestRes| { &mut m.uppers },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<TestRes>(
            "TestRes",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for TestRes {
    const NAME: &'static str = "TestRes";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.id = is.read_int32()?;
                },
                18 => {
                    self.name = is.read_string()?;
                },
                24 => {
                    self.status = is.read_int32()?;
                },
                34 => {
                    self.uppers.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if self.id != 0 {
            my_size += ::protobuf::rt::int32_size(1, self.id);
        }
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.name);
        }
        if self.status != 0 {
            my_size += ::protobuf::rt::int32_size(3, self.status);
        }
        for value in &self.uppers {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if self.id != 0 {
            os.write_int32(1, self.id)?;
        }
        if !self.name.is_empty() {
            os.write_string(2, &self.name)?;
        }
        if self.status != 0 {
            os.write_int32(3, self.status)?;
        }
        for v in &self.uppers {
            ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> TestRes {
        TestRes::new()
    }

    fn clear(&mut self) {
        self.id = 0;
        self.name.clear();
        self.status = 0;
        self.uppers.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static TestRes {
        static instance: TestRes = TestRes {
            id: 0,
            name: ::std::string::String::new(),
            status: 0,
            uppers: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for TestRes {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("TestRes").unwrap()).clone()
    }
}

impl ::std::fmt::Display for TestRes {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for TestRes {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:data.TestUpper)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct TestUpper {
    // message fields
    // @@protoc_insertion_point(field:data.TestUpper.id)
    pub id: i32,
    // @@protoc_insertion_point(field:data.TestUpper.name)
    pub name: ::std::string::String,
    // special fields
    // @@protoc_insertion_point(special_field:data.TestUpper.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a TestUpper {
    fn default() -> &'a TestUpper {
        <TestUpper as ::protobuf::Message>::default_instance()
    }
}

impl TestUpper {
    pub fn new() -> TestUpper {
        ::std::default::Default::default()
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(2);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "id",
            |m: &TestUpper| { &m.id },
            |m: &mut TestUpper| { &mut m.id },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "name",
            |m: &TestUpper| { &m.name },
            |m: &mut TestUpper| { &mut m.name },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<TestUpper>(
            "TestUpper",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for TestUpper {
    const NAME: &'static str = "TestUpper";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.id = is.read_int32()?;
                },
                18 => {
                    self.name = is.read_string()?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if self.id != 0 {
            my_size += ::protobuf::rt::int32_size(1, self.id);
        }
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.name);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if self.id != 0 {
            os.write_int32(1, self.id)?;
        }
        if !self.name.is_empty() {
            os.write_string(2, &self.name)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> TestUpper {
        TestUpper::new()
    }

    fn clear(&mut self) {
        self.id = 0;
        self.name.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static TestUpper {
        static instance: TestUpper = TestUpper {
            id: 0,
            name: ::std::string::String::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for TestUpper {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("TestUpper").unwrap()).clone()
    }
}

impl ::std::fmt::Display for TestUpper {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for TestUpper {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:data.StatusTest)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct StatusTest {
    // message fields
    // @@protoc_insertion_point(field:data.StatusTest.id)
    pub id: i32,
    // @@protoc_insertion_point(field:data.StatusTest.name)
    pub name: ::std::string::String,
    // @@protoc_insertion_point(field:data.StatusTest.status)
    pub status: i32,
    // @@protoc_insertion_point(field:data.StatusTest.uppers)
    pub uppers: ::std::vec::Vec<TestUpper>,
    // special fields
    // @@protoc_insertion_point(special_field:data.StatusTest.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a StatusTest {
    fn default() -> &'a StatusTest {
        <StatusTest as ::protobuf::Message>::default_instance()
    }
}

impl StatusTest {
    pub fn new() -> StatusTest {
        ::std::default::Default::default()
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(4);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "id",
            |m: &StatusTest| { &m.id },
            |m: &mut StatusTest| { &mut m.id },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "name",
            |m: &StatusTest| { &m.name },
            |m: &mut StatusTest| { &mut m.name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "status",
            |m: &StatusTest| { &m.status },
            |m: &mut StatusTest| { &mut m.status },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "uppers",
            |m: &StatusTest| { &m.uppers },
            |m: &mut StatusTest| { &mut m.uppers },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<StatusTest>(
            "StatusTest",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for StatusTest {
    const NAME: &'static str = "StatusTest";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.id = is.read_int32()?;
                },
                18 => {
                    self.name = is.read_string()?;
                },
                24 => {
                    self.status = is.read_int32()?;
                },
                34 => {
                    self.uppers.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if self.id != 0 {
            my_size += ::protobuf::rt::int32_size(1, self.id);
        }
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.name);
        }
        if self.status != 0 {
            my_size += ::protobuf::rt::int32_size(3, self.status);
        }
        for value in &self.uppers {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if self.id != 0 {
            os.write_int32(1, self.id)?;
        }
        if !self.name.is_empty() {
            os.write_string(2, &self.name)?;
        }
        if self.status != 0 {
            os.write_int32(3, self.status)?;
        }
        for v in &self.uppers {
            ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> StatusTest {
        StatusTest::new()
    }

    fn clear(&mut self) {
        self.id = 0;
        self.name.clear();
        self.status = 0;
        self.uppers.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static StatusTest {
        static instance: StatusTest = StatusTest {
            id: 0,
            name: ::std::string::String::new(),
            status: 0,
            uppers: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for StatusTest {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("StatusTest").unwrap()).clone()
    }
}

impl ::std::fmt::Display for StatusTest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for StatusTest {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\ndata.proto\x12\x04data\"\x05\n\x03Msg\"/\n\x04Conf\x12'\n\x07headers\
    \x18\x01\x20\x01(\x0b2\r.data.HeadersR\x07headers\"\xb4\x01\n\x07Headers\
    \x12\x1d\n\nuser_agent\x18\x01\x20\x01(\tR\tuserAgent\x12\x18\n\x07refer\
    er\x18\x02\x20\x01(\tR\x07referer\x124\n\x07cookies\x18\x03\x20\x03(\x0b\
    2\x1a.data.Headers.CookiesEntryR\x07cookies\x1a:\n\x0cCookiesEntry\x12\
    \x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\
    \x01(\tR\x05value:\x028\x01\"+\n\x03App\x12$\n\x04sets\x18\x01\x20\x03(\
    \x0b2\x10.data.TestResSetR\x04sets\"|\n\nTestResSet\x12\x0e\n\x02id\x18\
    \x01\x20\x01(\x05R\x02id\x12\x12\n\x04name\x18\x02\x20\x01(\tR\x04name\
    \x12!\n\x04sets\x18\x03\x20\x03(\x0b2\r.data.TestResR\x04sets\x12'\n\x06\
    uppers\x18\x04\x20\x03(\x0b2\x0f.data.TestUpperR\x06uppers\"n\n\x07TestR\
    es\x12\x0e\n\x02id\x18\x01\x20\x01(\x05R\x02id\x12\x12\n\x04name\x18\x02\
    \x20\x01(\tR\x04name\x12\x16\n\x06status\x18\x03\x20\x01(\x05R\x06status\
    \x12'\n\x06uppers\x18\x04\x20\x03(\x0b2\x0f.data.TestUpperR\x06uppers\"/\
    \n\tTestUpper\x12\x0e\n\x02id\x18\x01\x20\x01(\x05R\x02id\x12\x12\n\x04n\
    ame\x18\x02\x20\x01(\tR\x04name\"q\n\nStatusTest\x12\x0e\n\x02id\x18\x01\
    \x20\x01(\x05R\x02id\x12\x12\n\x04name\x18\x02\x20\x01(\tR\x04name\x12\
    \x16\n\x06status\x18\x03\x20\x01(\x05R\x06status\x12'\n\x06uppers\x18\
    \x04\x20\x03(\x0b2\x0f.data.TestUpperR\x06uppersb\x06proto3\
";

/// `FileDescriptorProto` object which was a source for this generated file
fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
    file_descriptor_proto_lazy.get(|| {
        ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
    })
}

/// `FileDescriptor` object which allows dynamic access to files
pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
    static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
    static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
    file_descriptor.get(|| {
        let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
            let mut deps = ::std::vec::Vec::with_capacity(0);
            let mut messages = ::std::vec::Vec::with_capacity(8);
            messages.push(Msg::generated_message_descriptor_data());
            messages.push(Conf::generated_message_descriptor_data());
            messages.push(Headers::generated_message_descriptor_data());
            messages.push(App::generated_message_descriptor_data());
            messages.push(TestResSet::generated_message_descriptor_data());
            messages.push(TestRes::generated_message_descriptor_data());
            messages.push(TestUpper::generated_message_descriptor_data());
            messages.push(StatusTest::generated_message_descriptor_data());
            let mut enums = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
                file_descriptor_proto(),
                deps,
                messages,
                enums,
            )
        });
        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
    })
}