anychain_tron/protocol/

Discover.rs

// This file is generated by rust-protobuf 3.3.0. Do not edit
// .proto file is parsed by protoc --rust-out=...
// @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(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 `core/Discover.proto`

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

// @@protoc_insertion_point(message:protocol.Endpoint)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Endpoint {
    // message fields
    // @@protoc_insertion_point(field:protocol.Endpoint.address)
    pub address: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.Endpoint.port)
    pub port: i32,
    // @@protoc_insertion_point(field:protocol.Endpoint.nodeId)
    pub nodeId: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.Endpoint.addressIpv6)
    pub addressIpv6: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.Endpoint.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

impl Endpoint {
    pub fn new() -> Endpoint {
        ::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::<_, _>(
            "address",
            |m: &Endpoint| { &m.address },
            |m: &mut Endpoint| { &mut m.address },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "port",
            |m: &Endpoint| { &m.port },
            |m: &mut Endpoint| { &mut m.port },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "nodeId",
            |m: &Endpoint| { &m.nodeId },
            |m: &mut Endpoint| { &mut m.nodeId },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "addressIpv6",
            |m: &Endpoint| { &m.addressIpv6 },
            |m: &mut Endpoint| { &mut m.addressIpv6 },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Endpoint>(
            "Endpoint",
            fields,
            oneofs,
        )
    }
}

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

    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.address = is.read_bytes()?;
                },
                16 => {
                    self.port = is.read_int32()?;
                },
                26 => {
                    self.nodeId = is.read_bytes()?;
                },
                34 => {
                    self.addressIpv6 = is.read_bytes()?;
                },
                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.address.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.address);
        }
        if self.port != 0 {
            my_size += ::protobuf::rt::int32_size(2, self.port);
        }
        if !self.nodeId.is_empty() {
            my_size += ::protobuf::rt::bytes_size(3, &self.nodeId);
        }
        if !self.addressIpv6.is_empty() {
            my_size += ::protobuf::rt::bytes_size(4, &self.addressIpv6);
        }
        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.address.is_empty() {
            os.write_bytes(1, &self.address)?;
        }
        if self.port != 0 {
            os.write_int32(2, self.port)?;
        }
        if !self.nodeId.is_empty() {
            os.write_bytes(3, &self.nodeId)?;
        }
        if !self.addressIpv6.is_empty() {
            os.write_bytes(4, &self.addressIpv6)?;
        }
        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() -> Endpoint {
        Endpoint::new()
    }

    fn clear(&mut self) {
        self.address.clear();
        self.port = 0;
        self.nodeId.clear();
        self.addressIpv6.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Endpoint {
        static instance: Endpoint = Endpoint {
            address: ::std::vec::Vec::new(),
            port: 0,
            nodeId: ::std::vec::Vec::new(),
            addressIpv6: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Endpoint {
    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("Endpoint").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:protocol.PingMessage)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PingMessage {
    // message fields
    // @@protoc_insertion_point(field:protocol.PingMessage.from)
    pub from: ::protobuf::MessageField<Endpoint>,
    // @@protoc_insertion_point(field:protocol.PingMessage.to)
    pub to: ::protobuf::MessageField<Endpoint>,
    // @@protoc_insertion_point(field:protocol.PingMessage.version)
    pub version: i32,
    // @@protoc_insertion_point(field:protocol.PingMessage.timestamp)
    pub timestamp: i64,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.PingMessage.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

impl PingMessage {
    pub fn new() -> PingMessage {
        ::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_message_field_accessor::<_, Endpoint>(
            "from",
            |m: &PingMessage| { &m.from },
            |m: &mut PingMessage| { &mut m.from },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Endpoint>(
            "to",
            |m: &PingMessage| { &m.to },
            |m: &mut PingMessage| { &mut m.to },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "version",
            |m: &PingMessage| { &m.version },
            |m: &mut PingMessage| { &mut m.version },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "timestamp",
            |m: &PingMessage| { &m.timestamp },
            |m: &mut PingMessage| { &mut m.timestamp },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PingMessage>(
            "PingMessage",
            fields,
            oneofs,
        )
    }
}

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

    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.from)?;
                },
                18 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.to)?;
                },
                24 => {
                    self.version = is.read_int32()?;
                },
                32 => {
                    self.timestamp = is.read_int64()?;
                },
                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.from.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.to.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if self.version != 0 {
            my_size += ::protobuf::rt::int32_size(3, self.version);
        }
        if self.timestamp != 0 {
            my_size += ::protobuf::rt::int64_size(4, self.timestamp);
        }
        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.from.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if let Some(v) = self.to.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        if self.version != 0 {
            os.write_int32(3, self.version)?;
        }
        if self.timestamp != 0 {
            os.write_int64(4, self.timestamp)?;
        }
        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() -> PingMessage {
        PingMessage::new()
    }

    fn clear(&mut self) {
        self.from.clear();
        self.to.clear();
        self.version = 0;
        self.timestamp = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static PingMessage {
        static instance: PingMessage = PingMessage {
            from: ::protobuf::MessageField::none(),
            to: ::protobuf::MessageField::none(),
            version: 0,
            timestamp: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for PingMessage {
    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("PingMessage").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:protocol.PongMessage)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PongMessage {
    // message fields
    // @@protoc_insertion_point(field:protocol.PongMessage.from)
    pub from: ::protobuf::MessageField<Endpoint>,
    // @@protoc_insertion_point(field:protocol.PongMessage.echo)
    pub echo: i32,
    // @@protoc_insertion_point(field:protocol.PongMessage.timestamp)
    pub timestamp: i64,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.PongMessage.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

impl PongMessage {
    pub fn new() -> PongMessage {
        ::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_message_field_accessor::<_, Endpoint>(
            "from",
            |m: &PongMessage| { &m.from },
            |m: &mut PongMessage| { &mut m.from },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "echo",
            |m: &PongMessage| { &m.echo },
            |m: &mut PongMessage| { &mut m.echo },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "timestamp",
            |m: &PongMessage| { &m.timestamp },
            |m: &mut PongMessage| { &mut m.timestamp },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PongMessage>(
            "PongMessage",
            fields,
            oneofs,
        )
    }
}

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

    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.from)?;
                },
                16 => {
                    self.echo = is.read_int32()?;
                },
                24 => {
                    self.timestamp = is.read_int64()?;
                },
                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.from.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if self.echo != 0 {
            my_size += ::protobuf::rt::int32_size(2, self.echo);
        }
        if self.timestamp != 0 {
            my_size += ::protobuf::rt::int64_size(3, self.timestamp);
        }
        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.from.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if self.echo != 0 {
            os.write_int32(2, self.echo)?;
        }
        if self.timestamp != 0 {
            os.write_int64(3, self.timestamp)?;
        }
        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() -> PongMessage {
        PongMessage::new()
    }

    fn clear(&mut self) {
        self.from.clear();
        self.echo = 0;
        self.timestamp = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static PongMessage {
        static instance: PongMessage = PongMessage {
            from: ::protobuf::MessageField::none(),
            echo: 0,
            timestamp: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for PongMessage {
    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("PongMessage").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:protocol.FindNeighbours)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct FindNeighbours {
    // message fields
    // @@protoc_insertion_point(field:protocol.FindNeighbours.from)
    pub from: ::protobuf::MessageField<Endpoint>,
    // @@protoc_insertion_point(field:protocol.FindNeighbours.targetId)
    pub targetId: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:protocol.FindNeighbours.timestamp)
    pub timestamp: i64,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.FindNeighbours.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

impl FindNeighbours {
    pub fn new() -> FindNeighbours {
        ::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_message_field_accessor::<_, Endpoint>(
            "from",
            |m: &FindNeighbours| { &m.from },
            |m: &mut FindNeighbours| { &mut m.from },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "targetId",
            |m: &FindNeighbours| { &m.targetId },
            |m: &mut FindNeighbours| { &mut m.targetId },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "timestamp",
            |m: &FindNeighbours| { &m.timestamp },
            |m: &mut FindNeighbours| { &mut m.timestamp },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<FindNeighbours>(
            "FindNeighbours",
            fields,
            oneofs,
        )
    }
}

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

    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.from)?;
                },
                18 => {
                    self.targetId = is.read_bytes()?;
                },
                24 => {
                    self.timestamp = is.read_int64()?;
                },
                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.from.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if !self.targetId.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.targetId);
        }
        if self.timestamp != 0 {
            my_size += ::protobuf::rt::int64_size(3, self.timestamp);
        }
        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.from.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if !self.targetId.is_empty() {
            os.write_bytes(2, &self.targetId)?;
        }
        if self.timestamp != 0 {
            os.write_int64(3, self.timestamp)?;
        }
        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() -> FindNeighbours {
        FindNeighbours::new()
    }

    fn clear(&mut self) {
        self.from.clear();
        self.targetId.clear();
        self.timestamp = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static FindNeighbours {
        static instance: FindNeighbours = FindNeighbours {
            from: ::protobuf::MessageField::none(),
            targetId: ::std::vec::Vec::new(),
            timestamp: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for FindNeighbours {
    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("FindNeighbours").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:protocol.Neighbours)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Neighbours {
    // message fields
    // @@protoc_insertion_point(field:protocol.Neighbours.from)
    pub from: ::protobuf::MessageField<Endpoint>,
    // @@protoc_insertion_point(field:protocol.Neighbours.neighbours)
    pub neighbours: ::std::vec::Vec<Endpoint>,
    // @@protoc_insertion_point(field:protocol.Neighbours.timestamp)
    pub timestamp: i64,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.Neighbours.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

impl Neighbours {
    pub fn new() -> Neighbours {
        ::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_message_field_accessor::<_, Endpoint>(
            "from",
            |m: &Neighbours| { &m.from },
            |m: &mut Neighbours| { &mut m.from },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "neighbours",
            |m: &Neighbours| { &m.neighbours },
            |m: &mut Neighbours| { &mut m.neighbours },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "timestamp",
            |m: &Neighbours| { &m.timestamp },
            |m: &mut Neighbours| { &mut m.timestamp },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Neighbours>(
            "Neighbours",
            fields,
            oneofs,
        )
    }
}

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

    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.from)?;
                },
                18 => {
                    self.neighbours.push(is.read_message()?);
                },
                24 => {
                    self.timestamp = is.read_int64()?;
                },
                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.from.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.neighbours {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if self.timestamp != 0 {
            my_size += ::protobuf::rt::int64_size(3, self.timestamp);
        }
        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.from.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        for v in &self.neighbours {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        };
        if self.timestamp != 0 {
            os.write_int64(3, self.timestamp)?;
        }
        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() -> Neighbours {
        Neighbours::new()
    }

    fn clear(&mut self) {
        self.from.clear();
        self.neighbours.clear();
        self.timestamp = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Neighbours {
        static instance: Neighbours = Neighbours {
            from: ::protobuf::MessageField::none(),
            neighbours: ::std::vec::Vec::new(),
            timestamp: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Neighbours {
    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("Neighbours").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:protocol.BackupMessage)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct BackupMessage {
    // message fields
    // @@protoc_insertion_point(field:protocol.BackupMessage.flag)
    pub flag: bool,
    // @@protoc_insertion_point(field:protocol.BackupMessage.priority)
    pub priority: i32,
    // special fields
    // @@protoc_insertion_point(special_field:protocol.BackupMessage.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

impl BackupMessage {
    pub fn new() -> BackupMessage {
        ::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::<_, _>(
            "flag",
            |m: &BackupMessage| { &m.flag },
            |m: &mut BackupMessage| { &mut m.flag },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "priority",
            |m: &BackupMessage| { &m.priority },
            |m: &mut BackupMessage| { &mut m.priority },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<BackupMessage>(
            "BackupMessage",
            fields,
            oneofs,
        )
    }
}

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

    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.flag = is.read_bool()?;
                },
                16 => {
                    self.priority = is.read_int32()?;
                },
                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.flag != false {
            my_size += 1 + 1;
        }
        if self.priority != 0 {
            my_size += ::protobuf::rt::int32_size(2, self.priority);
        }
        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.flag != false {
            os.write_bool(1, self.flag)?;
        }
        if self.priority != 0 {
            os.write_int32(2, self.priority)?;
        }
        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() -> BackupMessage {
        BackupMessage::new()
    }

    fn clear(&mut self) {
        self.flag = false;
        self.priority = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static BackupMessage {
        static instance: BackupMessage = BackupMessage {
            flag: false,
            priority: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for BackupMessage {
    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("BackupMessage").unwrap()).clone()
    }
}

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x13core/Discover.proto\x12\x08protocol\"r\n\x08Endpoint\x12\x18\n\x07\
    address\x18\x01\x20\x01(\x0cR\x07address\x12\x12\n\x04port\x18\x02\x20\
    \x01(\x05R\x04port\x12\x16\n\x06nodeId\x18\x03\x20\x01(\x0cR\x06nodeId\
    \x12\x20\n\x0baddressIpv6\x18\x04\x20\x01(\x0cR\x0baddressIpv6\"\x91\x01\
    \n\x0bPingMessage\x12&\n\x04from\x18\x01\x20\x01(\x0b2\x12.protocol.Endp\
    ointR\x04from\x12\"\n\x02to\x18\x02\x20\x01(\x0b2\x12.protocol.EndpointR\
    \x02to\x12\x18\n\x07version\x18\x03\x20\x01(\x05R\x07version\x12\x1c\n\t\
    timestamp\x18\x04\x20\x01(\x03R\ttimestamp\"g\n\x0bPongMessage\x12&\n\
    \x04from\x18\x01\x20\x01(\x0b2\x12.protocol.EndpointR\x04from\x12\x12\n\
    \x04echo\x18\x02\x20\x01(\x05R\x04echo\x12\x1c\n\ttimestamp\x18\x03\x20\
    \x01(\x03R\ttimestamp\"r\n\x0eFindNeighbours\x12&\n\x04from\x18\x01\x20\
    \x01(\x0b2\x12.protocol.EndpointR\x04from\x12\x1a\n\x08targetId\x18\x02\
    \x20\x01(\x0cR\x08targetId\x12\x1c\n\ttimestamp\x18\x03\x20\x01(\x03R\tt\
    imestamp\"\x86\x01\n\nNeighbours\x12&\n\x04from\x18\x01\x20\x01(\x0b2\
    \x12.protocol.EndpointR\x04from\x122\n\nneighbours\x18\x02\x20\x03(\x0b2\
    \x12.protocol.EndpointR\nneighbours\x12\x1c\n\ttimestamp\x18\x03\x20\x01\
    (\x03R\ttimestamp\"?\n\rBackupMessage\x12\x12\n\x04flag\x18\x01\x20\x01(\
    \x08R\x04flag\x12\x1a\n\x08priority\x18\x02\x20\x01(\x05R\x08priorityBF\
    \n\x0forg.tron.protosB\x08DiscoverZ)github.com/tronprotocol/grpc-gateway\
    /coreJ\x81\x0b\n\x06\x12\x04\0\0,\x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\
    \x08\n\x01\x02\x12\x03\x02\0\x11\n\x08\n\x01\x08\x12\x03\x05\0(\nH\n\x02\
    \x08\x01\x12\x03\x05\0(\"=Specify\x20the\x20name\x20of\x20the\x20package\
    \x20that\x20generated\x20the\x20Java\x20file\n\n\x08\n\x01\x08\x12\x03\
    \x06\0)\n=\n\x02\x08\x08\x12\x03\x06\0)\"2Specify\x20the\x20class\x20nam\
    e\x20of\x20the\x20generated\x20Java\x20file\n\n\x08\n\x01\x08\x12\x03\
    \x07\0@\n\t\n\x02\x08\x0b\x12\x03\x07\0@\n\n\n\x02\x04\0\x12\x04\t\0\x0e\
    \x01\n\n\n\x03\x04\0\x01\x12\x03\t\x08\x10\n\x0b\n\x04\x04\0\x02\0\x12\
    \x03\n\x02\x14\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\n\x02\x07\n\x0c\n\x05\
    \x04\0\x02\0\x01\x12\x03\n\x08\x0f\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\n\
    \x12\x13\n\x0b\n\x04\x04\0\x02\x01\x12\x03\x0b\x02\x11\n\x0c\n\x05\x04\0\
    \x02\x01\x05\x12\x03\x0b\x02\x07\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\
    \x0b\x08\x0c\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03\x0b\x0f\x10\n\x0b\n\
    \x04\x04\0\x02\x02\x12\x03\x0c\x02\x13\n\x0c\n\x05\x04\0\x02\x02\x05\x12\
    \x03\x0c\x02\x07\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03\x0c\x08\x0e\n\x0c\
    \n\x05\x04\0\x02\x02\x03\x12\x03\x0c\x11\x12\n\x0b\n\x04\x04\0\x02\x03\
    \x12\x03\r\x02\x18\n\x0c\n\x05\x04\0\x02\x03\x05\x12\x03\r\x02\x07\n\x0c\
    \n\x05\x04\0\x02\x03\x01\x12\x03\r\x08\x13\n\x0c\n\x05\x04\0\x02\x03\x03\
    \x12\x03\r\x16\x17\n\n\n\x02\x04\x01\x12\x04\x10\0\x15\x01\n\n\n\x03\x04\
    \x01\x01\x12\x03\x10\x08\x13\n\x0b\n\x04\x04\x01\x02\0\x12\x03\x11\x02\
    \x14\n\x0c\n\x05\x04\x01\x02\0\x06\x12\x03\x11\x02\n\n\x0c\n\x05\x04\x01\
    \x02\0\x01\x12\x03\x11\x0b\x0f\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03\x11\
    \x12\x13\n\x0b\n\x04\x04\x01\x02\x01\x12\x03\x12\x02\x12\n\x0c\n\x05\x04\
    \x01\x02\x01\x06\x12\x03\x12\x02\n\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\
    \x03\x12\x0b\r\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03\x12\x10\x11\n\x0b\
    \n\x04\x04\x01\x02\x02\x12\x03\x13\x02\x14\n\x0c\n\x05\x04\x01\x02\x02\
    \x05\x12\x03\x13\x02\x07\n\x0c\n\x05\x04\x01\x02\x02\x01\x12\x03\x13\x08\
    \x0f\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\x03\x13\x12\x13\n\x0b\n\x04\x04\
    \x01\x02\x03\x12\x03\x14\x02\x16\n\x0c\n\x05\x04\x01\x02\x03\x05\x12\x03\
    \x14\x02\x07\n\x0c\n\x05\x04\x01\x02\x03\x01\x12\x03\x14\x08\x11\n\x0c\n\
    \x05\x04\x01\x02\x03\x03\x12\x03\x14\x14\x15\n\n\n\x02\x04\x02\x12\x04\
    \x17\0\x1b\x01\n\n\n\x03\x04\x02\x01\x12\x03\x17\x08\x13\n\x0b\n\x04\x04\
    \x02\x02\0\x12\x03\x18\x02\x14\n\x0c\n\x05\x04\x02\x02\0\x06\x12\x03\x18\
    \x02\n\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03\x18\x0b\x0f\n\x0c\n\x05\x04\
    \x02\x02\0\x03\x12\x03\x18\x12\x13\n\x0b\n\x04\x04\x02\x02\x01\x12\x03\
    \x19\x02\x11\n\x0c\n\x05\x04\x02\x02\x01\x05\x12\x03\x19\x02\x07\n\x0c\n\
    \x05\x04\x02\x02\x01\x01\x12\x03\x19\x08\x0c\n\x0c\n\x05\x04\x02\x02\x01\
    \x03\x12\x03\x19\x0f\x10\n\x0b\n\x04\x04\x02\x02\x02\x12\x03\x1a\x02\x16\
    \n\x0c\n\x05\x04\x02\x02\x02\x05\x12\x03\x1a\x02\x07\n\x0c\n\x05\x04\x02\
    \x02\x02\x01\x12\x03\x1a\x08\x11\n\x0c\n\x05\x04\x02\x02\x02\x03\x12\x03\
    \x1a\x14\x15\n\n\n\x02\x04\x03\x12\x04\x1d\0!\x01\n\n\n\x03\x04\x03\x01\
    \x12\x03\x1d\x08\x16\n\x0b\n\x04\x04\x03\x02\0\x12\x03\x1e\x02\x14\n\x0c\
    \n\x05\x04\x03\x02\0\x06\x12\x03\x1e\x02\n\n\x0c\n\x05\x04\x03\x02\0\x01\
    \x12\x03\x1e\x0b\x0f\n\x0c\n\x05\x04\x03\x02\0\x03\x12\x03\x1e\x12\x13\n\
    \x0b\n\x04\x04\x03\x02\x01\x12\x03\x1f\x02\x15\n\x0c\n\x05\x04\x03\x02\
    \x01\x05\x12\x03\x1f\x02\x07\n\x0c\n\x05\x04\x03\x02\x01\x01\x12\x03\x1f\
    \x08\x10\n\x0c\n\x05\x04\x03\x02\x01\x03\x12\x03\x1f\x13\x14\n\x0b\n\x04\
    \x04\x03\x02\x02\x12\x03\x20\x02\x16\n\x0c\n\x05\x04\x03\x02\x02\x05\x12\
    \x03\x20\x02\x07\n\x0c\n\x05\x04\x03\x02\x02\x01\x12\x03\x20\x08\x11\n\
    \x0c\n\x05\x04\x03\x02\x02\x03\x12\x03\x20\x14\x15\n\n\n\x02\x04\x04\x12\
    \x04#\0'\x01\n\n\n\x03\x04\x04\x01\x12\x03#\x08\x12\n\x0b\n\x04\x04\x04\
    \x02\0\x12\x03$\x02\x14\n\x0c\n\x05\x04\x04\x02\0\x06\x12\x03$\x02\n\n\
    \x0c\n\x05\x04\x04\x02\0\x01\x12\x03$\x0b\x0f\n\x0c\n\x05\x04\x04\x02\0\
    \x03\x12\x03$\x12\x13\n\x0b\n\x04\x04\x04\x02\x01\x12\x03%\x02#\n\x0c\n\
    \x05\x04\x04\x02\x01\x04\x12\x03%\x02\n\n\x0c\n\x05\x04\x04\x02\x01\x06\
    \x12\x03%\x0b\x13\n\x0c\n\x05\x04\x04\x02\x01\x01\x12\x03%\x14\x1e\n\x0c\
    \n\x05\x04\x04\x02\x01\x03\x12\x03%!\"\n\x0b\n\x04\x04\x04\x02\x02\x12\
    \x03&\x02\x16\n\x0c\n\x05\x04\x04\x02\x02\x05\x12\x03&\x02\x07\n\x0c\n\
    \x05\x04\x04\x02\x02\x01\x12\x03&\x08\x11\n\x0c\n\x05\x04\x04\x02\x02\
    \x03\x12\x03&\x14\x15\n\n\n\x02\x04\x05\x12\x04)\0,\x01\n\n\n\x03\x04\
    \x05\x01\x12\x03)\x08\x15\n\x0b\n\x04\x04\x05\x02\0\x12\x03*\x02\x10\n\
    \x0c\n\x05\x04\x05\x02\0\x05\x12\x03*\x02\x06\n\x0c\n\x05\x04\x05\x02\0\
    \x01\x12\x03*\x07\x0b\n\x0c\n\x05\x04\x05\x02\0\x03\x12\x03*\x0e\x0f\n\
    \x0b\n\x04\x04\x05\x02\x01\x12\x03+\x02\x15\n\x0c\n\x05\x04\x05\x02\x01\
    \x05\x12\x03+\x02\x07\n\x0c\n\x05\x04\x05\x02\x01\x01\x12\x03+\x08\x10\n\
    \x0c\n\x05\x04\x05\x02\x01\x03\x12\x03+\x13\x14b\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(6);
            messages.push(Endpoint::generated_message_descriptor_data());
            messages.push(PingMessage::generated_message_descriptor_data());
            messages.push(PongMessage::generated_message_descriptor_data());
            messages.push(FindNeighbours::generated_message_descriptor_data());
            messages.push(Neighbours::generated_message_descriptor_data());
            messages.push(BackupMessage::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)
    })
}