#![allow(unknown_lints)]
#![allow(clippy::all)]
#![cfg_attr(rustfmt, rustfmt_skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unsafe_code)]
#![allow(unused_imports)]
#![allow(unused_results)]
use protobuf::Message as Message_imported_for_functions;
use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
#[derive(PartialEq,Clone,Default)]
pub struct PoissonParams {
pub offered_load: f64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a PoissonParams {
fn default() -> &'a PoissonParams {
<PoissonParams as ::protobuf::Message>::default_instance()
}
}
impl PoissonParams {
pub fn new() -> PoissonParams {
::std::default::Default::default()
}
pub fn get_offered_load(&self) -> f64 {
self.offered_load
}
pub fn clear_offered_load(&mut self) {
self.offered_load = 0.;
}
pub fn set_offered_load(&mut self, v: f64) {
self.offered_load = v;
}
}
impl ::protobuf::Message for PoissonParams {
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::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.offered_load = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.offered_load != 0. {
my_size += 9;
}
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 self.offered_load != 0. {
os.write_double(1, self.offered_load)?;
}
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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> PoissonParams {
PoissonParams::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"offered_load",
|m: &PoissonParams| { &m.offered_load },
|m: &mut PoissonParams| { &mut m.offered_load },
));
::protobuf::reflect::MessageDescriptor::new::<PoissonParams>(
"PoissonParams",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static PoissonParams {
static mut instance: ::protobuf::lazy::Lazy<PoissonParams> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const PoissonParams,
};
unsafe {
instance.get(PoissonParams::new)
}
}
}
impl ::protobuf::Clear for PoissonParams {
fn clear(&mut self) {
self.offered_load = 0.;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for PoissonParams {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for PoissonParams {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ClosedLoopParams {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ClosedLoopParams {
fn default() -> &'a ClosedLoopParams {
<ClosedLoopParams as ::protobuf::Message>::default_instance()
}
}
impl ClosedLoopParams {
pub fn new() -> ClosedLoopParams {
::std::default::Default::default()
}
}
impl ::protobuf::Message for ClosedLoopParams {
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 {
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
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<()> {
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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ClosedLoopParams {
ClosedLoopParams::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let fields = ::std::vec::Vec::new();
::protobuf::reflect::MessageDescriptor::new::<ClosedLoopParams>(
"ClosedLoopParams",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ClosedLoopParams {
static mut instance: ::protobuf::lazy::Lazy<ClosedLoopParams> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ClosedLoopParams,
};
unsafe {
instance.get(ClosedLoopParams::new)
}
}
}
impl ::protobuf::Clear for ClosedLoopParams {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for ClosedLoopParams {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ClosedLoopParams {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct LoadParams {
pub load: ::std::option::Option<LoadParams_oneof_load>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a LoadParams {
fn default() -> &'a LoadParams {
<LoadParams as ::protobuf::Message>::default_instance()
}
}
#[derive(Clone,PartialEq,Debug)]
pub enum LoadParams_oneof_load {
closed_loop(ClosedLoopParams),
poisson(PoissonParams),
}
impl LoadParams {
pub fn new() -> LoadParams {
::std::default::Default::default()
}
pub fn get_closed_loop(&self) -> &ClosedLoopParams {
match self.load {
::std::option::Option::Some(LoadParams_oneof_load::closed_loop(ref v)) => v,
_ => ClosedLoopParams::default_instance(),
}
}
pub fn clear_closed_loop(&mut self) {
self.load = ::std::option::Option::None;
}
pub fn has_closed_loop(&self) -> bool {
match self.load {
::std::option::Option::Some(LoadParams_oneof_load::closed_loop(..)) => true,
_ => false,
}
}
pub fn set_closed_loop(&mut self, v: ClosedLoopParams) {
self.load = ::std::option::Option::Some(LoadParams_oneof_load::closed_loop(v))
}
pub fn mut_closed_loop(&mut self) -> &mut ClosedLoopParams {
if let ::std::option::Option::Some(LoadParams_oneof_load::closed_loop(_)) = self.load {
} else {
self.load = ::std::option::Option::Some(LoadParams_oneof_load::closed_loop(ClosedLoopParams::new()));
}
match self.load {
::std::option::Option::Some(LoadParams_oneof_load::closed_loop(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_closed_loop(&mut self) -> ClosedLoopParams {
if self.has_closed_loop() {
match self.load.take() {
::std::option::Option::Some(LoadParams_oneof_load::closed_loop(v)) => v,
_ => panic!(),
}
} else {
ClosedLoopParams::new()
}
}
pub fn get_poisson(&self) -> &PoissonParams {
match self.load {
::std::option::Option::Some(LoadParams_oneof_load::poisson(ref v)) => v,
_ => PoissonParams::default_instance(),
}
}
pub fn clear_poisson(&mut self) {
self.load = ::std::option::Option::None;
}
pub fn has_poisson(&self) -> bool {
match self.load {
::std::option::Option::Some(LoadParams_oneof_load::poisson(..)) => true,
_ => false,
}
}
pub fn set_poisson(&mut self, v: PoissonParams) {
self.load = ::std::option::Option::Some(LoadParams_oneof_load::poisson(v))
}
pub fn mut_poisson(&mut self) -> &mut PoissonParams {
if let ::std::option::Option::Some(LoadParams_oneof_load::poisson(_)) = self.load {
} else {
self.load = ::std::option::Option::Some(LoadParams_oneof_load::poisson(PoissonParams::new()));
}
match self.load {
::std::option::Option::Some(LoadParams_oneof_load::poisson(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_poisson(&mut self) -> PoissonParams {
if self.has_poisson() {
match self.load.take() {
::std::option::Option::Some(LoadParams_oneof_load::poisson(v)) => v,
_ => panic!(),
}
} else {
PoissonParams::new()
}
}
}
impl ::protobuf::Message for LoadParams {
fn is_initialized(&self) -> bool {
if let Some(LoadParams_oneof_load::closed_loop(ref v)) = self.load {
if !v.is_initialized() {
return false;
}
}
if let Some(LoadParams_oneof_load::poisson(ref v)) = self.load {
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.load = ::std::option::Option::Some(LoadParams_oneof_load::closed_loop(is.read_message()?));
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.load = ::std::option::Option::Some(LoadParams_oneof_load::poisson(is.read_message()?));
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let ::std::option::Option::Some(ref v) = self.load {
match v {
&LoadParams_oneof_load::closed_loop(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&LoadParams_oneof_load::poisson(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.load {
match v {
&LoadParams_oneof_load::closed_loop(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)?;
},
&LoadParams_oneof_load::poisson(ref v) => {
os.write_tag(2, ::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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> LoadParams {
LoadParams::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ClosedLoopParams>(
"closed_loop",
LoadParams::has_closed_loop,
LoadParams::get_closed_loop,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, PoissonParams>(
"poisson",
LoadParams::has_poisson,
LoadParams::get_poisson,
));
::protobuf::reflect::MessageDescriptor::new::<LoadParams>(
"LoadParams",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static LoadParams {
static mut instance: ::protobuf::lazy::Lazy<LoadParams> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const LoadParams,
};
unsafe {
instance.get(LoadParams::new)
}
}
}
impl ::protobuf::Clear for LoadParams {
fn clear(&mut self) {
self.load = ::std::option::Option::None;
self.load = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for LoadParams {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for LoadParams {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SecurityParams {
pub use_test_ca: bool,
pub server_host_override: ::std::string::String,
pub cred_type: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SecurityParams {
fn default() -> &'a SecurityParams {
<SecurityParams as ::protobuf::Message>::default_instance()
}
}
impl SecurityParams {
pub fn new() -> SecurityParams {
::std::default::Default::default()
}
pub fn get_use_test_ca(&self) -> bool {
self.use_test_ca
}
pub fn clear_use_test_ca(&mut self) {
self.use_test_ca = false;
}
pub fn set_use_test_ca(&mut self, v: bool) {
self.use_test_ca = v;
}
pub fn get_server_host_override(&self) -> &str {
&self.server_host_override
}
pub fn clear_server_host_override(&mut self) {
self.server_host_override.clear();
}
pub fn set_server_host_override(&mut self, v: ::std::string::String) {
self.server_host_override = v;
}
pub fn mut_server_host_override(&mut self) -> &mut ::std::string::String {
&mut self.server_host_override
}
pub fn take_server_host_override(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.server_host_override, ::std::string::String::new())
}
pub fn get_cred_type(&self) -> &str {
&self.cred_type
}
pub fn clear_cred_type(&mut self) {
self.cred_type.clear();
}
pub fn set_cred_type(&mut self, v: ::std::string::String) {
self.cred_type = v;
}
pub fn mut_cred_type(&mut self) -> &mut ::std::string::String {
&mut self.cred_type
}
pub fn take_cred_type(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.cred_type, ::std::string::String::new())
}
}
impl ::protobuf::Message for SecurityParams {
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.use_test_ca = tmp;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.server_host_override)?;
},
3 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.cred_type)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.use_test_ca != false {
my_size += 2;
}
if !self.server_host_override.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.server_host_override);
}
if !self.cred_type.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.cred_type);
}
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 self.use_test_ca != false {
os.write_bool(1, self.use_test_ca)?;
}
if !self.server_host_override.is_empty() {
os.write_string(2, &self.server_host_override)?;
}
if !self.cred_type.is_empty() {
os.write_string(3, &self.cred_type)?;
}
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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> SecurityParams {
SecurityParams::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"use_test_ca",
|m: &SecurityParams| { &m.use_test_ca },
|m: &mut SecurityParams| { &mut m.use_test_ca },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"server_host_override",
|m: &SecurityParams| { &m.server_host_override },
|m: &mut SecurityParams| { &mut m.server_host_override },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"cred_type",
|m: &SecurityParams| { &m.cred_type },
|m: &mut SecurityParams| { &mut m.cred_type },
));
::protobuf::reflect::MessageDescriptor::new::<SecurityParams>(
"SecurityParams",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static SecurityParams {
static mut instance: ::protobuf::lazy::Lazy<SecurityParams> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const SecurityParams,
};
unsafe {
instance.get(SecurityParams::new)
}
}
}
impl ::protobuf::Clear for SecurityParams {
fn clear(&mut self) {
self.use_test_ca = false;
self.server_host_override.clear();
self.cred_type.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SecurityParams {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SecurityParams {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ChannelArg {
pub name: ::std::string::String,
pub value: ::std::option::Option<ChannelArg_oneof_value>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ChannelArg {
fn default() -> &'a ChannelArg {
<ChannelArg as ::protobuf::Message>::default_instance()
}
}
#[derive(Clone,PartialEq,Debug)]
pub enum ChannelArg_oneof_value {
str_value(::std::string::String),
int_value(i32),
}
impl ChannelArg {
pub fn new() -> ChannelArg {
::std::default::Default::default()
}
pub fn get_name(&self) -> &str {
&self.name
}
pub fn clear_name(&mut self) {
self.name.clear();
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = v;
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
&mut self.name
}
pub fn take_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.name, ::std::string::String::new())
}
pub fn get_str_value(&self) -> &str {
match self.value {
::std::option::Option::Some(ChannelArg_oneof_value::str_value(ref v)) => v,
_ => "",
}
}
pub fn clear_str_value(&mut self) {
self.value = ::std::option::Option::None;
}
pub fn has_str_value(&self) -> bool {
match self.value {
::std::option::Option::Some(ChannelArg_oneof_value::str_value(..)) => true,
_ => false,
}
}
pub fn set_str_value(&mut self, v: ::std::string::String) {
self.value = ::std::option::Option::Some(ChannelArg_oneof_value::str_value(v))
}
pub fn mut_str_value(&mut self) -> &mut ::std::string::String {
if let ::std::option::Option::Some(ChannelArg_oneof_value::str_value(_)) = self.value {
} else {
self.value = ::std::option::Option::Some(ChannelArg_oneof_value::str_value(::std::string::String::new()));
}
match self.value {
::std::option::Option::Some(ChannelArg_oneof_value::str_value(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_str_value(&mut self) -> ::std::string::String {
if self.has_str_value() {
match self.value.take() {
::std::option::Option::Some(ChannelArg_oneof_value::str_value(v)) => v,
_ => panic!(),
}
} else {
::std::string::String::new()
}
}
pub fn get_int_value(&self) -> i32 {
match self.value {
::std::option::Option::Some(ChannelArg_oneof_value::int_value(v)) => v,
_ => 0,
}
}
pub fn clear_int_value(&mut self) {
self.value = ::std::option::Option::None;
}
pub fn has_int_value(&self) -> bool {
match self.value {
::std::option::Option::Some(ChannelArg_oneof_value::int_value(..)) => true,
_ => false,
}
}
pub fn set_int_value(&mut self, v: i32) {
self.value = ::std::option::Option::Some(ChannelArg_oneof_value::int_value(v))
}
}
impl ::protobuf::Message for ChannelArg {
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 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.value = ::std::option::Option::Some(ChannelArg_oneof_value::str_value(is.read_string()?));
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.value = ::std::option::Option::Some(ChannelArg_oneof_value::int_value(is.read_int32()?));
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.name.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.name);
}
if let ::std::option::Option::Some(ref v) = self.value {
match v {
&ChannelArg_oneof_value::str_value(ref v) => {
my_size += ::protobuf::rt::string_size(2, &v);
},
&ChannelArg_oneof_value::int_value(v) => {
my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
},
};
}
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 !self.name.is_empty() {
os.write_string(1, &self.name)?;
}
if let ::std::option::Option::Some(ref v) = self.value {
match v {
&ChannelArg_oneof_value::str_value(ref v) => {
os.write_string(2, v)?;
},
&ChannelArg_oneof_value::int_value(v) => {
os.write_int32(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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ChannelArg {
ChannelArg::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"name",
|m: &ChannelArg| { &m.name },
|m: &mut ChannelArg| { &mut m.name },
));
fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
"str_value",
ChannelArg::has_str_value,
ChannelArg::get_str_value,
));
fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor::<_>(
"int_value",
ChannelArg::has_int_value,
ChannelArg::get_int_value,
));
::protobuf::reflect::MessageDescriptor::new::<ChannelArg>(
"ChannelArg",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ChannelArg {
static mut instance: ::protobuf::lazy::Lazy<ChannelArg> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ChannelArg,
};
unsafe {
instance.get(ChannelArg::new)
}
}
}
impl ::protobuf::Clear for ChannelArg {
fn clear(&mut self) {
self.name.clear();
self.value = ::std::option::Option::None;
self.value = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for ChannelArg {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ChannelArg {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ClientConfig {
pub server_targets: ::protobuf::RepeatedField<::std::string::String>,
pub client_type: ClientType,
pub security_params: ::protobuf::SingularPtrField<SecurityParams>,
pub outstanding_rpcs_per_channel: i32,
pub client_channels: i32,
pub async_client_threads: i32,
pub rpc_type: RpcType,
pub load_params: ::protobuf::SingularPtrField<LoadParams>,
pub payload_config: ::protobuf::SingularPtrField<super::payloads::PayloadConfig>,
pub histogram_params: ::protobuf::SingularPtrField<super::stats::HistogramParams>,
pub core_list: ::std::vec::Vec<i32>,
pub core_limit: i32,
pub other_client_api: ::std::string::String,
pub channel_args: ::protobuf::RepeatedField<ChannelArg>,
pub threads_per_cq: i32,
pub messages_per_stream: i32,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ClientConfig {
fn default() -> &'a ClientConfig {
<ClientConfig as ::protobuf::Message>::default_instance()
}
}
impl ClientConfig {
pub fn new() -> ClientConfig {
::std::default::Default::default()
}
pub fn get_server_targets(&self) -> &[::std::string::String] {
&self.server_targets
}
pub fn clear_server_targets(&mut self) {
self.server_targets.clear();
}
pub fn set_server_targets(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
self.server_targets = v;
}
pub fn mut_server_targets(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
&mut self.server_targets
}
pub fn take_server_targets(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
::std::mem::replace(&mut self.server_targets, ::protobuf::RepeatedField::new())
}
pub fn get_client_type(&self) -> ClientType {
self.client_type
}
pub fn clear_client_type(&mut self) {
self.client_type = ClientType::SYNC_CLIENT;
}
pub fn set_client_type(&mut self, v: ClientType) {
self.client_type = v;
}
pub fn get_security_params(&self) -> &SecurityParams {
self.security_params.as_ref().unwrap_or_else(|| SecurityParams::default_instance())
}
pub fn clear_security_params(&mut self) {
self.security_params.clear();
}
pub fn has_security_params(&self) -> bool {
self.security_params.is_some()
}
pub fn set_security_params(&mut self, v: SecurityParams) {
self.security_params = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_security_params(&mut self) -> &mut SecurityParams {
if self.security_params.is_none() {
self.security_params.set_default();
}
self.security_params.as_mut().unwrap()
}
pub fn take_security_params(&mut self) -> SecurityParams {
self.security_params.take().unwrap_or_else(|| SecurityParams::new())
}
pub fn get_outstanding_rpcs_per_channel(&self) -> i32 {
self.outstanding_rpcs_per_channel
}
pub fn clear_outstanding_rpcs_per_channel(&mut self) {
self.outstanding_rpcs_per_channel = 0;
}
pub fn set_outstanding_rpcs_per_channel(&mut self, v: i32) {
self.outstanding_rpcs_per_channel = v;
}
pub fn get_client_channels(&self) -> i32 {
self.client_channels
}
pub fn clear_client_channels(&mut self) {
self.client_channels = 0;
}
pub fn set_client_channels(&mut self, v: i32) {
self.client_channels = v;
}
pub fn get_async_client_threads(&self) -> i32 {
self.async_client_threads
}
pub fn clear_async_client_threads(&mut self) {
self.async_client_threads = 0;
}
pub fn set_async_client_threads(&mut self, v: i32) {
self.async_client_threads = v;
}
pub fn get_rpc_type(&self) -> RpcType {
self.rpc_type
}
pub fn clear_rpc_type(&mut self) {
self.rpc_type = RpcType::UNARY;
}
pub fn set_rpc_type(&mut self, v: RpcType) {
self.rpc_type = v;
}
pub fn get_load_params(&self) -> &LoadParams {
self.load_params.as_ref().unwrap_or_else(|| LoadParams::default_instance())
}
pub fn clear_load_params(&mut self) {
self.load_params.clear();
}
pub fn has_load_params(&self) -> bool {
self.load_params.is_some()
}
pub fn set_load_params(&mut self, v: LoadParams) {
self.load_params = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_load_params(&mut self) -> &mut LoadParams {
if self.load_params.is_none() {
self.load_params.set_default();
}
self.load_params.as_mut().unwrap()
}
pub fn take_load_params(&mut self) -> LoadParams {
self.load_params.take().unwrap_or_else(|| LoadParams::new())
}
pub fn get_payload_config(&self) -> &super::payloads::PayloadConfig {
self.payload_config.as_ref().unwrap_or_else(|| super::payloads::PayloadConfig::default_instance())
}
pub fn clear_payload_config(&mut self) {
self.payload_config.clear();
}
pub fn has_payload_config(&self) -> bool {
self.payload_config.is_some()
}
pub fn set_payload_config(&mut self, v: super::payloads::PayloadConfig) {
self.payload_config = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_payload_config(&mut self) -> &mut super::payloads::PayloadConfig {
if self.payload_config.is_none() {
self.payload_config.set_default();
}
self.payload_config.as_mut().unwrap()
}
pub fn take_payload_config(&mut self) -> super::payloads::PayloadConfig {
self.payload_config.take().unwrap_or_else(|| super::payloads::PayloadConfig::new())
}
pub fn get_histogram_params(&self) -> &super::stats::HistogramParams {
self.histogram_params.as_ref().unwrap_or_else(|| super::stats::HistogramParams::default_instance())
}
pub fn clear_histogram_params(&mut self) {
self.histogram_params.clear();
}
pub fn has_histogram_params(&self) -> bool {
self.histogram_params.is_some()
}
pub fn set_histogram_params(&mut self, v: super::stats::HistogramParams) {
self.histogram_params = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_histogram_params(&mut self) -> &mut super::stats::HistogramParams {
if self.histogram_params.is_none() {
self.histogram_params.set_default();
}
self.histogram_params.as_mut().unwrap()
}
pub fn take_histogram_params(&mut self) -> super::stats::HistogramParams {
self.histogram_params.take().unwrap_or_else(|| super::stats::HistogramParams::new())
}
pub fn get_core_list(&self) -> &[i32] {
&self.core_list
}
pub fn clear_core_list(&mut self) {
self.core_list.clear();
}
pub fn set_core_list(&mut self, v: ::std::vec::Vec<i32>) {
self.core_list = v;
}
pub fn mut_core_list(&mut self) -> &mut ::std::vec::Vec<i32> {
&mut self.core_list
}
pub fn take_core_list(&mut self) -> ::std::vec::Vec<i32> {
::std::mem::replace(&mut self.core_list, ::std::vec::Vec::new())
}
pub fn get_core_limit(&self) -> i32 {
self.core_limit
}
pub fn clear_core_limit(&mut self) {
self.core_limit = 0;
}
pub fn set_core_limit(&mut self, v: i32) {
self.core_limit = v;
}
pub fn get_other_client_api(&self) -> &str {
&self.other_client_api
}
pub fn clear_other_client_api(&mut self) {
self.other_client_api.clear();
}
pub fn set_other_client_api(&mut self, v: ::std::string::String) {
self.other_client_api = v;
}
pub fn mut_other_client_api(&mut self) -> &mut ::std::string::String {
&mut self.other_client_api
}
pub fn take_other_client_api(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.other_client_api, ::std::string::String::new())
}
pub fn get_channel_args(&self) -> &[ChannelArg] {
&self.channel_args
}
pub fn clear_channel_args(&mut self) {
self.channel_args.clear();
}
pub fn set_channel_args(&mut self, v: ::protobuf::RepeatedField<ChannelArg>) {
self.channel_args = v;
}
pub fn mut_channel_args(&mut self) -> &mut ::protobuf::RepeatedField<ChannelArg> {
&mut self.channel_args
}
pub fn take_channel_args(&mut self) -> ::protobuf::RepeatedField<ChannelArg> {
::std::mem::replace(&mut self.channel_args, ::protobuf::RepeatedField::new())
}
pub fn get_threads_per_cq(&self) -> i32 {
self.threads_per_cq
}
pub fn clear_threads_per_cq(&mut self) {
self.threads_per_cq = 0;
}
pub fn set_threads_per_cq(&mut self, v: i32) {
self.threads_per_cq = v;
}
pub fn get_messages_per_stream(&self) -> i32 {
self.messages_per_stream
}
pub fn clear_messages_per_stream(&mut self) {
self.messages_per_stream = 0;
}
pub fn set_messages_per_stream(&mut self, v: i32) {
self.messages_per_stream = v;
}
}
impl ::protobuf::Message for ClientConfig {
fn is_initialized(&self) -> bool {
for v in &self.security_params {
if !v.is_initialized() {
return false;
}
};
for v in &self.load_params {
if !v.is_initialized() {
return false;
}
};
for v in &self.payload_config {
if !v.is_initialized() {
return false;
}
};
for v in &self.histogram_params {
if !v.is_initialized() {
return false;
}
};
for v in &self.channel_args {
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_string_into(wire_type, is, &mut self.server_targets)?;
},
2 => {
::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.client_type, 2, &mut self.unknown_fields)?
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.security_params)?;
},
4 => {
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.outstanding_rpcs_per_channel = tmp;
},
5 => {
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.client_channels = tmp;
},
7 => {
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.async_client_threads = tmp;
},
8 => {
::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.rpc_type, 8, &mut self.unknown_fields)?
},
10 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.load_params)?;
},
11 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.payload_config)?;
},
12 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.histogram_params)?;
},
13 => {
::protobuf::rt::read_repeated_int32_into(wire_type, is, &mut self.core_list)?;
},
14 => {
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.core_limit = tmp;
},
15 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.other_client_api)?;
},
16 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.channel_args)?;
},
17 => {
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.threads_per_cq = tmp;
},
18 => {
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.messages_per_stream = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
for value in &self.server_targets {
my_size += ::protobuf::rt::string_size(1, &value);
};
if self.client_type != ClientType::SYNC_CLIENT {
my_size += ::protobuf::rt::enum_size(2, self.client_type);
}
if let Some(ref v) = self.security_params.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.outstanding_rpcs_per_channel != 0 {
my_size += ::protobuf::rt::value_size(4, self.outstanding_rpcs_per_channel, ::protobuf::wire_format::WireTypeVarint);
}
if self.client_channels != 0 {
my_size += ::protobuf::rt::value_size(5, self.client_channels, ::protobuf::wire_format::WireTypeVarint);
}
if self.async_client_threads != 0 {
my_size += ::protobuf::rt::value_size(7, self.async_client_threads, ::protobuf::wire_format::WireTypeVarint);
}
if self.rpc_type != RpcType::UNARY {
my_size += ::protobuf::rt::enum_size(8, self.rpc_type);
}
if let Some(ref v) = self.load_params.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.payload_config.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.histogram_params.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.core_list {
my_size += ::protobuf::rt::value_size(13, *value, ::protobuf::wire_format::WireTypeVarint);
};
if self.core_limit != 0 {
my_size += ::protobuf::rt::value_size(14, self.core_limit, ::protobuf::wire_format::WireTypeVarint);
}
if !self.other_client_api.is_empty() {
my_size += ::protobuf::rt::string_size(15, &self.other_client_api);
}
for value in &self.channel_args {
let len = value.compute_size();
my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
if self.threads_per_cq != 0 {
my_size += ::protobuf::rt::value_size(17, self.threads_per_cq, ::protobuf::wire_format::WireTypeVarint);
}
if self.messages_per_stream != 0 {
my_size += ::protobuf::rt::value_size(18, self.messages_per_stream, ::protobuf::wire_format::WireTypeVarint);
}
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.server_targets {
os.write_string(1, &v)?;
};
if self.client_type != ClientType::SYNC_CLIENT {
os.write_enum(2, self.client_type.value())?;
}
if let Some(ref v) = self.security_params.as_ref() {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.outstanding_rpcs_per_channel != 0 {
os.write_int32(4, self.outstanding_rpcs_per_channel)?;
}
if self.client_channels != 0 {
os.write_int32(5, self.client_channels)?;
}
if self.async_client_threads != 0 {
os.write_int32(7, self.async_client_threads)?;
}
if self.rpc_type != RpcType::UNARY {
os.write_enum(8, self.rpc_type.value())?;
}
if let Some(ref v) = self.load_params.as_ref() {
os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.payload_config.as_ref() {
os.write_tag(11, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.histogram_params.as_ref() {
os.write_tag(12, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.core_list {
os.write_int32(13, *v)?;
};
if self.core_limit != 0 {
os.write_int32(14, self.core_limit)?;
}
if !self.other_client_api.is_empty() {
os.write_string(15, &self.other_client_api)?;
}
for v in &self.channel_args {
os.write_tag(16, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
if self.threads_per_cq != 0 {
os.write_int32(17, self.threads_per_cq)?;
}
if self.messages_per_stream != 0 {
os.write_int32(18, self.messages_per_stream)?;
}
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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ClientConfig {
ClientConfig::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"server_targets",
|m: &ClientConfig| { &m.server_targets },
|m: &mut ClientConfig| { &mut m.server_targets },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ClientType>>(
"client_type",
|m: &ClientConfig| { &m.client_type },
|m: &mut ClientConfig| { &mut m.client_type },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<SecurityParams>>(
"security_params",
|m: &ClientConfig| { &m.security_params },
|m: &mut ClientConfig| { &mut m.security_params },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"outstanding_rpcs_per_channel",
|m: &ClientConfig| { &m.outstanding_rpcs_per_channel },
|m: &mut ClientConfig| { &mut m.outstanding_rpcs_per_channel },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"client_channels",
|m: &ClientConfig| { &m.client_channels },
|m: &mut ClientConfig| { &mut m.client_channels },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"async_client_threads",
|m: &ClientConfig| { &m.async_client_threads },
|m: &mut ClientConfig| { &mut m.async_client_threads },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<RpcType>>(
"rpc_type",
|m: &ClientConfig| { &m.rpc_type },
|m: &mut ClientConfig| { &mut m.rpc_type },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<LoadParams>>(
"load_params",
|m: &ClientConfig| { &m.load_params },
|m: &mut ClientConfig| { &mut m.load_params },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::payloads::PayloadConfig>>(
"payload_config",
|m: &ClientConfig| { &m.payload_config },
|m: &mut ClientConfig| { &mut m.payload_config },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::stats::HistogramParams>>(
"histogram_params",
|m: &ClientConfig| { &m.histogram_params },
|m: &mut ClientConfig| { &mut m.histogram_params },
));
fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"core_list",
|m: &ClientConfig| { &m.core_list },
|m: &mut ClientConfig| { &mut m.core_list },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"core_limit",
|m: &ClientConfig| { &m.core_limit },
|m: &mut ClientConfig| { &mut m.core_limit },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"other_client_api",
|m: &ClientConfig| { &m.other_client_api },
|m: &mut ClientConfig| { &mut m.other_client_api },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ChannelArg>>(
"channel_args",
|m: &ClientConfig| { &m.channel_args },
|m: &mut ClientConfig| { &mut m.channel_args },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"threads_per_cq",
|m: &ClientConfig| { &m.threads_per_cq },
|m: &mut ClientConfig| { &mut m.threads_per_cq },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"messages_per_stream",
|m: &ClientConfig| { &m.messages_per_stream },
|m: &mut ClientConfig| { &mut m.messages_per_stream },
));
::protobuf::reflect::MessageDescriptor::new::<ClientConfig>(
"ClientConfig",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ClientConfig {
static mut instance: ::protobuf::lazy::Lazy<ClientConfig> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ClientConfig,
};
unsafe {
instance.get(ClientConfig::new)
}
}
}
impl ::protobuf::Clear for ClientConfig {
fn clear(&mut self) {
self.server_targets.clear();
self.client_type = ClientType::SYNC_CLIENT;
self.security_params.clear();
self.outstanding_rpcs_per_channel = 0;
self.client_channels = 0;
self.async_client_threads = 0;
self.rpc_type = RpcType::UNARY;
self.load_params.clear();
self.payload_config.clear();
self.histogram_params.clear();
self.core_list.clear();
self.core_limit = 0;
self.other_client_api.clear();
self.channel_args.clear();
self.threads_per_cq = 0;
self.messages_per_stream = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for ClientConfig {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ClientConfig {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ClientStatus {
pub stats: ::protobuf::SingularPtrField<super::stats::ClientStats>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ClientStatus {
fn default() -> &'a ClientStatus {
<ClientStatus as ::protobuf::Message>::default_instance()
}
}
impl ClientStatus {
pub fn new() -> ClientStatus {
::std::default::Default::default()
}
pub fn get_stats(&self) -> &super::stats::ClientStats {
self.stats.as_ref().unwrap_or_else(|| super::stats::ClientStats::default_instance())
}
pub fn clear_stats(&mut self) {
self.stats.clear();
}
pub fn has_stats(&self) -> bool {
self.stats.is_some()
}
pub fn set_stats(&mut self, v: super::stats::ClientStats) {
self.stats = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_stats(&mut self) -> &mut super::stats::ClientStats {
if self.stats.is_none() {
self.stats.set_default();
}
self.stats.as_mut().unwrap()
}
pub fn take_stats(&mut self) -> super::stats::ClientStats {
self.stats.take().unwrap_or_else(|| super::stats::ClientStats::new())
}
}
impl ::protobuf::Message for ClientStatus {
fn is_initialized(&self) -> bool {
for v in &self.stats {
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_singular_message_into(wire_type, is, &mut self.stats)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.stats.as_ref() {
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 Some(ref v) = self.stats.as_ref() {
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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ClientStatus {
ClientStatus::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::stats::ClientStats>>(
"stats",
|m: &ClientStatus| { &m.stats },
|m: &mut ClientStatus| { &mut m.stats },
));
::protobuf::reflect::MessageDescriptor::new::<ClientStatus>(
"ClientStatus",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ClientStatus {
static mut instance: ::protobuf::lazy::Lazy<ClientStatus> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ClientStatus,
};
unsafe {
instance.get(ClientStatus::new)
}
}
}
impl ::protobuf::Clear for ClientStatus {
fn clear(&mut self) {
self.stats.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for ClientStatus {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ClientStatus {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Mark {
pub reset: bool,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Mark {
fn default() -> &'a Mark {
<Mark as ::protobuf::Message>::default_instance()
}
}
impl Mark {
pub fn new() -> Mark {
::std::default::Default::default()
}
pub fn get_reset(&self) -> bool {
self.reset
}
pub fn clear_reset(&mut self) {
self.reset = false;
}
pub fn set_reset(&mut self, v: bool) {
self.reset = v;
}
}
impl ::protobuf::Message for Mark {
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.reset = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.reset != false {
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 self.reset != false {
os.write_bool(1, self.reset)?;
}
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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Mark {
Mark::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"reset",
|m: &Mark| { &m.reset },
|m: &mut Mark| { &mut m.reset },
));
::protobuf::reflect::MessageDescriptor::new::<Mark>(
"Mark",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Mark {
static mut instance: ::protobuf::lazy::Lazy<Mark> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Mark,
};
unsafe {
instance.get(Mark::new)
}
}
}
impl ::protobuf::Clear for Mark {
fn clear(&mut self) {
self.reset = false;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Mark {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Mark {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ClientArgs {
pub argtype: ::std::option::Option<ClientArgs_oneof_argtype>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ClientArgs {
fn default() -> &'a ClientArgs {
<ClientArgs as ::protobuf::Message>::default_instance()
}
}
#[derive(Clone,PartialEq,Debug)]
pub enum ClientArgs_oneof_argtype {
setup(ClientConfig),
mark(Mark),
}
impl ClientArgs {
pub fn new() -> ClientArgs {
::std::default::Default::default()
}
pub fn get_setup(&self) -> &ClientConfig {
match self.argtype {
::std::option::Option::Some(ClientArgs_oneof_argtype::setup(ref v)) => v,
_ => ClientConfig::default_instance(),
}
}
pub fn clear_setup(&mut self) {
self.argtype = ::std::option::Option::None;
}
pub fn has_setup(&self) -> bool {
match self.argtype {
::std::option::Option::Some(ClientArgs_oneof_argtype::setup(..)) => true,
_ => false,
}
}
pub fn set_setup(&mut self, v: ClientConfig) {
self.argtype = ::std::option::Option::Some(ClientArgs_oneof_argtype::setup(v))
}
pub fn mut_setup(&mut self) -> &mut ClientConfig {
if let ::std::option::Option::Some(ClientArgs_oneof_argtype::setup(_)) = self.argtype {
} else {
self.argtype = ::std::option::Option::Some(ClientArgs_oneof_argtype::setup(ClientConfig::new()));
}
match self.argtype {
::std::option::Option::Some(ClientArgs_oneof_argtype::setup(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_setup(&mut self) -> ClientConfig {
if self.has_setup() {
match self.argtype.take() {
::std::option::Option::Some(ClientArgs_oneof_argtype::setup(v)) => v,
_ => panic!(),
}
} else {
ClientConfig::new()
}
}
pub fn get_mark(&self) -> &Mark {
match self.argtype {
::std::option::Option::Some(ClientArgs_oneof_argtype::mark(ref v)) => v,
_ => Mark::default_instance(),
}
}
pub fn clear_mark(&mut self) {
self.argtype = ::std::option::Option::None;
}
pub fn has_mark(&self) -> bool {
match self.argtype {
::std::option::Option::Some(ClientArgs_oneof_argtype::mark(..)) => true,
_ => false,
}
}
pub fn set_mark(&mut self, v: Mark) {
self.argtype = ::std::option::Option::Some(ClientArgs_oneof_argtype::mark(v))
}
pub fn mut_mark(&mut self) -> &mut Mark {
if let ::std::option::Option::Some(ClientArgs_oneof_argtype::mark(_)) = self.argtype {
} else {
self.argtype = ::std::option::Option::Some(ClientArgs_oneof_argtype::mark(Mark::new()));
}
match self.argtype {
::std::option::Option::Some(ClientArgs_oneof_argtype::mark(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_mark(&mut self) -> Mark {
if self.has_mark() {
match self.argtype.take() {
::std::option::Option::Some(ClientArgs_oneof_argtype::mark(v)) => v,
_ => panic!(),
}
} else {
Mark::new()
}
}
}
impl ::protobuf::Message for ClientArgs {
fn is_initialized(&self) -> bool {
if let Some(ClientArgs_oneof_argtype::setup(ref v)) = self.argtype {
if !v.is_initialized() {
return false;
}
}
if let Some(ClientArgs_oneof_argtype::mark(ref v)) = self.argtype {
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.argtype = ::std::option::Option::Some(ClientArgs_oneof_argtype::setup(is.read_message()?));
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.argtype = ::std::option::Option::Some(ClientArgs_oneof_argtype::mark(is.read_message()?));
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let ::std::option::Option::Some(ref v) = self.argtype {
match v {
&ClientArgs_oneof_argtype::setup(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&ClientArgs_oneof_argtype::mark(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.argtype {
match v {
&ClientArgs_oneof_argtype::setup(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)?;
},
&ClientArgs_oneof_argtype::mark(ref v) => {
os.write_tag(2, ::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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ClientArgs {
ClientArgs::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ClientConfig>(
"setup",
ClientArgs::has_setup,
ClientArgs::get_setup,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Mark>(
"mark",
ClientArgs::has_mark,
ClientArgs::get_mark,
));
::protobuf::reflect::MessageDescriptor::new::<ClientArgs>(
"ClientArgs",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ClientArgs {
static mut instance: ::protobuf::lazy::Lazy<ClientArgs> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ClientArgs,
};
unsafe {
instance.get(ClientArgs::new)
}
}
}
impl ::protobuf::Clear for ClientArgs {
fn clear(&mut self) {
self.argtype = ::std::option::Option::None;
self.argtype = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for ClientArgs {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ClientArgs {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ServerConfig {
pub server_type: ServerType,
pub security_params: ::protobuf::SingularPtrField<SecurityParams>,
pub port: i32,
pub async_server_threads: i32,
pub core_limit: i32,
pub payload_config: ::protobuf::SingularPtrField<super::payloads::PayloadConfig>,
pub core_list: ::std::vec::Vec<i32>,
pub other_server_api: ::std::string::String,
pub threads_per_cq: i32,
pub resource_quota_size: i32,
pub channel_args: ::protobuf::RepeatedField<ChannelArg>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ServerConfig {
fn default() -> &'a ServerConfig {
<ServerConfig as ::protobuf::Message>::default_instance()
}
}
impl ServerConfig {
pub fn new() -> ServerConfig {
::std::default::Default::default()
}
pub fn get_server_type(&self) -> ServerType {
self.server_type
}
pub fn clear_server_type(&mut self) {
self.server_type = ServerType::SYNC_SERVER;
}
pub fn set_server_type(&mut self, v: ServerType) {
self.server_type = v;
}
pub fn get_security_params(&self) -> &SecurityParams {
self.security_params.as_ref().unwrap_or_else(|| SecurityParams::default_instance())
}
pub fn clear_security_params(&mut self) {
self.security_params.clear();
}
pub fn has_security_params(&self) -> bool {
self.security_params.is_some()
}
pub fn set_security_params(&mut self, v: SecurityParams) {
self.security_params = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_security_params(&mut self) -> &mut SecurityParams {
if self.security_params.is_none() {
self.security_params.set_default();
}
self.security_params.as_mut().unwrap()
}
pub fn take_security_params(&mut self) -> SecurityParams {
self.security_params.take().unwrap_or_else(|| SecurityParams::new())
}
pub fn get_port(&self) -> i32 {
self.port
}
pub fn clear_port(&mut self) {
self.port = 0;
}
pub fn set_port(&mut self, v: i32) {
self.port = v;
}
pub fn get_async_server_threads(&self) -> i32 {
self.async_server_threads
}
pub fn clear_async_server_threads(&mut self) {
self.async_server_threads = 0;
}
pub fn set_async_server_threads(&mut self, v: i32) {
self.async_server_threads = v;
}
pub fn get_core_limit(&self) -> i32 {
self.core_limit
}
pub fn clear_core_limit(&mut self) {
self.core_limit = 0;
}
pub fn set_core_limit(&mut self, v: i32) {
self.core_limit = v;
}
pub fn get_payload_config(&self) -> &super::payloads::PayloadConfig {
self.payload_config.as_ref().unwrap_or_else(|| super::payloads::PayloadConfig::default_instance())
}
pub fn clear_payload_config(&mut self) {
self.payload_config.clear();
}
pub fn has_payload_config(&self) -> bool {
self.payload_config.is_some()
}
pub fn set_payload_config(&mut self, v: super::payloads::PayloadConfig) {
self.payload_config = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_payload_config(&mut self) -> &mut super::payloads::PayloadConfig {
if self.payload_config.is_none() {
self.payload_config.set_default();
}
self.payload_config.as_mut().unwrap()
}
pub fn take_payload_config(&mut self) -> super::payloads::PayloadConfig {
self.payload_config.take().unwrap_or_else(|| super::payloads::PayloadConfig::new())
}
pub fn get_core_list(&self) -> &[i32] {
&self.core_list
}
pub fn clear_core_list(&mut self) {
self.core_list.clear();
}
pub fn set_core_list(&mut self, v: ::std::vec::Vec<i32>) {
self.core_list = v;
}
pub fn mut_core_list(&mut self) -> &mut ::std::vec::Vec<i32> {
&mut self.core_list
}
pub fn take_core_list(&mut self) -> ::std::vec::Vec<i32> {
::std::mem::replace(&mut self.core_list, ::std::vec::Vec::new())
}
pub fn get_other_server_api(&self) -> &str {
&self.other_server_api
}
pub fn clear_other_server_api(&mut self) {
self.other_server_api.clear();
}
pub fn set_other_server_api(&mut self, v: ::std::string::String) {
self.other_server_api = v;
}
pub fn mut_other_server_api(&mut self) -> &mut ::std::string::String {
&mut self.other_server_api
}
pub fn take_other_server_api(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.other_server_api, ::std::string::String::new())
}
pub fn get_threads_per_cq(&self) -> i32 {
self.threads_per_cq
}
pub fn clear_threads_per_cq(&mut self) {
self.threads_per_cq = 0;
}
pub fn set_threads_per_cq(&mut self, v: i32) {
self.threads_per_cq = v;
}
pub fn get_resource_quota_size(&self) -> i32 {
self.resource_quota_size
}
pub fn clear_resource_quota_size(&mut self) {
self.resource_quota_size = 0;
}
pub fn set_resource_quota_size(&mut self, v: i32) {
self.resource_quota_size = v;
}
pub fn get_channel_args(&self) -> &[ChannelArg] {
&self.channel_args
}
pub fn clear_channel_args(&mut self) {
self.channel_args.clear();
}
pub fn set_channel_args(&mut self, v: ::protobuf::RepeatedField<ChannelArg>) {
self.channel_args = v;
}
pub fn mut_channel_args(&mut self) -> &mut ::protobuf::RepeatedField<ChannelArg> {
&mut self.channel_args
}
pub fn take_channel_args(&mut self) -> ::protobuf::RepeatedField<ChannelArg> {
::std::mem::replace(&mut self.channel_args, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for ServerConfig {
fn is_initialized(&self) -> bool {
for v in &self.security_params {
if !v.is_initialized() {
return false;
}
};
for v in &self.payload_config {
if !v.is_initialized() {
return false;
}
};
for v in &self.channel_args {
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_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.server_type, 1, &mut self.unknown_fields)?
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.security_params)?;
},
4 => {
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.port = tmp;
},
7 => {
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.async_server_threads = tmp;
},
8 => {
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.core_limit = tmp;
},
9 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.payload_config)?;
},
10 => {
::protobuf::rt::read_repeated_int32_into(wire_type, is, &mut self.core_list)?;
},
11 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.other_server_api)?;
},
12 => {
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.threads_per_cq = tmp;
},
1001 => {
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.resource_quota_size = tmp;
},
1002 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.channel_args)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.server_type != ServerType::SYNC_SERVER {
my_size += ::protobuf::rt::enum_size(1, self.server_type);
}
if let Some(ref v) = self.security_params.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.port != 0 {
my_size += ::protobuf::rt::value_size(4, self.port, ::protobuf::wire_format::WireTypeVarint);
}
if self.async_server_threads != 0 {
my_size += ::protobuf::rt::value_size(7, self.async_server_threads, ::protobuf::wire_format::WireTypeVarint);
}
if self.core_limit != 0 {
my_size += ::protobuf::rt::value_size(8, self.core_limit, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.payload_config.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.core_list {
my_size += ::protobuf::rt::value_size(10, *value, ::protobuf::wire_format::WireTypeVarint);
};
if !self.other_server_api.is_empty() {
my_size += ::protobuf::rt::string_size(11, &self.other_server_api);
}
if self.threads_per_cq != 0 {
my_size += ::protobuf::rt::value_size(12, self.threads_per_cq, ::protobuf::wire_format::WireTypeVarint);
}
if self.resource_quota_size != 0 {
my_size += ::protobuf::rt::value_size(1001, self.resource_quota_size, ::protobuf::wire_format::WireTypeVarint);
}
for value in &self.channel_args {
let len = value.compute_size();
my_size += 2 + ::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 self.server_type != ServerType::SYNC_SERVER {
os.write_enum(1, self.server_type.value())?;
}
if let Some(ref v) = self.security_params.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.port != 0 {
os.write_int32(4, self.port)?;
}
if self.async_server_threads != 0 {
os.write_int32(7, self.async_server_threads)?;
}
if self.core_limit != 0 {
os.write_int32(8, self.core_limit)?;
}
if let Some(ref v) = self.payload_config.as_ref() {
os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.core_list {
os.write_int32(10, *v)?;
};
if !self.other_server_api.is_empty() {
os.write_string(11, &self.other_server_api)?;
}
if self.threads_per_cq != 0 {
os.write_int32(12, self.threads_per_cq)?;
}
if self.resource_quota_size != 0 {
os.write_int32(1001, self.resource_quota_size)?;
}
for v in &self.channel_args {
os.write_tag(1002, ::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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ServerConfig {
ServerConfig::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ServerType>>(
"server_type",
|m: &ServerConfig| { &m.server_type },
|m: &mut ServerConfig| { &mut m.server_type },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<SecurityParams>>(
"security_params",
|m: &ServerConfig| { &m.security_params },
|m: &mut ServerConfig| { &mut m.security_params },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"port",
|m: &ServerConfig| { &m.port },
|m: &mut ServerConfig| { &mut m.port },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"async_server_threads",
|m: &ServerConfig| { &m.async_server_threads },
|m: &mut ServerConfig| { &mut m.async_server_threads },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"core_limit",
|m: &ServerConfig| { &m.core_limit },
|m: &mut ServerConfig| { &mut m.core_limit },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::payloads::PayloadConfig>>(
"payload_config",
|m: &ServerConfig| { &m.payload_config },
|m: &mut ServerConfig| { &mut m.payload_config },
));
fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"core_list",
|m: &ServerConfig| { &m.core_list },
|m: &mut ServerConfig| { &mut m.core_list },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"other_server_api",
|m: &ServerConfig| { &m.other_server_api },
|m: &mut ServerConfig| { &mut m.other_server_api },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"threads_per_cq",
|m: &ServerConfig| { &m.threads_per_cq },
|m: &mut ServerConfig| { &mut m.threads_per_cq },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"resource_quota_size",
|m: &ServerConfig| { &m.resource_quota_size },
|m: &mut ServerConfig| { &mut m.resource_quota_size },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ChannelArg>>(
"channel_args",
|m: &ServerConfig| { &m.channel_args },
|m: &mut ServerConfig| { &mut m.channel_args },
));
::protobuf::reflect::MessageDescriptor::new::<ServerConfig>(
"ServerConfig",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ServerConfig {
static mut instance: ::protobuf::lazy::Lazy<ServerConfig> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ServerConfig,
};
unsafe {
instance.get(ServerConfig::new)
}
}
}
impl ::protobuf::Clear for ServerConfig {
fn clear(&mut self) {
self.server_type = ServerType::SYNC_SERVER;
self.security_params.clear();
self.port = 0;
self.async_server_threads = 0;
self.core_limit = 0;
self.payload_config.clear();
self.core_list.clear();
self.other_server_api.clear();
self.threads_per_cq = 0;
self.resource_quota_size = 0;
self.channel_args.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for ServerConfig {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ServerConfig {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ServerArgs {
pub argtype: ::std::option::Option<ServerArgs_oneof_argtype>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ServerArgs {
fn default() -> &'a ServerArgs {
<ServerArgs as ::protobuf::Message>::default_instance()
}
}
#[derive(Clone,PartialEq,Debug)]
pub enum ServerArgs_oneof_argtype {
setup(ServerConfig),
mark(Mark),
}
impl ServerArgs {
pub fn new() -> ServerArgs {
::std::default::Default::default()
}
pub fn get_setup(&self) -> &ServerConfig {
match self.argtype {
::std::option::Option::Some(ServerArgs_oneof_argtype::setup(ref v)) => v,
_ => ServerConfig::default_instance(),
}
}
pub fn clear_setup(&mut self) {
self.argtype = ::std::option::Option::None;
}
pub fn has_setup(&self) -> bool {
match self.argtype {
::std::option::Option::Some(ServerArgs_oneof_argtype::setup(..)) => true,
_ => false,
}
}
pub fn set_setup(&mut self, v: ServerConfig) {
self.argtype = ::std::option::Option::Some(ServerArgs_oneof_argtype::setup(v))
}
pub fn mut_setup(&mut self) -> &mut ServerConfig {
if let ::std::option::Option::Some(ServerArgs_oneof_argtype::setup(_)) = self.argtype {
} else {
self.argtype = ::std::option::Option::Some(ServerArgs_oneof_argtype::setup(ServerConfig::new()));
}
match self.argtype {
::std::option::Option::Some(ServerArgs_oneof_argtype::setup(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_setup(&mut self) -> ServerConfig {
if self.has_setup() {
match self.argtype.take() {
::std::option::Option::Some(ServerArgs_oneof_argtype::setup(v)) => v,
_ => panic!(),
}
} else {
ServerConfig::new()
}
}
pub fn get_mark(&self) -> &Mark {
match self.argtype {
::std::option::Option::Some(ServerArgs_oneof_argtype::mark(ref v)) => v,
_ => Mark::default_instance(),
}
}
pub fn clear_mark(&mut self) {
self.argtype = ::std::option::Option::None;
}
pub fn has_mark(&self) -> bool {
match self.argtype {
::std::option::Option::Some(ServerArgs_oneof_argtype::mark(..)) => true,
_ => false,
}
}
pub fn set_mark(&mut self, v: Mark) {
self.argtype = ::std::option::Option::Some(ServerArgs_oneof_argtype::mark(v))
}
pub fn mut_mark(&mut self) -> &mut Mark {
if let ::std::option::Option::Some(ServerArgs_oneof_argtype::mark(_)) = self.argtype {
} else {
self.argtype = ::std::option::Option::Some(ServerArgs_oneof_argtype::mark(Mark::new()));
}
match self.argtype {
::std::option::Option::Some(ServerArgs_oneof_argtype::mark(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_mark(&mut self) -> Mark {
if self.has_mark() {
match self.argtype.take() {
::std::option::Option::Some(ServerArgs_oneof_argtype::mark(v)) => v,
_ => panic!(),
}
} else {
Mark::new()
}
}
}
impl ::protobuf::Message for ServerArgs {
fn is_initialized(&self) -> bool {
if let Some(ServerArgs_oneof_argtype::setup(ref v)) = self.argtype {
if !v.is_initialized() {
return false;
}
}
if let Some(ServerArgs_oneof_argtype::mark(ref v)) = self.argtype {
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.argtype = ::std::option::Option::Some(ServerArgs_oneof_argtype::setup(is.read_message()?));
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.argtype = ::std::option::Option::Some(ServerArgs_oneof_argtype::mark(is.read_message()?));
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let ::std::option::Option::Some(ref v) = self.argtype {
match v {
&ServerArgs_oneof_argtype::setup(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&ServerArgs_oneof_argtype::mark(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.argtype {
match v {
&ServerArgs_oneof_argtype::setup(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)?;
},
&ServerArgs_oneof_argtype::mark(ref v) => {
os.write_tag(2, ::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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ServerArgs {
ServerArgs::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ServerConfig>(
"setup",
ServerArgs::has_setup,
ServerArgs::get_setup,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Mark>(
"mark",
ServerArgs::has_mark,
ServerArgs::get_mark,
));
::protobuf::reflect::MessageDescriptor::new::<ServerArgs>(
"ServerArgs",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ServerArgs {
static mut instance: ::protobuf::lazy::Lazy<ServerArgs> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ServerArgs,
};
unsafe {
instance.get(ServerArgs::new)
}
}
}
impl ::protobuf::Clear for ServerArgs {
fn clear(&mut self) {
self.argtype = ::std::option::Option::None;
self.argtype = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for ServerArgs {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ServerArgs {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ServerStatus {
pub stats: ::protobuf::SingularPtrField<super::stats::ServerStats>,
pub port: i32,
pub cores: i32,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ServerStatus {
fn default() -> &'a ServerStatus {
<ServerStatus as ::protobuf::Message>::default_instance()
}
}
impl ServerStatus {
pub fn new() -> ServerStatus {
::std::default::Default::default()
}
pub fn get_stats(&self) -> &super::stats::ServerStats {
self.stats.as_ref().unwrap_or_else(|| super::stats::ServerStats::default_instance())
}
pub fn clear_stats(&mut self) {
self.stats.clear();
}
pub fn has_stats(&self) -> bool {
self.stats.is_some()
}
pub fn set_stats(&mut self, v: super::stats::ServerStats) {
self.stats = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_stats(&mut self) -> &mut super::stats::ServerStats {
if self.stats.is_none() {
self.stats.set_default();
}
self.stats.as_mut().unwrap()
}
pub fn take_stats(&mut self) -> super::stats::ServerStats {
self.stats.take().unwrap_or_else(|| super::stats::ServerStats::new())
}
pub fn get_port(&self) -> i32 {
self.port
}
pub fn clear_port(&mut self) {
self.port = 0;
}
pub fn set_port(&mut self, v: i32) {
self.port = v;
}
pub fn get_cores(&self) -> i32 {
self.cores
}
pub fn clear_cores(&mut self) {
self.cores = 0;
}
pub fn set_cores(&mut self, v: i32) {
self.cores = v;
}
}
impl ::protobuf::Message for ServerStatus {
fn is_initialized(&self) -> bool {
for v in &self.stats {
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_singular_message_into(wire_type, is, &mut self.stats)?;
},
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.port = 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_int32()?;
self.cores = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.stats.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.port != 0 {
my_size += ::protobuf::rt::value_size(2, self.port, ::protobuf::wire_format::WireTypeVarint);
}
if self.cores != 0 {
my_size += ::protobuf::rt::value_size(3, self.cores, ::protobuf::wire_format::WireTypeVarint);
}
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(ref v) = self.stats.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.port != 0 {
os.write_int32(2, self.port)?;
}
if self.cores != 0 {
os.write_int32(3, self.cores)?;
}
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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ServerStatus {
ServerStatus::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::stats::ServerStats>>(
"stats",
|m: &ServerStatus| { &m.stats },
|m: &mut ServerStatus| { &mut m.stats },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"port",
|m: &ServerStatus| { &m.port },
|m: &mut ServerStatus| { &mut m.port },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"cores",
|m: &ServerStatus| { &m.cores },
|m: &mut ServerStatus| { &mut m.cores },
));
::protobuf::reflect::MessageDescriptor::new::<ServerStatus>(
"ServerStatus",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ServerStatus {
static mut instance: ::protobuf::lazy::Lazy<ServerStatus> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ServerStatus,
};
unsafe {
instance.get(ServerStatus::new)
}
}
}
impl ::protobuf::Clear for ServerStatus {
fn clear(&mut self) {
self.stats.clear();
self.port = 0;
self.cores = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for ServerStatus {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ServerStatus {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CoreRequest {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CoreRequest {
fn default() -> &'a CoreRequest {
<CoreRequest as ::protobuf::Message>::default_instance()
}
}
impl CoreRequest {
pub fn new() -> CoreRequest {
::std::default::Default::default()
}
}
impl ::protobuf::Message for CoreRequest {
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 {
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
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<()> {
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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CoreRequest {
CoreRequest::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let fields = ::std::vec::Vec::new();
::protobuf::reflect::MessageDescriptor::new::<CoreRequest>(
"CoreRequest",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static CoreRequest {
static mut instance: ::protobuf::lazy::Lazy<CoreRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CoreRequest,
};
unsafe {
instance.get(CoreRequest::new)
}
}
}
impl ::protobuf::Clear for CoreRequest {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CoreRequest {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CoreRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct CoreResponse {
pub cores: i32,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CoreResponse {
fn default() -> &'a CoreResponse {
<CoreResponse as ::protobuf::Message>::default_instance()
}
}
impl CoreResponse {
pub fn new() -> CoreResponse {
::std::default::Default::default()
}
pub fn get_cores(&self) -> i32 {
self.cores
}
pub fn clear_cores(&mut self) {
self.cores = 0;
}
pub fn set_cores(&mut self, v: i32) {
self.cores = v;
}
}
impl ::protobuf::Message for CoreResponse {
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.cores = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.cores != 0 {
my_size += ::protobuf::rt::value_size(1, self.cores, ::protobuf::wire_format::WireTypeVarint);
}
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 self.cores != 0 {
os.write_int32(1, self.cores)?;
}
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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CoreResponse {
CoreResponse::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"cores",
|m: &CoreResponse| { &m.cores },
|m: &mut CoreResponse| { &mut m.cores },
));
::protobuf::reflect::MessageDescriptor::new::<CoreResponse>(
"CoreResponse",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static CoreResponse {
static mut instance: ::protobuf::lazy::Lazy<CoreResponse> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const CoreResponse,
};
unsafe {
instance.get(CoreResponse::new)
}
}
}
impl ::protobuf::Clear for CoreResponse {
fn clear(&mut self) {
self.cores = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CoreResponse {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CoreResponse {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Void {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Void {
fn default() -> &'a Void {
<Void as ::protobuf::Message>::default_instance()
}
}
impl Void {
pub fn new() -> Void {
::std::default::Default::default()
}
}
impl ::protobuf::Message for Void {
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 {
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
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<()> {
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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Void {
Void::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let fields = ::std::vec::Vec::new();
::protobuf::reflect::MessageDescriptor::new::<Void>(
"Void",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Void {
static mut instance: ::protobuf::lazy::Lazy<Void> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Void,
};
unsafe {
instance.get(Void::new)
}
}
}
impl ::protobuf::Clear for Void {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Void {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Void {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Scenario {
pub name: ::std::string::String,
pub client_config: ::protobuf::SingularPtrField<ClientConfig>,
pub num_clients: i32,
pub server_config: ::protobuf::SingularPtrField<ServerConfig>,
pub num_servers: i32,
pub warmup_seconds: i32,
pub benchmark_seconds: i32,
pub spawn_local_worker_count: i32,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Scenario {
fn default() -> &'a Scenario {
<Scenario as ::protobuf::Message>::default_instance()
}
}
impl Scenario {
pub fn new() -> Scenario {
::std::default::Default::default()
}
pub fn get_name(&self) -> &str {
&self.name
}
pub fn clear_name(&mut self) {
self.name.clear();
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = v;
}
pub fn mut_name(&mut self) -> &mut ::std::string::String {
&mut self.name
}
pub fn take_name(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.name, ::std::string::String::new())
}
pub fn get_client_config(&self) -> &ClientConfig {
self.client_config.as_ref().unwrap_or_else(|| ClientConfig::default_instance())
}
pub fn clear_client_config(&mut self) {
self.client_config.clear();
}
pub fn has_client_config(&self) -> bool {
self.client_config.is_some()
}
pub fn set_client_config(&mut self, v: ClientConfig) {
self.client_config = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_client_config(&mut self) -> &mut ClientConfig {
if self.client_config.is_none() {
self.client_config.set_default();
}
self.client_config.as_mut().unwrap()
}
pub fn take_client_config(&mut self) -> ClientConfig {
self.client_config.take().unwrap_or_else(|| ClientConfig::new())
}
pub fn get_num_clients(&self) -> i32 {
self.num_clients
}
pub fn clear_num_clients(&mut self) {
self.num_clients = 0;
}
pub fn set_num_clients(&mut self, v: i32) {
self.num_clients = v;
}
pub fn get_server_config(&self) -> &ServerConfig {
self.server_config.as_ref().unwrap_or_else(|| ServerConfig::default_instance())
}
pub fn clear_server_config(&mut self) {
self.server_config.clear();
}
pub fn has_server_config(&self) -> bool {
self.server_config.is_some()
}
pub fn set_server_config(&mut self, v: ServerConfig) {
self.server_config = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_server_config(&mut self) -> &mut ServerConfig {
if self.server_config.is_none() {
self.server_config.set_default();
}
self.server_config.as_mut().unwrap()
}
pub fn take_server_config(&mut self) -> ServerConfig {
self.server_config.take().unwrap_or_else(|| ServerConfig::new())
}
pub fn get_num_servers(&self) -> i32 {
self.num_servers
}
pub fn clear_num_servers(&mut self) {
self.num_servers = 0;
}
pub fn set_num_servers(&mut self, v: i32) {
self.num_servers = v;
}
pub fn get_warmup_seconds(&self) -> i32 {
self.warmup_seconds
}
pub fn clear_warmup_seconds(&mut self) {
self.warmup_seconds = 0;
}
pub fn set_warmup_seconds(&mut self, v: i32) {
self.warmup_seconds = v;
}
pub fn get_benchmark_seconds(&self) -> i32 {
self.benchmark_seconds
}
pub fn clear_benchmark_seconds(&mut self) {
self.benchmark_seconds = 0;
}
pub fn set_benchmark_seconds(&mut self, v: i32) {
self.benchmark_seconds = v;
}
pub fn get_spawn_local_worker_count(&self) -> i32 {
self.spawn_local_worker_count
}
pub fn clear_spawn_local_worker_count(&mut self) {
self.spawn_local_worker_count = 0;
}
pub fn set_spawn_local_worker_count(&mut self, v: i32) {
self.spawn_local_worker_count = v;
}
}
impl ::protobuf::Message for Scenario {
fn is_initialized(&self) -> bool {
for v in &self.client_config {
if !v.is_initialized() {
return false;
}
};
for v in &self.server_config {
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_singular_proto3_string_into(wire_type, is, &mut self.name)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.client_config)?;
},
3 => {
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.num_clients = tmp;
},
4 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.server_config)?;
},
5 => {
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.num_servers = tmp;
},
6 => {
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.warmup_seconds = tmp;
},
7 => {
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.benchmark_seconds = tmp;
},
8 => {
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.spawn_local_worker_count = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.name.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.name);
}
if let Some(ref v) = self.client_config.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.num_clients != 0 {
my_size += ::protobuf::rt::value_size(3, self.num_clients, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.server_config.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if self.num_servers != 0 {
my_size += ::protobuf::rt::value_size(5, self.num_servers, ::protobuf::wire_format::WireTypeVarint);
}
if self.warmup_seconds != 0 {
my_size += ::protobuf::rt::value_size(6, self.warmup_seconds, ::protobuf::wire_format::WireTypeVarint);
}
if self.benchmark_seconds != 0 {
my_size += ::protobuf::rt::value_size(7, self.benchmark_seconds, ::protobuf::wire_format::WireTypeVarint);
}
if self.spawn_local_worker_count != 0 {
my_size += ::protobuf::rt::value_size(8, self.spawn_local_worker_count, ::protobuf::wire_format::WireTypeVarint);
}
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 !self.name.is_empty() {
os.write_string(1, &self.name)?;
}
if let Some(ref v) = self.client_config.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.num_clients != 0 {
os.write_int32(3, self.num_clients)?;
}
if let Some(ref v) = self.server_config.as_ref() {
os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if self.num_servers != 0 {
os.write_int32(5, self.num_servers)?;
}
if self.warmup_seconds != 0 {
os.write_int32(6, self.warmup_seconds)?;
}
if self.benchmark_seconds != 0 {
os.write_int32(7, self.benchmark_seconds)?;
}
if self.spawn_local_worker_count != 0 {
os.write_int32(8, self.spawn_local_worker_count)?;
}
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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Scenario {
Scenario::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"name",
|m: &Scenario| { &m.name },
|m: &mut Scenario| { &mut m.name },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ClientConfig>>(
"client_config",
|m: &Scenario| { &m.client_config },
|m: &mut Scenario| { &mut m.client_config },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"num_clients",
|m: &Scenario| { &m.num_clients },
|m: &mut Scenario| { &mut m.num_clients },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ServerConfig>>(
"server_config",
|m: &Scenario| { &m.server_config },
|m: &mut Scenario| { &mut m.server_config },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"num_servers",
|m: &Scenario| { &m.num_servers },
|m: &mut Scenario| { &mut m.num_servers },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"warmup_seconds",
|m: &Scenario| { &m.warmup_seconds },
|m: &mut Scenario| { &mut m.warmup_seconds },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"benchmark_seconds",
|m: &Scenario| { &m.benchmark_seconds },
|m: &mut Scenario| { &mut m.benchmark_seconds },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"spawn_local_worker_count",
|m: &Scenario| { &m.spawn_local_worker_count },
|m: &mut Scenario| { &mut m.spawn_local_worker_count },
));
::protobuf::reflect::MessageDescriptor::new::<Scenario>(
"Scenario",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Scenario {
static mut instance: ::protobuf::lazy::Lazy<Scenario> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Scenario,
};
unsafe {
instance.get(Scenario::new)
}
}
}
impl ::protobuf::Clear for Scenario {
fn clear(&mut self) {
self.name.clear();
self.client_config.clear();
self.num_clients = 0;
self.server_config.clear();
self.num_servers = 0;
self.warmup_seconds = 0;
self.benchmark_seconds = 0;
self.spawn_local_worker_count = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Scenario {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Scenario {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Scenarios {
pub scenarios: ::protobuf::RepeatedField<Scenario>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Scenarios {
fn default() -> &'a Scenarios {
<Scenarios as ::protobuf::Message>::default_instance()
}
}
impl Scenarios {
pub fn new() -> Scenarios {
::std::default::Default::default()
}
pub fn get_scenarios(&self) -> &[Scenario] {
&self.scenarios
}
pub fn clear_scenarios(&mut self) {
self.scenarios.clear();
}
pub fn set_scenarios(&mut self, v: ::protobuf::RepeatedField<Scenario>) {
self.scenarios = v;
}
pub fn mut_scenarios(&mut self) -> &mut ::protobuf::RepeatedField<Scenario> {
&mut self.scenarios
}
pub fn take_scenarios(&mut self) -> ::protobuf::RepeatedField<Scenario> {
::std::mem::replace(&mut self.scenarios, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for Scenarios {
fn is_initialized(&self) -> bool {
for v in &self.scenarios {
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.scenarios)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
for value in &self.scenarios {
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.scenarios {
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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Scenarios {
Scenarios::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Scenario>>(
"scenarios",
|m: &Scenarios| { &m.scenarios },
|m: &mut Scenarios| { &mut m.scenarios },
));
::protobuf::reflect::MessageDescriptor::new::<Scenarios>(
"Scenarios",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Scenarios {
static mut instance: ::protobuf::lazy::Lazy<Scenarios> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Scenarios,
};
unsafe {
instance.get(Scenarios::new)
}
}
}
impl ::protobuf::Clear for Scenarios {
fn clear(&mut self) {
self.scenarios.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Scenarios {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Scenarios {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ScenarioResultSummary {
pub qps: f64,
pub qps_per_server_core: f64,
pub server_system_time: f64,
pub server_user_time: f64,
pub client_system_time: f64,
pub client_user_time: f64,
pub latency_50: f64,
pub latency_90: f64,
pub latency_95: f64,
pub latency_99: f64,
pub latency_999: f64,
pub server_cpu_usage: f64,
pub successful_requests_per_second: f64,
pub failed_requests_per_second: f64,
pub client_polls_per_request: f64,
pub server_polls_per_request: f64,
pub server_queries_per_cpu_sec: f64,
pub client_queries_per_cpu_sec: f64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ScenarioResultSummary {
fn default() -> &'a ScenarioResultSummary {
<ScenarioResultSummary as ::protobuf::Message>::default_instance()
}
}
impl ScenarioResultSummary {
pub fn new() -> ScenarioResultSummary {
::std::default::Default::default()
}
pub fn get_qps(&self) -> f64 {
self.qps
}
pub fn clear_qps(&mut self) {
self.qps = 0.;
}
pub fn set_qps(&mut self, v: f64) {
self.qps = v;
}
pub fn get_qps_per_server_core(&self) -> f64 {
self.qps_per_server_core
}
pub fn clear_qps_per_server_core(&mut self) {
self.qps_per_server_core = 0.;
}
pub fn set_qps_per_server_core(&mut self, v: f64) {
self.qps_per_server_core = v;
}
pub fn get_server_system_time(&self) -> f64 {
self.server_system_time
}
pub fn clear_server_system_time(&mut self) {
self.server_system_time = 0.;
}
pub fn set_server_system_time(&mut self, v: f64) {
self.server_system_time = v;
}
pub fn get_server_user_time(&self) -> f64 {
self.server_user_time
}
pub fn clear_server_user_time(&mut self) {
self.server_user_time = 0.;
}
pub fn set_server_user_time(&mut self, v: f64) {
self.server_user_time = v;
}
pub fn get_client_system_time(&self) -> f64 {
self.client_system_time
}
pub fn clear_client_system_time(&mut self) {
self.client_system_time = 0.;
}
pub fn set_client_system_time(&mut self, v: f64) {
self.client_system_time = v;
}
pub fn get_client_user_time(&self) -> f64 {
self.client_user_time
}
pub fn clear_client_user_time(&mut self) {
self.client_user_time = 0.;
}
pub fn set_client_user_time(&mut self, v: f64) {
self.client_user_time = v;
}
pub fn get_latency_50(&self) -> f64 {
self.latency_50
}
pub fn clear_latency_50(&mut self) {
self.latency_50 = 0.;
}
pub fn set_latency_50(&mut self, v: f64) {
self.latency_50 = v;
}
pub fn get_latency_90(&self) -> f64 {
self.latency_90
}
pub fn clear_latency_90(&mut self) {
self.latency_90 = 0.;
}
pub fn set_latency_90(&mut self, v: f64) {
self.latency_90 = v;
}
pub fn get_latency_95(&self) -> f64 {
self.latency_95
}
pub fn clear_latency_95(&mut self) {
self.latency_95 = 0.;
}
pub fn set_latency_95(&mut self, v: f64) {
self.latency_95 = v;
}
pub fn get_latency_99(&self) -> f64 {
self.latency_99
}
pub fn clear_latency_99(&mut self) {
self.latency_99 = 0.;
}
pub fn set_latency_99(&mut self, v: f64) {
self.latency_99 = v;
}
pub fn get_latency_999(&self) -> f64 {
self.latency_999
}
pub fn clear_latency_999(&mut self) {
self.latency_999 = 0.;
}
pub fn set_latency_999(&mut self, v: f64) {
self.latency_999 = v;
}
pub fn get_server_cpu_usage(&self) -> f64 {
self.server_cpu_usage
}
pub fn clear_server_cpu_usage(&mut self) {
self.server_cpu_usage = 0.;
}
pub fn set_server_cpu_usage(&mut self, v: f64) {
self.server_cpu_usage = v;
}
pub fn get_successful_requests_per_second(&self) -> f64 {
self.successful_requests_per_second
}
pub fn clear_successful_requests_per_second(&mut self) {
self.successful_requests_per_second = 0.;
}
pub fn set_successful_requests_per_second(&mut self, v: f64) {
self.successful_requests_per_second = v;
}
pub fn get_failed_requests_per_second(&self) -> f64 {
self.failed_requests_per_second
}
pub fn clear_failed_requests_per_second(&mut self) {
self.failed_requests_per_second = 0.;
}
pub fn set_failed_requests_per_second(&mut self, v: f64) {
self.failed_requests_per_second = v;
}
pub fn get_client_polls_per_request(&self) -> f64 {
self.client_polls_per_request
}
pub fn clear_client_polls_per_request(&mut self) {
self.client_polls_per_request = 0.;
}
pub fn set_client_polls_per_request(&mut self, v: f64) {
self.client_polls_per_request = v;
}
pub fn get_server_polls_per_request(&self) -> f64 {
self.server_polls_per_request
}
pub fn clear_server_polls_per_request(&mut self) {
self.server_polls_per_request = 0.;
}
pub fn set_server_polls_per_request(&mut self, v: f64) {
self.server_polls_per_request = v;
}
pub fn get_server_queries_per_cpu_sec(&self) -> f64 {
self.server_queries_per_cpu_sec
}
pub fn clear_server_queries_per_cpu_sec(&mut self) {
self.server_queries_per_cpu_sec = 0.;
}
pub fn set_server_queries_per_cpu_sec(&mut self, v: f64) {
self.server_queries_per_cpu_sec = v;
}
pub fn get_client_queries_per_cpu_sec(&self) -> f64 {
self.client_queries_per_cpu_sec
}
pub fn clear_client_queries_per_cpu_sec(&mut self) {
self.client_queries_per_cpu_sec = 0.;
}
pub fn set_client_queries_per_cpu_sec(&mut self, v: f64) {
self.client_queries_per_cpu_sec = v;
}
}
impl ::protobuf::Message for ScenarioResultSummary {
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::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.qps = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.qps_per_server_core = tmp;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.server_system_time = tmp;
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.server_user_time = tmp;
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.client_system_time = tmp;
},
6 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.client_user_time = tmp;
},
7 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.latency_50 = tmp;
},
8 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.latency_90 = tmp;
},
9 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.latency_95 = tmp;
},
10 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.latency_99 = tmp;
},
11 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.latency_999 = tmp;
},
12 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.server_cpu_usage = tmp;
},
13 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.successful_requests_per_second = tmp;
},
14 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.failed_requests_per_second = tmp;
},
15 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.client_polls_per_request = tmp;
},
16 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.server_polls_per_request = tmp;
},
17 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.server_queries_per_cpu_sec = tmp;
},
18 => {
if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_double()?;
self.client_queries_per_cpu_sec = tmp;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.qps != 0. {
my_size += 9;
}
if self.qps_per_server_core != 0. {
my_size += 9;
}
if self.server_system_time != 0. {
my_size += 9;
}
if self.server_user_time != 0. {
my_size += 9;
}
if self.client_system_time != 0. {
my_size += 9;
}
if self.client_user_time != 0. {
my_size += 9;
}
if self.latency_50 != 0. {
my_size += 9;
}
if self.latency_90 != 0. {
my_size += 9;
}
if self.latency_95 != 0. {
my_size += 9;
}
if self.latency_99 != 0. {
my_size += 9;
}
if self.latency_999 != 0. {
my_size += 9;
}
if self.server_cpu_usage != 0. {
my_size += 9;
}
if self.successful_requests_per_second != 0. {
my_size += 9;
}
if self.failed_requests_per_second != 0. {
my_size += 9;
}
if self.client_polls_per_request != 0. {
my_size += 9;
}
if self.server_polls_per_request != 0. {
my_size += 10;
}
if self.server_queries_per_cpu_sec != 0. {
my_size += 10;
}
if self.client_queries_per_cpu_sec != 0. {
my_size += 10;
}
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 self.qps != 0. {
os.write_double(1, self.qps)?;
}
if self.qps_per_server_core != 0. {
os.write_double(2, self.qps_per_server_core)?;
}
if self.server_system_time != 0. {
os.write_double(3, self.server_system_time)?;
}
if self.server_user_time != 0. {
os.write_double(4, self.server_user_time)?;
}
if self.client_system_time != 0. {
os.write_double(5, self.client_system_time)?;
}
if self.client_user_time != 0. {
os.write_double(6, self.client_user_time)?;
}
if self.latency_50 != 0. {
os.write_double(7, self.latency_50)?;
}
if self.latency_90 != 0. {
os.write_double(8, self.latency_90)?;
}
if self.latency_95 != 0. {
os.write_double(9, self.latency_95)?;
}
if self.latency_99 != 0. {
os.write_double(10, self.latency_99)?;
}
if self.latency_999 != 0. {
os.write_double(11, self.latency_999)?;
}
if self.server_cpu_usage != 0. {
os.write_double(12, self.server_cpu_usage)?;
}
if self.successful_requests_per_second != 0. {
os.write_double(13, self.successful_requests_per_second)?;
}
if self.failed_requests_per_second != 0. {
os.write_double(14, self.failed_requests_per_second)?;
}
if self.client_polls_per_request != 0. {
os.write_double(15, self.client_polls_per_request)?;
}
if self.server_polls_per_request != 0. {
os.write_double(16, self.server_polls_per_request)?;
}
if self.server_queries_per_cpu_sec != 0. {
os.write_double(17, self.server_queries_per_cpu_sec)?;
}
if self.client_queries_per_cpu_sec != 0. {
os.write_double(18, self.client_queries_per_cpu_sec)?;
}
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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ScenarioResultSummary {
ScenarioResultSummary::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"qps",
|m: &ScenarioResultSummary| { &m.qps },
|m: &mut ScenarioResultSummary| { &mut m.qps },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"qps_per_server_core",
|m: &ScenarioResultSummary| { &m.qps_per_server_core },
|m: &mut ScenarioResultSummary| { &mut m.qps_per_server_core },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"server_system_time",
|m: &ScenarioResultSummary| { &m.server_system_time },
|m: &mut ScenarioResultSummary| { &mut m.server_system_time },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"server_user_time",
|m: &ScenarioResultSummary| { &m.server_user_time },
|m: &mut ScenarioResultSummary| { &mut m.server_user_time },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"client_system_time",
|m: &ScenarioResultSummary| { &m.client_system_time },
|m: &mut ScenarioResultSummary| { &mut m.client_system_time },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"client_user_time",
|m: &ScenarioResultSummary| { &m.client_user_time },
|m: &mut ScenarioResultSummary| { &mut m.client_user_time },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"latency_50",
|m: &ScenarioResultSummary| { &m.latency_50 },
|m: &mut ScenarioResultSummary| { &mut m.latency_50 },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"latency_90",
|m: &ScenarioResultSummary| { &m.latency_90 },
|m: &mut ScenarioResultSummary| { &mut m.latency_90 },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"latency_95",
|m: &ScenarioResultSummary| { &m.latency_95 },
|m: &mut ScenarioResultSummary| { &mut m.latency_95 },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"latency_99",
|m: &ScenarioResultSummary| { &m.latency_99 },
|m: &mut ScenarioResultSummary| { &mut m.latency_99 },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"latency_999",
|m: &ScenarioResultSummary| { &m.latency_999 },
|m: &mut ScenarioResultSummary| { &mut m.latency_999 },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"server_cpu_usage",
|m: &ScenarioResultSummary| { &m.server_cpu_usage },
|m: &mut ScenarioResultSummary| { &mut m.server_cpu_usage },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"successful_requests_per_second",
|m: &ScenarioResultSummary| { &m.successful_requests_per_second },
|m: &mut ScenarioResultSummary| { &mut m.successful_requests_per_second },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"failed_requests_per_second",
|m: &ScenarioResultSummary| { &m.failed_requests_per_second },
|m: &mut ScenarioResultSummary| { &mut m.failed_requests_per_second },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"client_polls_per_request",
|m: &ScenarioResultSummary| { &m.client_polls_per_request },
|m: &mut ScenarioResultSummary| { &mut m.client_polls_per_request },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"server_polls_per_request",
|m: &ScenarioResultSummary| { &m.server_polls_per_request },
|m: &mut ScenarioResultSummary| { &mut m.server_polls_per_request },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"server_queries_per_cpu_sec",
|m: &ScenarioResultSummary| { &m.server_queries_per_cpu_sec },
|m: &mut ScenarioResultSummary| { &mut m.server_queries_per_cpu_sec },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
"client_queries_per_cpu_sec",
|m: &ScenarioResultSummary| { &m.client_queries_per_cpu_sec },
|m: &mut ScenarioResultSummary| { &mut m.client_queries_per_cpu_sec },
));
::protobuf::reflect::MessageDescriptor::new::<ScenarioResultSummary>(
"ScenarioResultSummary",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ScenarioResultSummary {
static mut instance: ::protobuf::lazy::Lazy<ScenarioResultSummary> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ScenarioResultSummary,
};
unsafe {
instance.get(ScenarioResultSummary::new)
}
}
}
impl ::protobuf::Clear for ScenarioResultSummary {
fn clear(&mut self) {
self.qps = 0.;
self.qps_per_server_core = 0.;
self.server_system_time = 0.;
self.server_user_time = 0.;
self.client_system_time = 0.;
self.client_user_time = 0.;
self.latency_50 = 0.;
self.latency_90 = 0.;
self.latency_95 = 0.;
self.latency_99 = 0.;
self.latency_999 = 0.;
self.server_cpu_usage = 0.;
self.successful_requests_per_second = 0.;
self.failed_requests_per_second = 0.;
self.client_polls_per_request = 0.;
self.server_polls_per_request = 0.;
self.server_queries_per_cpu_sec = 0.;
self.client_queries_per_cpu_sec = 0.;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for ScenarioResultSummary {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ScenarioResultSummary {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct ScenarioResult {
pub scenario: ::protobuf::SingularPtrField<Scenario>,
pub latencies: ::protobuf::SingularPtrField<super::stats::HistogramData>,
pub client_stats: ::protobuf::RepeatedField<super::stats::ClientStats>,
pub server_stats: ::protobuf::RepeatedField<super::stats::ServerStats>,
pub server_cores: ::std::vec::Vec<i32>,
pub summary: ::protobuf::SingularPtrField<ScenarioResultSummary>,
pub client_success: ::std::vec::Vec<bool>,
pub server_success: ::std::vec::Vec<bool>,
pub request_results: ::protobuf::RepeatedField<super::stats::RequestResultCount>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a ScenarioResult {
fn default() -> &'a ScenarioResult {
<ScenarioResult as ::protobuf::Message>::default_instance()
}
}
impl ScenarioResult {
pub fn new() -> ScenarioResult {
::std::default::Default::default()
}
pub fn get_scenario(&self) -> &Scenario {
self.scenario.as_ref().unwrap_or_else(|| Scenario::default_instance())
}
pub fn clear_scenario(&mut self) {
self.scenario.clear();
}
pub fn has_scenario(&self) -> bool {
self.scenario.is_some()
}
pub fn set_scenario(&mut self, v: Scenario) {
self.scenario = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_scenario(&mut self) -> &mut Scenario {
if self.scenario.is_none() {
self.scenario.set_default();
}
self.scenario.as_mut().unwrap()
}
pub fn take_scenario(&mut self) -> Scenario {
self.scenario.take().unwrap_or_else(|| Scenario::new())
}
pub fn get_latencies(&self) -> &super::stats::HistogramData {
self.latencies.as_ref().unwrap_or_else(|| super::stats::HistogramData::default_instance())
}
pub fn clear_latencies(&mut self) {
self.latencies.clear();
}
pub fn has_latencies(&self) -> bool {
self.latencies.is_some()
}
pub fn set_latencies(&mut self, v: super::stats::HistogramData) {
self.latencies = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_latencies(&mut self) -> &mut super::stats::HistogramData {
if self.latencies.is_none() {
self.latencies.set_default();
}
self.latencies.as_mut().unwrap()
}
pub fn take_latencies(&mut self) -> super::stats::HistogramData {
self.latencies.take().unwrap_or_else(|| super::stats::HistogramData::new())
}
pub fn get_client_stats(&self) -> &[super::stats::ClientStats] {
&self.client_stats
}
pub fn clear_client_stats(&mut self) {
self.client_stats.clear();
}
pub fn set_client_stats(&mut self, v: ::protobuf::RepeatedField<super::stats::ClientStats>) {
self.client_stats = v;
}
pub fn mut_client_stats(&mut self) -> &mut ::protobuf::RepeatedField<super::stats::ClientStats> {
&mut self.client_stats
}
pub fn take_client_stats(&mut self) -> ::protobuf::RepeatedField<super::stats::ClientStats> {
::std::mem::replace(&mut self.client_stats, ::protobuf::RepeatedField::new())
}
pub fn get_server_stats(&self) -> &[super::stats::ServerStats] {
&self.server_stats
}
pub fn clear_server_stats(&mut self) {
self.server_stats.clear();
}
pub fn set_server_stats(&mut self, v: ::protobuf::RepeatedField<super::stats::ServerStats>) {
self.server_stats = v;
}
pub fn mut_server_stats(&mut self) -> &mut ::protobuf::RepeatedField<super::stats::ServerStats> {
&mut self.server_stats
}
pub fn take_server_stats(&mut self) -> ::protobuf::RepeatedField<super::stats::ServerStats> {
::std::mem::replace(&mut self.server_stats, ::protobuf::RepeatedField::new())
}
pub fn get_server_cores(&self) -> &[i32] {
&self.server_cores
}
pub fn clear_server_cores(&mut self) {
self.server_cores.clear();
}
pub fn set_server_cores(&mut self, v: ::std::vec::Vec<i32>) {
self.server_cores = v;
}
pub fn mut_server_cores(&mut self) -> &mut ::std::vec::Vec<i32> {
&mut self.server_cores
}
pub fn take_server_cores(&mut self) -> ::std::vec::Vec<i32> {
::std::mem::replace(&mut self.server_cores, ::std::vec::Vec::new())
}
pub fn get_summary(&self) -> &ScenarioResultSummary {
self.summary.as_ref().unwrap_or_else(|| ScenarioResultSummary::default_instance())
}
pub fn clear_summary(&mut self) {
self.summary.clear();
}
pub fn has_summary(&self) -> bool {
self.summary.is_some()
}
pub fn set_summary(&mut self, v: ScenarioResultSummary) {
self.summary = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_summary(&mut self) -> &mut ScenarioResultSummary {
if self.summary.is_none() {
self.summary.set_default();
}
self.summary.as_mut().unwrap()
}
pub fn take_summary(&mut self) -> ScenarioResultSummary {
self.summary.take().unwrap_or_else(|| ScenarioResultSummary::new())
}
pub fn get_client_success(&self) -> &[bool] {
&self.client_success
}
pub fn clear_client_success(&mut self) {
self.client_success.clear();
}
pub fn set_client_success(&mut self, v: ::std::vec::Vec<bool>) {
self.client_success = v;
}
pub fn mut_client_success(&mut self) -> &mut ::std::vec::Vec<bool> {
&mut self.client_success
}
pub fn take_client_success(&mut self) -> ::std::vec::Vec<bool> {
::std::mem::replace(&mut self.client_success, ::std::vec::Vec::new())
}
pub fn get_server_success(&self) -> &[bool] {
&self.server_success
}
pub fn clear_server_success(&mut self) {
self.server_success.clear();
}
pub fn set_server_success(&mut self, v: ::std::vec::Vec<bool>) {
self.server_success = v;
}
pub fn mut_server_success(&mut self) -> &mut ::std::vec::Vec<bool> {
&mut self.server_success
}
pub fn take_server_success(&mut self) -> ::std::vec::Vec<bool> {
::std::mem::replace(&mut self.server_success, ::std::vec::Vec::new())
}
pub fn get_request_results(&self) -> &[super::stats::RequestResultCount] {
&self.request_results
}
pub fn clear_request_results(&mut self) {
self.request_results.clear();
}
pub fn set_request_results(&mut self, v: ::protobuf::RepeatedField<super::stats::RequestResultCount>) {
self.request_results = v;
}
pub fn mut_request_results(&mut self) -> &mut ::protobuf::RepeatedField<super::stats::RequestResultCount> {
&mut self.request_results
}
pub fn take_request_results(&mut self) -> ::protobuf::RepeatedField<super::stats::RequestResultCount> {
::std::mem::replace(&mut self.request_results, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for ScenarioResult {
fn is_initialized(&self) -> bool {
for v in &self.scenario {
if !v.is_initialized() {
return false;
}
};
for v in &self.latencies {
if !v.is_initialized() {
return false;
}
};
for v in &self.client_stats {
if !v.is_initialized() {
return false;
}
};
for v in &self.server_stats {
if !v.is_initialized() {
return false;
}
};
for v in &self.summary {
if !v.is_initialized() {
return false;
}
};
for v in &self.request_results {
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_singular_message_into(wire_type, is, &mut self.scenario)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.latencies)?;
},
3 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.client_stats)?;
},
4 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.server_stats)?;
},
5 => {
::protobuf::rt::read_repeated_int32_into(wire_type, is, &mut self.server_cores)?;
},
6 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.summary)?;
},
7 => {
::protobuf::rt::read_repeated_bool_into(wire_type, is, &mut self.client_success)?;
},
8 => {
::protobuf::rt::read_repeated_bool_into(wire_type, is, &mut self.server_success)?;
},
9 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.request_results)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let Some(ref v) = self.scenario.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.latencies.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
for value in &self.client_stats {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
for value in &self.server_stats {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
for value in &self.server_cores {
my_size += ::protobuf::rt::value_size(5, *value, ::protobuf::wire_format::WireTypeVarint);
};
if let Some(ref v) = self.summary.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += 2 * self.client_success.len() as u32;
my_size += 2 * self.server_success.len() as u32;
for value in &self.request_results {
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<()> {
if let Some(ref v) = self.scenario.as_ref() {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.latencies.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.client_stats {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
for v in &self.server_stats {
os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
for v in &self.server_cores {
os.write_int32(5, *v)?;
};
if let Some(ref v) = self.summary.as_ref() {
os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
for v in &self.client_success {
os.write_bool(7, *v)?;
};
for v in &self.server_success {
os.write_bool(8, *v)?;
};
for v in &self.request_results {
os.write_tag(9, ::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: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> ScenarioResult {
ScenarioResult::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Scenario>>(
"scenario",
|m: &ScenarioResult| { &m.scenario },
|m: &mut ScenarioResult| { &mut m.scenario },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::stats::HistogramData>>(
"latencies",
|m: &ScenarioResult| { &m.latencies },
|m: &mut ScenarioResult| { &mut m.latencies },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::stats::ClientStats>>(
"client_stats",
|m: &ScenarioResult| { &m.client_stats },
|m: &mut ScenarioResult| { &mut m.client_stats },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::stats::ServerStats>>(
"server_stats",
|m: &ScenarioResult| { &m.server_stats },
|m: &mut ScenarioResult| { &mut m.server_stats },
));
fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"server_cores",
|m: &ScenarioResult| { &m.server_cores },
|m: &mut ScenarioResult| { &mut m.server_cores },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ScenarioResultSummary>>(
"summary",
|m: &ScenarioResult| { &m.summary },
|m: &mut ScenarioResult| { &mut m.summary },
));
fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"client_success",
|m: &ScenarioResult| { &m.client_success },
|m: &mut ScenarioResult| { &mut m.client_success },
));
fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"server_success",
|m: &ScenarioResult| { &m.server_success },
|m: &mut ScenarioResult| { &mut m.server_success },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::stats::RequestResultCount>>(
"request_results",
|m: &ScenarioResult| { &m.request_results },
|m: &mut ScenarioResult| { &mut m.request_results },
));
::protobuf::reflect::MessageDescriptor::new::<ScenarioResult>(
"ScenarioResult",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ScenarioResult {
static mut instance: ::protobuf::lazy::Lazy<ScenarioResult> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ScenarioResult,
};
unsafe {
instance.get(ScenarioResult::new)
}
}
}
impl ::protobuf::Clear for ScenarioResult {
fn clear(&mut self) {
self.scenario.clear();
self.latencies.clear();
self.client_stats.clear();
self.server_stats.clear();
self.server_cores.clear();
self.summary.clear();
self.client_success.clear();
self.server_success.clear();
self.request_results.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for ScenarioResult {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ScenarioResult {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum ClientType {
SYNC_CLIENT = 0,
ASYNC_CLIENT = 1,
OTHER_CLIENT = 2,
}
impl ::protobuf::ProtobufEnum for ClientType {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<ClientType> {
match value {
0 => ::std::option::Option::Some(ClientType::SYNC_CLIENT),
1 => ::std::option::Option::Some(ClientType::ASYNC_CLIENT),
2 => ::std::option::Option::Some(ClientType::OTHER_CLIENT),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [ClientType] = &[
ClientType::SYNC_CLIENT,
ClientType::ASYNC_CLIENT,
ClientType::OTHER_CLIENT,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
};
unsafe {
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new("ClientType", file_descriptor_proto())
})
}
}
}
impl ::std::marker::Copy for ClientType {
}
impl ::std::default::Default for ClientType {
fn default() -> Self {
ClientType::SYNC_CLIENT
}
}
impl ::protobuf::reflect::ProtobufValue for ClientType {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum ServerType {
SYNC_SERVER = 0,
ASYNC_SERVER = 1,
ASYNC_GENERIC_SERVER = 2,
OTHER_SERVER = 3,
}
impl ::protobuf::ProtobufEnum for ServerType {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<ServerType> {
match value {
0 => ::std::option::Option::Some(ServerType::SYNC_SERVER),
1 => ::std::option::Option::Some(ServerType::ASYNC_SERVER),
2 => ::std::option::Option::Some(ServerType::ASYNC_GENERIC_SERVER),
3 => ::std::option::Option::Some(ServerType::OTHER_SERVER),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [ServerType] = &[
ServerType::SYNC_SERVER,
ServerType::ASYNC_SERVER,
ServerType::ASYNC_GENERIC_SERVER,
ServerType::OTHER_SERVER,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
};
unsafe {
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new("ServerType", file_descriptor_proto())
})
}
}
}
impl ::std::marker::Copy for ServerType {
}
impl ::std::default::Default for ServerType {
fn default() -> Self {
ServerType::SYNC_SERVER
}
}
impl ::protobuf::reflect::ProtobufValue for ServerType {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
}
}
#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum RpcType {
UNARY = 0,
STREAMING = 1,
STREAMING_FROM_CLIENT = 2,
STREAMING_FROM_SERVER = 3,
STREAMING_BOTH_WAYS = 4,
}
impl ::protobuf::ProtobufEnum for RpcType {
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<RpcType> {
match value {
0 => ::std::option::Option::Some(RpcType::UNARY),
1 => ::std::option::Option::Some(RpcType::STREAMING),
2 => ::std::option::Option::Some(RpcType::STREAMING_FROM_CLIENT),
3 => ::std::option::Option::Some(RpcType::STREAMING_FROM_SERVER),
4 => ::std::option::Option::Some(RpcType::STREAMING_BOTH_WAYS),
_ => ::std::option::Option::None
}
}
fn values() -> &'static [Self] {
static values: &'static [RpcType] = &[
RpcType::UNARY,
RpcType::STREAMING,
RpcType::STREAMING_FROM_CLIENT,
RpcType::STREAMING_FROM_SERVER,
RpcType::STREAMING_BOTH_WAYS,
];
values
}
fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
};
unsafe {
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new("RpcType", file_descriptor_proto())
})
}
}
}
impl ::std::marker::Copy for RpcType {
}
impl ::std::default::Default for RpcType {
fn default() -> Self {
RpcType::UNARY
}
}
impl ::protobuf::reflect::ProtobufValue for RpcType {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x1agrpc/testing/control.proto\x12\x0cgrpc.testing\x1a\x1bgrpc/testing\
/payloads.proto\x1a\x18grpc/testing/stats.proto\"2\n\rPoissonParams\x12!\
\n\x0coffered_load\x18\x01\x20\x01(\x01R\x0bofferedLoad\"\x12\n\x10Close\
dLoopParams\"\x90\x01\n\nLoadParams\x12A\n\x0bclosed_loop\x18\x01\x20\
\x01(\x0b2\x1e.grpc.testing.ClosedLoopParamsH\0R\nclosedLoop\x127\n\x07p\
oisson\x18\x02\x20\x01(\x0b2\x1b.grpc.testing.PoissonParamsH\0R\x07poiss\
onB\x06\n\x04load\"\x7f\n\x0eSecurityParams\x12\x1e\n\x0buse_test_ca\x18\
\x01\x20\x01(\x08R\tuseTestCa\x120\n\x14server_host_override\x18\x02\x20\
\x01(\tR\x12serverHostOverride\x12\x1b\n\tcred_type\x18\x03\x20\x01(\tR\
\x08credType\"g\n\nChannelArg\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04n\
ame\x12\x1d\n\tstr_value\x18\x02\x20\x01(\tH\0R\x08strValue\x12\x1d\n\ti\
nt_value\x18\x03\x20\x01(\x05H\0R\x08intValueB\x07\n\x05value\"\xc7\x06\
\n\x0cClientConfig\x12%\n\x0eserver_targets\x18\x01\x20\x03(\tR\rserverT\
argets\x129\n\x0bclient_type\x18\x02\x20\x01(\x0e2\x18.grpc.testing.Clie\
ntTypeR\nclientType\x12E\n\x0fsecurity_params\x18\x03\x20\x01(\x0b2\x1c.\
grpc.testing.SecurityParamsR\x0esecurityParams\x12?\n\x1coutstanding_rpc\
s_per_channel\x18\x04\x20\x01(\x05R\x19outstandingRpcsPerChannel\x12'\n\
\x0fclient_channels\x18\x05\x20\x01(\x05R\x0eclientChannels\x120\n\x14as\
ync_client_threads\x18\x07\x20\x01(\x05R\x12asyncClientThreads\x120\n\
\x08rpc_type\x18\x08\x20\x01(\x0e2\x15.grpc.testing.RpcTypeR\x07rpcType\
\x129\n\x0bload_params\x18\n\x20\x01(\x0b2\x18.grpc.testing.LoadParamsR\
\nloadParams\x12B\n\x0epayload_config\x18\x0b\x20\x01(\x0b2\x1b.grpc.tes\
ting.PayloadConfigR\rpayloadConfig\x12H\n\x10histogram_params\x18\x0c\
\x20\x01(\x0b2\x1d.grpc.testing.HistogramParamsR\x0fhistogramParams\x12\
\x1b\n\tcore_list\x18\r\x20\x03(\x05R\x08coreList\x12\x1d\n\ncore_limit\
\x18\x0e\x20\x01(\x05R\tcoreLimit\x12(\n\x10other_client_api\x18\x0f\x20\
\x01(\tR\x0eotherClientApi\x12;\n\x0cchannel_args\x18\x10\x20\x03(\x0b2\
\x18.grpc.testing.ChannelArgR\x0bchannelArgs\x12$\n\x0ethreads_per_cq\
\x18\x11\x20\x01(\x05R\x0cthreadsPerCq\x12.\n\x13messages_per_stream\x18\
\x12\x20\x01(\x05R\x11messagesPerStream\"?\n\x0cClientStatus\x12/\n\x05s\
tats\x18\x01\x20\x01(\x0b2\x19.grpc.testing.ClientStatsR\x05stats\"\x1c\
\n\x04Mark\x12\x14\n\x05reset\x18\x01\x20\x01(\x08R\x05reset\"u\n\nClien\
tArgs\x122\n\x05setup\x18\x01\x20\x01(\x0b2\x1a.grpc.testing.ClientConfi\
gH\0R\x05setup\x12(\n\x04mark\x18\x02\x20\x01(\x0b2\x12.grpc.testing.Mar\
kH\0R\x04markB\t\n\x07argtype\"\x95\x04\n\x0cServerConfig\x129\n\x0bserv\
er_type\x18\x01\x20\x01(\x0e2\x18.grpc.testing.ServerTypeR\nserverType\
\x12E\n\x0fsecurity_params\x18\x02\x20\x01(\x0b2\x1c.grpc.testing.Securi\
tyParamsR\x0esecurityParams\x12\x12\n\x04port\x18\x04\x20\x01(\x05R\x04p\
ort\x120\n\x14async_server_threads\x18\x07\x20\x01(\x05R\x12asyncServerT\
hreads\x12\x1d\n\ncore_limit\x18\x08\x20\x01(\x05R\tcoreLimit\x12B\n\x0e\
payload_config\x18\t\x20\x01(\x0b2\x1b.grpc.testing.PayloadConfigR\rpayl\
oadConfig\x12\x1b\n\tcore_list\x18\n\x20\x03(\x05R\x08coreList\x12(\n\
\x10other_server_api\x18\x0b\x20\x01(\tR\x0eotherServerApi\x12$\n\x0ethr\
eads_per_cq\x18\x0c\x20\x01(\x05R\x0cthreadsPerCq\x12/\n\x13resource_quo\
ta_size\x18\xe9\x07\x20\x01(\x05R\x11resourceQuotaSize\x12<\n\x0cchannel\
_args\x18\xea\x07\x20\x03(\x0b2\x18.grpc.testing.ChannelArgR\x0bchannelA\
rgs\"u\n\nServerArgs\x122\n\x05setup\x18\x01\x20\x01(\x0b2\x1a.grpc.test\
ing.ServerConfigH\0R\x05setup\x12(\n\x04mark\x18\x02\x20\x01(\x0b2\x12.g\
rpc.testing.MarkH\0R\x04markB\t\n\x07argtype\"i\n\x0cServerStatus\x12/\n\
\x05stats\x18\x01\x20\x01(\x0b2\x19.grpc.testing.ServerStatsR\x05stats\
\x12\x12\n\x04port\x18\x02\x20\x01(\x05R\x04port\x12\x14\n\x05cores\x18\
\x03\x20\x01(\x05R\x05cores\"\r\n\x0bCoreRequest\"$\n\x0cCoreResponse\
\x12\x14\n\x05cores\x18\x01\x20\x01(\x05R\x05cores\"\x06\n\x04Void\"\xef\
\x02\n\x08Scenario\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12?\n\
\rclient_config\x18\x02\x20\x01(\x0b2\x1a.grpc.testing.ClientConfigR\x0c\
clientConfig\x12\x1f\n\x0bnum_clients\x18\x03\x20\x01(\x05R\nnumClients\
\x12?\n\rserver_config\x18\x04\x20\x01(\x0b2\x1a.grpc.testing.ServerConf\
igR\x0cserverConfig\x12\x1f\n\x0bnum_servers\x18\x05\x20\x01(\x05R\nnumS\
ervers\x12%\n\x0ewarmup_seconds\x18\x06\x20\x01(\x05R\rwarmupSeconds\x12\
+\n\x11benchmark_seconds\x18\x07\x20\x01(\x05R\x10benchmarkSeconds\x127\
\n\x18spawn_local_worker_count\x18\x08\x20\x01(\x05R\x15spawnLocalWorker\
Count\"A\n\tScenarios\x124\n\tscenarios\x18\x01\x20\x03(\x0b2\x16.grpc.t\
esting.ScenarioR\tscenarios\"\xbb\x06\n\x15ScenarioResultSummary\x12\x10\
\n\x03qps\x18\x01\x20\x01(\x01R\x03qps\x12-\n\x13qps_per_server_core\x18\
\x02\x20\x01(\x01R\x10qpsPerServerCore\x12,\n\x12server_system_time\x18\
\x03\x20\x01(\x01R\x10serverSystemTime\x12(\n\x10server_user_time\x18\
\x04\x20\x01(\x01R\x0eserverUserTime\x12,\n\x12client_system_time\x18\
\x05\x20\x01(\x01R\x10clientSystemTime\x12(\n\x10client_user_time\x18\
\x06\x20\x01(\x01R\x0eclientUserTime\x12\x1d\n\nlatency_50\x18\x07\x20\
\x01(\x01R\tlatency50\x12\x1d\n\nlatency_90\x18\x08\x20\x01(\x01R\tlaten\
cy90\x12\x1d\n\nlatency_95\x18\t\x20\x01(\x01R\tlatency95\x12\x1d\n\nlat\
ency_99\x18\n\x20\x01(\x01R\tlatency99\x12\x1f\n\x0blatency_999\x18\x0b\
\x20\x01(\x01R\nlatency999\x12(\n\x10server_cpu_usage\x18\x0c\x20\x01(\
\x01R\x0eserverCpuUsage\x12C\n\x1esuccessful_requests_per_second\x18\r\
\x20\x01(\x01R\x1bsuccessfulRequestsPerSecond\x12;\n\x1afailed_requests_\
per_second\x18\x0e\x20\x01(\x01R\x17failedRequestsPerSecond\x127\n\x18cl\
ient_polls_per_request\x18\x0f\x20\x01(\x01R\x15clientPollsPerRequest\
\x127\n\x18server_polls_per_request\x18\x10\x20\x01(\x01R\x15serverPolls\
PerRequest\x12:\n\x1aserver_queries_per_cpu_sec\x18\x11\x20\x01(\x01R\
\x16serverQueriesPerCpuSec\x12:\n\x1aclient_queries_per_cpu_sec\x18\x12\
\x20\x01(\x01R\x16clientQueriesPerCpuSec\"\xf6\x03\n\x0eScenarioResult\
\x122\n\x08scenario\x18\x01\x20\x01(\x0b2\x16.grpc.testing.ScenarioR\x08\
scenario\x129\n\tlatencies\x18\x02\x20\x01(\x0b2\x1b.grpc.testing.Histog\
ramDataR\tlatencies\x12<\n\x0cclient_stats\x18\x03\x20\x03(\x0b2\x19.grp\
c.testing.ClientStatsR\x0bclientStats\x12<\n\x0cserver_stats\x18\x04\x20\
\x03(\x0b2\x19.grpc.testing.ServerStatsR\x0bserverStats\x12!\n\x0cserver\
_cores\x18\x05\x20\x03(\x05R\x0bserverCores\x12=\n\x07summary\x18\x06\
\x20\x01(\x0b2#.grpc.testing.ScenarioResultSummaryR\x07summary\x12%\n\
\x0eclient_success\x18\x07\x20\x03(\x08R\rclientSuccess\x12%\n\x0eserver\
_success\x18\x08\x20\x03(\x08R\rserverSuccess\x12I\n\x0frequest_results\
\x18\t\x20\x03(\x0b2\x20.grpc.testing.RequestResultCountR\x0erequestResu\
lts*A\n\nClientType\x12\x0f\n\x0bSYNC_CLIENT\x10\0\x12\x10\n\x0cASYNC_CL\
IENT\x10\x01\x12\x10\n\x0cOTHER_CLIENT\x10\x02*[\n\nServerType\x12\x0f\n\
\x0bSYNC_SERVER\x10\0\x12\x10\n\x0cASYNC_SERVER\x10\x01\x12\x18\n\x14ASY\
NC_GENERIC_SERVER\x10\x02\x12\x10\n\x0cOTHER_SERVER\x10\x03*r\n\x07RpcTy\
pe\x12\t\n\x05UNARY\x10\0\x12\r\n\tSTREAMING\x10\x01\x12\x19\n\x15STREAM\
ING_FROM_CLIENT\x10\x02\x12\x19\n\x15STREAMING_FROM_SERVER\x10\x03\x12\
\x17\n\x13STREAMING_BOTH_WAYS\x10\x04b\x06proto3\
";
static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto,
};
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 {
unsafe {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}
}