rics 0.2.2

// This file is generated by rust-protobuf 2.18.1. Do not edit
// @generated

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

#![allow(unused_attributes)]
#![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_imports)]
#![allow(unused_results)]
//! Generated file from `rics.proto`

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

#[derive(PartialEq,Clone,Default)]
pub struct RICS_Connection {
    // message fields
    connect_as_node: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional bool connect_as_node = 1;


    pub fn get_connect_as_node(&self) -> bool {
        self.connect_as_node.unwrap_or(false)
    }
    pub fn clear_connect_as_node(&mut self) {
        self.connect_as_node = ::std::option::Option::None;
    }

    pub fn has_connect_as_node(&self) -> bool {
        self.connect_as_node.is_some()
    }

    // Param is passed by value, moved
    pub fn set_connect_as_node(&mut self, v: bool) {
        self.connect_as_node = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for RICS_Connection {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.connect_as_node = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.connect_as_node {
            my_size += 2;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.connect_as_node {
            os.write_bool(1, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "connect_as_node",
                |m: &RICS_Connection| { &m.connect_as_node },
                |m: &mut RICS_Connection| { &mut m.connect_as_node },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<RICS_Connection>(
                "RICS_Connection",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for RICS_Connection {
    fn clear(&mut self) {
        self.connect_as_node = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for RICS_Connection {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct RICS_Data {
    // message fields
    source: ::std::option::Option<i32>,
    target: ::std::option::Option<i32>,
    data: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    id: ::std::option::Option<i32>,
    field_type: ::std::option::Option<RICS_Data_RICS_DataType>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional int32 source = 100;


    pub fn get_source(&self) -> i32 {
        self.source.unwrap_or(0)
    }
    pub fn clear_source(&mut self) {
        self.source = ::std::option::Option::None;
    }

    pub fn has_source(&self) -> bool {
        self.source.is_some()
    }

    // Param is passed by value, moved
    pub fn set_source(&mut self, v: i32) {
        self.source = ::std::option::Option::Some(v);
    }

    // optional int32 target = 101;


    pub fn get_target(&self) -> i32 {
        self.target.unwrap_or(0)
    }
    pub fn clear_target(&mut self) {
        self.target = ::std::option::Option::None;
    }

    pub fn has_target(&self) -> bool {
        self.target.is_some()
    }

    // Param is passed by value, moved
    pub fn set_target(&mut self, v: i32) {
        self.target = ::std::option::Option::Some(v);
    }

    // optional bytes data = 1;


    pub fn get_data(&self) -> &[u8] {
        match self.data.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_data(&mut self) {
        self.data.clear();
    }

    pub fn has_data(&self) -> bool {
        self.data.is_some()
    }

    // Param is passed by value, moved
    pub fn set_data(&mut self, v: ::std::vec::Vec<u8>) {
        self.data = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_data(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.data.is_none() {
            self.data.set_default();
        }
        self.data.as_mut().unwrap()
    }

    // Take field
    pub fn take_data(&mut self) -> ::std::vec::Vec<u8> {
        self.data.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional int32 id = 2;


    pub fn get_id(&self) -> i32 {
        self.id.unwrap_or(0)
    }
    pub fn clear_id(&mut self) {
        self.id = ::std::option::Option::None;
    }

    pub fn has_id(&self) -> bool {
        self.id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_id(&mut self, v: i32) {
        self.id = ::std::option::Option::Some(v);
    }

    // optional .RICS_Data.RICS_DataType type = 3;


    pub fn get_field_type(&self) -> RICS_Data_RICS_DataType {
        self.field_type.unwrap_or(RICS_Data_RICS_DataType::RAW)
    }
    pub fn clear_field_type(&mut self) {
        self.field_type = ::std::option::Option::None;
    }

    pub fn has_field_type(&self) -> bool {
        self.field_type.is_some()
    }

    // Param is passed by value, moved
    pub fn set_field_type(&mut self, v: RICS_Data_RICS_DataType) {
        self.field_type = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for RICS_Data {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                100 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.source = ::std::option::Option::Some(tmp);
                },
                101 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.target = ::std::option::Option::Some(tmp);
                },
                1 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.data)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.id = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.field_type, 3, &mut self.unknown_fields)?
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.source {
            my_size += ::protobuf::rt::value_size(100, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.target {
            my_size += ::protobuf::rt::value_size(101, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.data.as_ref() {
            my_size += ::protobuf::rt::bytes_size(1, &v);
        }
        if let Some(v) = self.id {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.field_type {
            my_size += ::protobuf::rt::enum_size(3, v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.source {
            os.write_int32(100, v)?;
        }
        if let Some(v) = self.target {
            os.write_int32(101, v)?;
        }
        if let Some(ref v) = self.data.as_ref() {
            os.write_bytes(1, &v)?;
        }
        if let Some(v) = self.id {
            os.write_int32(2, v)?;
        }
        if let Some(v) = self.field_type {
            os.write_enum(3, ::protobuf::ProtobufEnum::value(&v))?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "source",
                |m: &RICS_Data| { &m.source },
                |m: &mut RICS_Data| { &mut m.source },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "target",
                |m: &RICS_Data| { &m.target },
                |m: &mut RICS_Data| { &mut m.target },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "data",
                |m: &RICS_Data| { &m.data },
                |m: &mut RICS_Data| { &mut m.data },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "id",
                |m: &RICS_Data| { &m.id },
                |m: &mut RICS_Data| { &mut m.id },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RICS_Data_RICS_DataType>>(
                "type",
                |m: &RICS_Data| { &m.field_type },
                |m: &mut RICS_Data| { &mut m.field_type },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<RICS_Data>(
                "RICS_Data",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for RICS_Data {
    fn clear(&mut self) {
        self.source = ::std::option::Option::None;
        self.target = ::std::option::Option::None;
        self.data.clear();
        self.id = ::std::option::Option::None;
        self.field_type = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for RICS_Data {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum RICS_Data_RICS_DataType {
    RAW = 0,
    STREAM = 1,
    CAN = 2,
    DATAGRAM = 3,
    SYNC = 4,
}

impl ::protobuf::ProtobufEnum for RICS_Data_RICS_DataType {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<RICS_Data_RICS_DataType> {
        match value {
            0 => ::std::option::Option::Some(RICS_Data_RICS_DataType::RAW),
            1 => ::std::option::Option::Some(RICS_Data_RICS_DataType::STREAM),
            2 => ::std::option::Option::Some(RICS_Data_RICS_DataType::CAN),
            3 => ::std::option::Option::Some(RICS_Data_RICS_DataType::DATAGRAM),
            4 => ::std::option::Option::Some(RICS_Data_RICS_DataType::SYNC),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [RICS_Data_RICS_DataType] = &[
            RICS_Data_RICS_DataType::RAW,
            RICS_Data_RICS_DataType::STREAM,
            RICS_Data_RICS_DataType::CAN,
            RICS_Data_RICS_DataType::DATAGRAM,
            RICS_Data_RICS_DataType::SYNC,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<RICS_Data_RICS_DataType>("RICS_Data.RICS_DataType", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for RICS_Data_RICS_DataType {
}

impl ::std::default::Default for RICS_Data_RICS_DataType {
    fn default() -> Self {
        RICS_Data_RICS_DataType::RAW
    }
}

impl ::protobuf::reflect::ProtobufValue for RICS_Data_RICS_DataType {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct RICS_Route {
    // message fields
    from: ::std::option::Option<i32>,
    to: ::std::option::Option<i32>,
    bidirectional: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // optional int32 from = 1;


    pub fn get_from(&self) -> i32 {
        self.from.unwrap_or(0)
    }
    pub fn clear_from(&mut self) {
        self.from = ::std::option::Option::None;
    }

    pub fn has_from(&self) -> bool {
        self.from.is_some()
    }

    // Param is passed by value, moved
    pub fn set_from(&mut self, v: i32) {
        self.from = ::std::option::Option::Some(v);
    }

    // optional int32 to = 2;


    pub fn get_to(&self) -> i32 {
        self.to.unwrap_or(0)
    }
    pub fn clear_to(&mut self) {
        self.to = ::std::option::Option::None;
    }

    pub fn has_to(&self) -> bool {
        self.to.is_some()
    }

    // Param is passed by value, moved
    pub fn set_to(&mut self, v: i32) {
        self.to = ::std::option::Option::Some(v);
    }

    // optional bool bidirectional = 3;


    pub fn get_bidirectional(&self) -> bool {
        self.bidirectional.unwrap_or(false)
    }
    pub fn clear_bidirectional(&mut self) {
        self.bidirectional = ::std::option::Option::None;
    }

    pub fn has_bidirectional(&self) -> bool {
        self.bidirectional.is_some()
    }

    // Param is passed by value, moved
    pub fn set_bidirectional(&mut self, v: bool) {
        self.bidirectional = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for RICS_Route {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.from = ::std::option::Option::Some(tmp);
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.to = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.bidirectional = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.from {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.to {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.bidirectional {
            my_size += 2;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.from {
            os.write_int32(1, v)?;
        }
        if let Some(v) = self.to {
            os.write_int32(2, v)?;
        }
        if let Some(v) = self.bidirectional {
            os.write_bool(3, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "from",
                |m: &RICS_Route| { &m.from },
                |m: &mut RICS_Route| { &mut m.from },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "to",
                |m: &RICS_Route| { &m.to },
                |m: &mut RICS_Route| { &mut m.to },
            ));
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "bidirectional",
                |m: &RICS_Route| { &m.bidirectional },
                |m: &mut RICS_Route| { &mut m.bidirectional },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<RICS_Route>(
                "RICS_Route",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for RICS_Route {
    fn clear(&mut self) {
        self.from = ::std::option::Option::None;
        self.to = ::std::option::Option::None;
        self.bidirectional = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for RICS_Route {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct RICS_Request {
    // message oneof groups
    pub content: ::std::option::Option<RICS_Request_oneof_content>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

#[derive(Clone,PartialEq,Debug)]
pub enum RICS_Request_oneof_content {
    set_name(::std::string::String),
    query(RICS_Request_RICS_Query),
    data(RICS_Data),
    add_route(RICS_Route),
    del_route(RICS_Route),
    can_drop_chance(f32),
}

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

    // optional string set_name = 2;


    pub fn get_set_name(&self) -> &str {
        match self.content {
            ::std::option::Option::Some(RICS_Request_oneof_content::set_name(ref v)) => v,
            _ => "",
        }
    }
    pub fn clear_set_name(&mut self) {
        self.content = ::std::option::Option::None;
    }

    pub fn has_set_name(&self) -> bool {
        match self.content {
            ::std::option::Option::Some(RICS_Request_oneof_content::set_name(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_set_name(&mut self, v: ::std::string::String) {
        self.content = ::std::option::Option::Some(RICS_Request_oneof_content::set_name(v))
    }

    // Mutable pointer to the field.
    pub fn mut_set_name(&mut self) -> &mut ::std::string::String {
        if let ::std::option::Option::Some(RICS_Request_oneof_content::set_name(_)) = self.content {
        } else {
            self.content = ::std::option::Option::Some(RICS_Request_oneof_content::set_name(::std::string::String::new()));
        }
        match self.content {
            ::std::option::Option::Some(RICS_Request_oneof_content::set_name(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_set_name(&mut self) -> ::std::string::String {
        if self.has_set_name() {
            match self.content.take() {
                ::std::option::Option::Some(RICS_Request_oneof_content::set_name(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::string::String::new()
        }
    }

    // optional .RICS_Request.RICS_Query query = 3;


    pub fn get_query(&self) -> RICS_Request_RICS_Query {
        match self.content {
            ::std::option::Option::Some(RICS_Request_oneof_content::query(v)) => v,
            _ => RICS_Request_RICS_Query::NULL,
        }
    }
    pub fn clear_query(&mut self) {
        self.content = ::std::option::Option::None;
    }

    pub fn has_query(&self) -> bool {
        match self.content {
            ::std::option::Option::Some(RICS_Request_oneof_content::query(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_query(&mut self, v: RICS_Request_RICS_Query) {
        self.content = ::std::option::Option::Some(RICS_Request_oneof_content::query(v))
    }

    // optional .RICS_Data data = 4;


    pub fn get_data(&self) -> &RICS_Data {
        match self.content {
            ::std::option::Option::Some(RICS_Request_oneof_content::data(ref v)) => v,
            _ => <RICS_Data as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_data(&mut self) {
        self.content = ::std::option::Option::None;
    }

    pub fn has_data(&self) -> bool {
        match self.content {
            ::std::option::Option::Some(RICS_Request_oneof_content::data(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_data(&mut self, v: RICS_Data) {
        self.content = ::std::option::Option::Some(RICS_Request_oneof_content::data(v))
    }

    // Mutable pointer to the field.
    pub fn mut_data(&mut self) -> &mut RICS_Data {
        if let ::std::option::Option::Some(RICS_Request_oneof_content::data(_)) = self.content {
        } else {
            self.content = ::std::option::Option::Some(RICS_Request_oneof_content::data(RICS_Data::new()));
        }
        match self.content {
            ::std::option::Option::Some(RICS_Request_oneof_content::data(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_data(&mut self) -> RICS_Data {
        if self.has_data() {
            match self.content.take() {
                ::std::option::Option::Some(RICS_Request_oneof_content::data(v)) => v,
                _ => panic!(),
            }
        } else {
            RICS_Data::new()
        }
    }

    // optional .RICS_Route add_route = 5;


    pub fn get_add_route(&self) -> &RICS_Route {
        match self.content {
            ::std::option::Option::Some(RICS_Request_oneof_content::add_route(ref v)) => v,
            _ => <RICS_Route as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_add_route(&mut self) {
        self.content = ::std::option::Option::None;
    }

    pub fn has_add_route(&self) -> bool {
        match self.content {
            ::std::option::Option::Some(RICS_Request_oneof_content::add_route(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_add_route(&mut self, v: RICS_Route) {
        self.content = ::std::option::Option::Some(RICS_Request_oneof_content::add_route(v))
    }

    // Mutable pointer to the field.
    pub fn mut_add_route(&mut self) -> &mut RICS_Route {
        if let ::std::option::Option::Some(RICS_Request_oneof_content::add_route(_)) = self.content {
        } else {
            self.content = ::std::option::Option::Some(RICS_Request_oneof_content::add_route(RICS_Route::new()));
        }
        match self.content {
            ::std::option::Option::Some(RICS_Request_oneof_content::add_route(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_add_route(&mut self) -> RICS_Route {
        if self.has_add_route() {
            match self.content.take() {
                ::std::option::Option::Some(RICS_Request_oneof_content::add_route(v)) => v,
                _ => panic!(),
            }
        } else {
            RICS_Route::new()
        }
    }

    // optional .RICS_Route del_route = 6;


    pub fn get_del_route(&self) -> &RICS_Route {
        match self.content {
            ::std::option::Option::Some(RICS_Request_oneof_content::del_route(ref v)) => v,
            _ => <RICS_Route as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_del_route(&mut self) {
        self.content = ::std::option::Option::None;
    }

    pub fn has_del_route(&self) -> bool {
        match self.content {
            ::std::option::Option::Some(RICS_Request_oneof_content::del_route(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_del_route(&mut self, v: RICS_Route) {
        self.content = ::std::option::Option::Some(RICS_Request_oneof_content::del_route(v))
    }

    // Mutable pointer to the field.
    pub fn mut_del_route(&mut self) -> &mut RICS_Route {
        if let ::std::option::Option::Some(RICS_Request_oneof_content::del_route(_)) = self.content {
        } else {
            self.content = ::std::option::Option::Some(RICS_Request_oneof_content::del_route(RICS_Route::new()));
        }
        match self.content {
            ::std::option::Option::Some(RICS_Request_oneof_content::del_route(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_del_route(&mut self) -> RICS_Route {
        if self.has_del_route() {
            match self.content.take() {
                ::std::option::Option::Some(RICS_Request_oneof_content::del_route(v)) => v,
                _ => panic!(),
            }
        } else {
            RICS_Route::new()
        }
    }

    // optional float can_drop_chance = 7;


    pub fn get_can_drop_chance(&self) -> f32 {
        match self.content {
            ::std::option::Option::Some(RICS_Request_oneof_content::can_drop_chance(v)) => v,
            _ => 0.,
        }
    }
    pub fn clear_can_drop_chance(&mut self) {
        self.content = ::std::option::Option::None;
    }

    pub fn has_can_drop_chance(&self) -> bool {
        match self.content {
            ::std::option::Option::Some(RICS_Request_oneof_content::can_drop_chance(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_can_drop_chance(&mut self, v: f32) {
        self.content = ::std::option::Option::Some(RICS_Request_oneof_content::can_drop_chance(v))
    }
}

impl ::protobuf::Message for RICS_Request {
    fn is_initialized(&self) -> bool {
        if let Some(RICS_Request_oneof_content::data(ref v)) = self.content {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(RICS_Request_oneof_content::add_route(ref v)) = self.content {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(RICS_Request_oneof_content::del_route(ref v)) = self.content {
            if !v.is_initialized() {
                return false;
            }
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.content = ::std::option::Option::Some(RICS_Request_oneof_content::set_name(is.read_string()?));
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.content = ::std::option::Option::Some(RICS_Request_oneof_content::query(is.read_enum()?));
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.content = ::std::option::Option::Some(RICS_Request_oneof_content::data(is.read_message()?));
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.content = ::std::option::Option::Some(RICS_Request_oneof_content::add_route(is.read_message()?));
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.content = ::std::option::Option::Some(RICS_Request_oneof_content::del_route(is.read_message()?));
                },
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.content = ::std::option::Option::Some(RICS_Request_oneof_content::can_drop_chance(is.read_float()?));
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.content {
            match v {
                &RICS_Request_oneof_content::set_name(ref v) => {
                    my_size += ::protobuf::rt::string_size(2, &v);
                },
                &RICS_Request_oneof_content::query(v) => {
                    my_size += ::protobuf::rt::enum_size(3, v);
                },
                &RICS_Request_oneof_content::data(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &RICS_Request_oneof_content::add_route(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &RICS_Request_oneof_content::del_route(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &RICS_Request_oneof_content::can_drop_chance(v) => {
                    my_size += 5;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let ::std::option::Option::Some(ref v) = self.content {
            match v {
                &RICS_Request_oneof_content::set_name(ref v) => {
                    os.write_string(2, v)?;
                },
                &RICS_Request_oneof_content::query(v) => {
                    os.write_enum(3, ::protobuf::ProtobufEnum::value(&v))?;
                },
                &RICS_Request_oneof_content::data(ref v) => {
                    os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &RICS_Request_oneof_content::add_route(ref v) => {
                    os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &RICS_Request_oneof_content::del_route(ref v) => {
                    os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &RICS_Request_oneof_content::can_drop_chance(v) => {
                    os.write_float(7, v)?;
                },
            };
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
                "set_name",
                RICS_Request::has_set_name,
                RICS_Request::get_set_name,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor::<_, RICS_Request_RICS_Query>(
                "query",
                RICS_Request::has_query,
                RICS_Request::get_query,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, RICS_Data>(
                "data",
                RICS_Request::has_data,
                RICS_Request::get_data,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, RICS_Route>(
                "add_route",
                RICS_Request::has_add_route,
                RICS_Request::get_add_route,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, RICS_Route>(
                "del_route",
                RICS_Request::has_del_route,
                RICS_Request::get_del_route,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_f32_accessor::<_>(
                "can_drop_chance",
                RICS_Request::has_can_drop_chance,
                RICS_Request::get_can_drop_chance,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<RICS_Request>(
                "RICS_Request",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for RICS_Request {
    fn clear(&mut self) {
        self.content = ::std::option::Option::None;
        self.content = ::std::option::Option::None;
        self.content = ::std::option::Option::None;
        self.content = ::std::option::Option::None;
        self.content = ::std::option::Option::None;
        self.content = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for RICS_Request {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum RICS_Request_RICS_Query {
    NULL = 0,
    LIST_SINK = 1,
    WHO_AM_I = 2,
    SET_FLAG_CAN_BROADCAST = 3,
    CLEAR_FLAG_CAN_BROADCAST = 4,
    DAEMON_QUIT = 255,
}

impl ::protobuf::ProtobufEnum for RICS_Request_RICS_Query {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<RICS_Request_RICS_Query> {
        match value {
            0 => ::std::option::Option::Some(RICS_Request_RICS_Query::NULL),
            1 => ::std::option::Option::Some(RICS_Request_RICS_Query::LIST_SINK),
            2 => ::std::option::Option::Some(RICS_Request_RICS_Query::WHO_AM_I),
            3 => ::std::option::Option::Some(RICS_Request_RICS_Query::SET_FLAG_CAN_BROADCAST),
            4 => ::std::option::Option::Some(RICS_Request_RICS_Query::CLEAR_FLAG_CAN_BROADCAST),
            255 => ::std::option::Option::Some(RICS_Request_RICS_Query::DAEMON_QUIT),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [RICS_Request_RICS_Query] = &[
            RICS_Request_RICS_Query::NULL,
            RICS_Request_RICS_Query::LIST_SINK,
            RICS_Request_RICS_Query::WHO_AM_I,
            RICS_Request_RICS_Query::SET_FLAG_CAN_BROADCAST,
            RICS_Request_RICS_Query::CLEAR_FLAG_CAN_BROADCAST,
            RICS_Request_RICS_Query::DAEMON_QUIT,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<RICS_Request_RICS_Query>("RICS_Request.RICS_Query", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for RICS_Request_RICS_Query {
}

impl ::std::default::Default for RICS_Request_RICS_Query {
    fn default() -> Self {
        RICS_Request_RICS_Query::NULL
    }
}

impl ::protobuf::reflect::ProtobufValue for RICS_Request_RICS_Query {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct RICS_Response {
    // message oneof groups
    pub content: ::std::option::Option<RICS_Response_oneof_content>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

#[derive(Clone,PartialEq,Debug)]
pub enum RICS_Response_oneof_content {
    idlist(RICS_Response_RICS_IdList),
    node(i32),
    data(RICS_Data),
}

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

    // optional .RICS_Response.RICS_IdList idlist = 1;


    pub fn get_idlist(&self) -> &RICS_Response_RICS_IdList {
        match self.content {
            ::std::option::Option::Some(RICS_Response_oneof_content::idlist(ref v)) => v,
            _ => <RICS_Response_RICS_IdList as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_idlist(&mut self) {
        self.content = ::std::option::Option::None;
    }

    pub fn has_idlist(&self) -> bool {
        match self.content {
            ::std::option::Option::Some(RICS_Response_oneof_content::idlist(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_idlist(&mut self, v: RICS_Response_RICS_IdList) {
        self.content = ::std::option::Option::Some(RICS_Response_oneof_content::idlist(v))
    }

    // Mutable pointer to the field.
    pub fn mut_idlist(&mut self) -> &mut RICS_Response_RICS_IdList {
        if let ::std::option::Option::Some(RICS_Response_oneof_content::idlist(_)) = self.content {
        } else {
            self.content = ::std::option::Option::Some(RICS_Response_oneof_content::idlist(RICS_Response_RICS_IdList::new()));
        }
        match self.content {
            ::std::option::Option::Some(RICS_Response_oneof_content::idlist(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_idlist(&mut self) -> RICS_Response_RICS_IdList {
        if self.has_idlist() {
            match self.content.take() {
                ::std::option::Option::Some(RICS_Response_oneof_content::idlist(v)) => v,
                _ => panic!(),
            }
        } else {
            RICS_Response_RICS_IdList::new()
        }
    }

    // optional int32 node = 2;


    pub fn get_node(&self) -> i32 {
        match self.content {
            ::std::option::Option::Some(RICS_Response_oneof_content::node(v)) => v,
            _ => 0,
        }
    }
    pub fn clear_node(&mut self) {
        self.content = ::std::option::Option::None;
    }

    pub fn has_node(&self) -> bool {
        match self.content {
            ::std::option::Option::Some(RICS_Response_oneof_content::node(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_node(&mut self, v: i32) {
        self.content = ::std::option::Option::Some(RICS_Response_oneof_content::node(v))
    }

    // optional .RICS_Data data = 4;


    pub fn get_data(&self) -> &RICS_Data {
        match self.content {
            ::std::option::Option::Some(RICS_Response_oneof_content::data(ref v)) => v,
            _ => <RICS_Data as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_data(&mut self) {
        self.content = ::std::option::Option::None;
    }

    pub fn has_data(&self) -> bool {
        match self.content {
            ::std::option::Option::Some(RICS_Response_oneof_content::data(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_data(&mut self, v: RICS_Data) {
        self.content = ::std::option::Option::Some(RICS_Response_oneof_content::data(v))
    }

    // Mutable pointer to the field.
    pub fn mut_data(&mut self) -> &mut RICS_Data {
        if let ::std::option::Option::Some(RICS_Response_oneof_content::data(_)) = self.content {
        } else {
            self.content = ::std::option::Option::Some(RICS_Response_oneof_content::data(RICS_Data::new()));
        }
        match self.content {
            ::std::option::Option::Some(RICS_Response_oneof_content::data(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_data(&mut self) -> RICS_Data {
        if self.has_data() {
            match self.content.take() {
                ::std::option::Option::Some(RICS_Response_oneof_content::data(v)) => v,
                _ => panic!(),
            }
        } else {
            RICS_Data::new()
        }
    }
}

impl ::protobuf::Message for RICS_Response {
    fn is_initialized(&self) -> bool {
        if let Some(RICS_Response_oneof_content::idlist(ref v)) = self.content {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(RICS_Response_oneof_content::data(ref v)) = self.content {
            if !v.is_initialized() {
                return false;
            }
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.content = ::std::option::Option::Some(RICS_Response_oneof_content::idlist(is.read_message()?));
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.content = ::std::option::Option::Some(RICS_Response_oneof_content::node(is.read_int32()?));
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.content = ::std::option::Option::Some(RICS_Response_oneof_content::data(is.read_message()?));
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.content {
            match v {
                &RICS_Response_oneof_content::idlist(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &RICS_Response_oneof_content::node(v) => {
                    my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
                },
                &RICS_Response_oneof_content::data(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let ::std::option::Option::Some(ref v) = self.content {
            match v {
                &RICS_Response_oneof_content::idlist(ref v) => {
                    os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &RICS_Response_oneof_content::node(v) => {
                    os.write_int32(2, v)?;
                },
                &RICS_Response_oneof_content::data(ref v) => {
                    os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
            };
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, RICS_Response_RICS_IdList>(
                "idlist",
                RICS_Response::has_idlist,
                RICS_Response::get_idlist,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor::<_>(
                "node",
                RICS_Response::has_node,
                RICS_Response::get_node,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, RICS_Data>(
                "data",
                RICS_Response::has_data,
                RICS_Response::get_data,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<RICS_Response>(
                "RICS_Response",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for RICS_Response {
    fn clear(&mut self) {
        self.content = ::std::option::Option::None;
        self.content = ::std::option::Option::None;
        self.content = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for RICS_Response {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct RICS_Response_RICS_Id {
    // message fields
    id: ::std::option::Option<i32>,
    name: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // required int32 id = 1;


    pub fn get_id(&self) -> i32 {
        self.id.unwrap_or(0)
    }
    pub fn clear_id(&mut self) {
        self.id = ::std::option::Option::None;
    }

    pub fn has_id(&self) -> bool {
        self.id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_id(&mut self, v: i32) {
        self.id = ::std::option::Option::Some(v);
    }

    // optional string name = 2;


    pub fn get_name(&self) -> &str {
        match self.name.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

    pub fn has_name(&self) -> bool {
        self.name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        if self.name.is_none() {
            self.name.set_default();
        }
        self.name.as_mut().unwrap()
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        self.name.take().unwrap_or_else(|| ::std::string::String::new())
    }
}

impl ::protobuf::Message for RICS_Response_RICS_Id {
    fn is_initialized(&self) -> bool {
        if self.id.is_none() {
            return false;
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.id = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.id {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.id {
            os.write_int32(1, v)?;
        }
        if let Some(ref v) = self.name.as_ref() {
            os.write_string(2, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "id",
                |m: &RICS_Response_RICS_Id| { &m.id },
                |m: &mut RICS_Response_RICS_Id| { &mut m.id },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "name",
                |m: &RICS_Response_RICS_Id| { &m.name },
                |m: &mut RICS_Response_RICS_Id| { &mut m.name },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<RICS_Response_RICS_Id>(
                "RICS_Response.RICS_Id",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for RICS_Response_RICS_Id {
    fn clear(&mut self) {
        self.id = ::std::option::Option::None;
        self.name.clear();
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for RICS_Response_RICS_Id {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct RICS_Response_RICS_IdList {
    // message fields
    pub ids: ::protobuf::RepeatedField<RICS_Response_RICS_Id>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .RICS_Response.RICS_Id ids = 1;


    pub fn get_ids(&self) -> &[RICS_Response_RICS_Id] {
        &self.ids
    }
    pub fn clear_ids(&mut self) {
        self.ids.clear();
    }

    // Param is passed by value, moved
    pub fn set_ids(&mut self, v: ::protobuf::RepeatedField<RICS_Response_RICS_Id>) {
        self.ids = v;
    }

    // Mutable pointer to the field.
    pub fn mut_ids(&mut self) -> &mut ::protobuf::RepeatedField<RICS_Response_RICS_Id> {
        &mut self.ids
    }

    // Take field
    pub fn take_ids(&mut self) -> ::protobuf::RepeatedField<RICS_Response_RICS_Id> {
        ::std::mem::replace(&mut self.ids, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for RICS_Response_RICS_IdList {
    fn is_initialized(&self) -> bool {
        for v in &self.ids {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.ids)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.ids {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<RICS_Response_RICS_Id>>(
                "ids",
                |m: &RICS_Response_RICS_IdList| { &m.ids },
                |m: &mut RICS_Response_RICS_IdList| { &mut m.ids },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<RICS_Response_RICS_IdList>(
                "RICS_Response.RICS_IdList",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for RICS_Response_RICS_IdList {
    fn clear(&mut self) {
        self.ids.clear();
        self.unknown_fields.clear();
    }
}

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

impl ::protobuf::reflect::ProtobufValue for RICS_Response_RICS_IdList {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\nrics.proto\"9\n\x0fRICS_Connection\x12&\n\x0fconnect_as_node\x18\x01\
    \x20\x01(\x08R\rconnectAsNode\"\xdc\x01\n\tRICS_Data\x12\x16\n\x06source\
    \x18d\x20\x01(\x05R\x06source\x12\x16\n\x06target\x18e\x20\x01(\x05R\x06\
    target\x12\x12\n\x04data\x18\x01\x20\x01(\x0cR\x04data\x12\x0e\n\x02id\
    \x18\x02\x20\x01(\x05R\x02id\x12,\n\x04type\x18\x03\x20\x01(\x0e2\x18.RI\
    CS_Data.RICS_DataTypeR\x04type\"E\n\rRICS_DataType\x12\x07\n\x03RAW\x10\
    \0\x12\n\n\x06STREAM\x10\x01\x12\x07\n\x03CAN\x10\x02\x12\x0c\n\x08DATAG\
    RAM\x10\x03\x12\x08\n\x04SYNC\x10\x04*\x06\x08\xc8\x01\x10\xac\x02\"V\n\
    \nRICS_Route\x12\x12\n\x04from\x18\x01\x20\x01(\x05R\x04from\x12\x0e\n\
    \x02to\x18\x02\x20\x01(\x05R\x02to\x12$\n\rbidirectional\x18\x03\x20\x01\
    (\x08R\rbidirectional\"\x8d\x03\n\x0cRICS_Request\x12\x1b\n\x08set_name\
    \x18\x02\x20\x01(\tH\0R\x07setName\x120\n\x05query\x18\x03\x20\x01(\x0e2\
    \x18.RICS_Request.RICS_QueryH\0R\x05query\x12\x20\n\x04data\x18\x04\x20\
    \x01(\x0b2\n.RICS_DataH\0R\x04data\x12*\n\tadd_route\x18\x05\x20\x01(\
    \x0b2\x0b.RICS_RouteH\0R\x08addRoute\x12*\n\tdel_route\x18\x06\x20\x01(\
    \x0b2\x0b.RICS_RouteH\0R\x08delRoute\x12(\n\x0fcan_drop_chance\x18\x07\
    \x20\x01(\x02H\0R\rcanDropChance\"\x7f\n\nRICS_Query\x12\x08\n\x04NULL\
    \x10\0\x12\r\n\tLIST_SINK\x10\x01\x12\x0c\n\x08WHO_AM_I\x10\x02\x12\x1a\
    \n\x16SET_FLAG_CAN_BROADCAST\x10\x03\x12\x1c\n\x18CLEAR_FLAG_CAN_BROADCA\
    ST\x10\x04\x12\x10\n\x0bDAEMON_QUIT\x10\xff\x01B\t\n\x07content\"\xf0\
    \x01\n\rRICS_Response\x124\n\x06idlist\x18\x01\x20\x01(\x0b2\x1a.RICS_Re\
    sponse.RICS_IdListH\0R\x06idlist\x12\x14\n\x04node\x18\x02\x20\x01(\x05H\
    \0R\x04node\x12\x20\n\x04data\x18\x04\x20\x01(\x0b2\n.RICS_DataH\0R\x04d\
    ata\x1a-\n\x07RICS_Id\x12\x0e\n\x02id\x18\x01\x20\x02(\x05R\x02id\x12\
    \x12\n\x04name\x18\x02\x20\x01(\tR\x04name\x1a7\n\x0bRICS_IdList\x12(\n\
    \x03ids\x18\x01\x20\x03(\x0b2\x16.RICS_Response.RICS_IdR\x03idsB\t\n\x07\
    content\
";

static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    file_descriptor_proto_lazy.get(|| {
        parse_descriptor_proto()
    })
}