#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![rustfmt::skip]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(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: ::std::boxed::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::INIT;
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_pb_name::<PoissonParams>(
"PoissonParams",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static PoissonParams {
static mut instance: ::protobuf::lazy::Lazy<PoissonParams> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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: ::std::boxed::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::INIT;
unsafe {
descriptor.get(|| {
let fields = ::std::vec::Vec::new();
::protobuf::reflect::MessageDescriptor::new_pb_name::<ClosedLoopParams>(
"ClosedLoopParams",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ClosedLoopParams {
static mut instance: ::protobuf::lazy::Lazy<ClosedLoopParams> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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: ::std::boxed::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::INIT;
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_pb_name::<LoadParams>(
"LoadParams",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static LoadParams {
static mut instance: ::protobuf::lazy::Lazy<LoadParams> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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: ::std::boxed::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::INIT;
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_pb_name::<SecurityParams>(
"SecurityParams",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static SecurityParams {
static mut instance: ::protobuf::lazy::Lazy<SecurityParams> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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: ::std::boxed::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::INIT;
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_pb_name::<ChannelArg>(
"ChannelArg",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ChannelArg {
static mut instance: ::protobuf::lazy::Lazy<ChannelArg> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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 => {
if wire_type == ::protobuf::wire_format::WireTypeVarint {self.client_type = is.read_enum()?;} else {return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));}
},
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 => {
if wire_type == ::protobuf::wire_format::WireTypeVarint {self.rpc_type = is.read_enum()?;} else {return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));}
},
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: ::std::boxed::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::INIT;
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_pb_name::<ClientConfig>(
"ClientConfig",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ClientConfig {
static mut instance: ::protobuf::lazy::Lazy<ClientConfig> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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: ::std::boxed::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::INIT;
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_pb_name::<ClientStatus>(
"ClientStatus",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ClientStatus {
static mut instance: ::protobuf::lazy::Lazy<ClientStatus> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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: ::std::boxed::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::INIT;
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_pb_name::<Mark>(
"Mark",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Mark {
static mut instance: ::protobuf::lazy::Lazy<Mark> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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: ::std::boxed::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::INIT;
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_pb_name::<ClientArgs>(
"ClientArgs",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ClientArgs {
static mut instance: ::protobuf::lazy::Lazy<ClientArgs> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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 => {
if wire_type == ::protobuf::wire_format::WireTypeVarint {self.server_type = is.read_enum()?;} else {return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));}
},
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: ::std::boxed::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::INIT;
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_pb_name::<ServerConfig>(
"ServerConfig",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ServerConfig {
static mut instance: ::protobuf::lazy::Lazy<ServerConfig> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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: ::std::boxed::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::INIT;
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_pb_name::<ServerArgs>(
"ServerArgs",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ServerArgs {
static mut instance: ::protobuf::lazy::Lazy<ServerArgs> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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: ::std::boxed::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::INIT;
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_pb_name::<ServerStatus>(
"ServerStatus",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ServerStatus {
static mut instance: ::protobuf::lazy::Lazy<ServerStatus> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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: ::std::boxed::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::INIT;
unsafe {
descriptor.get(|| {
let fields = ::std::vec::Vec::new();
::protobuf::reflect::MessageDescriptor::new_pb_name::<CoreRequest>(
"CoreRequest",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static CoreRequest {
static mut instance: ::protobuf::lazy::Lazy<CoreRequest> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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: ::std::boxed::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::INIT;
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_pb_name::<CoreResponse>(
"CoreResponse",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static CoreResponse {
static mut instance: ::protobuf::lazy::Lazy<CoreResponse> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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: ::std::boxed::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::INIT;
unsafe {
descriptor.get(|| {
let fields = ::std::vec::Vec::new();
::protobuf::reflect::MessageDescriptor::new_pb_name::<Void>(
"Void",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Void {
static mut instance: ::protobuf::lazy::Lazy<Void> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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: ::std::boxed::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::INIT;
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_pb_name::<Scenario>(
"Scenario",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Scenario {
static mut instance: ::protobuf::lazy::Lazy<Scenario> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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: ::std::boxed::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::INIT;
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_pb_name::<Scenarios>(
"Scenarios",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Scenarios {
static mut instance: ::protobuf::lazy::Lazy<Scenarios> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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: ::std::boxed::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::INIT;
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_pb_name::<ScenarioResultSummary>(
"ScenarioResultSummary",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ScenarioResultSummary {
static mut instance: ::protobuf::lazy::Lazy<ScenarioResultSummary> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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: ::std::boxed::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::INIT;
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_pb_name::<ScenarioResult>(
"ScenarioResult",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static ScenarioResult {
static mut instance: ::protobuf::lazy::Lazy<ScenarioResult> = ::protobuf::lazy::Lazy::INIT;
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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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::INIT;
unsafe {
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new_pb_name::<ClientType>("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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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::INIT;
unsafe {
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new_pb_name::<ServerType>("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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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::INIT;
unsafe {
descriptor.get(|| {
::protobuf::reflect::EnumDescriptor::new_pb_name::<RpcType>("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::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::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\x04J\xdeX\n\x07\x12\x05\x0e\0\x8c\x02\
\x01\n\xbf\x04\n\x01\x0c\x12\x03\x0e\0\x122\xb4\x04\x20Copyright\x202015\
\x20gRPC\x20authors.\n\n\x20Licensed\x20under\x20the\x20Apache\x20Licens\
e,\x20Version\x202.0\x20(the\x20\"License\");\n\x20you\x20may\x20not\x20\
use\x20this\x20file\x20except\x20in\x20compliance\x20with\x20the\x20Lice\
nse.\n\x20You\x20may\x20obtain\x20a\x20copy\x20of\x20the\x20License\x20a\
t\n\n\x20\x20\x20\x20\x20http://www.apache.org/licenses/LICENSE-2.0\n\n\
\x20Unless\x20required\x20by\x20applicable\x20law\x20or\x20agreed\x20to\
\x20in\x20writing,\x20software\n\x20distributed\x20under\x20the\x20Licen\
se\x20is\x20distributed\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHO\
UT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20\
express\x20or\x20implied.\n\x20See\x20the\x20License\x20for\x20the\x20sp\
ecific\x20language\x20governing\x20permissions\x20and\n\x20limitations\
\x20under\x20the\x20License.\n\n\t\n\x02\x03\0\x12\x03\x10\x07$\n\t\n\
\x02\x03\x01\x12\x03\x11\x07!\n\x08\n\x01\x02\x12\x03\x13\x08\x14\n\n\n\
\x02\x05\0\x12\x04\x15\0\x1b\x01\n\n\n\x03\x05\0\x01\x12\x03\x15\x05\x0f\
\n\x80\x01\n\x04\x05\0\x02\0\x12\x03\x18\x02\x12\x1as\x20Many\x20languag\
es\x20support\x20a\x20basic\x20distinction\x20between\x20using\n\x20sync\
\x20or\x20async\x20client,\x20and\x20this\x20allows\x20the\x20specificat\
ion\n\n\x0c\n\x05\x05\0\x02\0\x01\x12\x03\x18\x02\r\n\x0c\n\x05\x05\0\
\x02\0\x02\x12\x03\x18\x10\x11\n\x0b\n\x04\x05\0\x02\x01\x12\x03\x19\x02\
\x13\n\x0c\n\x05\x05\0\x02\x01\x01\x12\x03\x19\x02\x0e\n\x0c\n\x05\x05\0\
\x02\x01\x02\x12\x03\x19\x11\x12\n7\n\x04\x05\0\x02\x02\x12\x03\x1a\x02\
\x13\"*\x20used\x20for\x20some\x20language-specific\x20variants\n\n\x0c\
\n\x05\x05\0\x02\x02\x01\x12\x03\x1a\x02\x0e\n\x0c\n\x05\x05\0\x02\x02\
\x02\x12\x03\x1a\x11\x12\n\n\n\x02\x05\x01\x12\x04\x1d\0\"\x01\n\n\n\x03\
\x05\x01\x01\x12\x03\x1d\x05\x0f\n\x0b\n\x04\x05\x01\x02\0\x12\x03\x1e\
\x02\x12\n\x0c\n\x05\x05\x01\x02\0\x01\x12\x03\x1e\x02\r\n\x0c\n\x05\x05\
\x01\x02\0\x02\x12\x03\x1e\x10\x11\n\x0b\n\x04\x05\x01\x02\x01\x12\x03\
\x1f\x02\x13\n\x0c\n\x05\x05\x01\x02\x01\x01\x12\x03\x1f\x02\x0e\n\x0c\n\
\x05\x05\x01\x02\x01\x02\x12\x03\x1f\x11\x12\n\x0b\n\x04\x05\x01\x02\x02\
\x12\x03\x20\x02\x1b\n\x0c\n\x05\x05\x01\x02\x02\x01\x12\x03\x20\x02\x16\
\n\x0c\n\x05\x05\x01\x02\x02\x02\x12\x03\x20\x19\x1a\n7\n\x04\x05\x01\
\x02\x03\x12\x03!\x02\x13\"*\x20used\x20for\x20some\x20language-specific\
\x20variants\n\n\x0c\n\x05\x05\x01\x02\x03\x01\x12\x03!\x02\x0e\n\x0c\n\
\x05\x05\x01\x02\x03\x02\x12\x03!\x11\x12\n\n\n\x02\x05\x02\x12\x04$\0*\
\x01\n\n\n\x03\x05\x02\x01\x12\x03$\x05\x0c\n\x0b\n\x04\x05\x02\x02\0\
\x12\x03%\x02\x0c\n\x0c\n\x05\x05\x02\x02\0\x01\x12\x03%\x02\x07\n\x0c\n\
\x05\x05\x02\x02\0\x02\x12\x03%\n\x0b\n\x0b\n\x04\x05\x02\x02\x01\x12\
\x03&\x02\x10\n\x0c\n\x05\x05\x02\x02\x01\x01\x12\x03&\x02\x0b\n\x0c\n\
\x05\x05\x02\x02\x01\x02\x12\x03&\x0e\x0f\n\x0b\n\x04\x05\x02\x02\x02\
\x12\x03'\x02\x1c\n\x0c\n\x05\x05\x02\x02\x02\x01\x12\x03'\x02\x17\n\x0c\
\n\x05\x05\x02\x02\x02\x02\x12\x03'\x1a\x1b\n\x0b\n\x04\x05\x02\x02\x03\
\x12\x03(\x02\x1c\n\x0c\n\x05\x05\x02\x02\x03\x01\x12\x03(\x02\x17\n\x0c\
\n\x05\x05\x02\x02\x03\x02\x12\x03(\x1a\x1b\n\x0b\n\x04\x05\x02\x02\x04\
\x12\x03)\x02\x1a\n\x0c\n\x05\x05\x02\x02\x04\x01\x12\x03)\x02\x15\n\x0c\
\n\x05\x05\x02\x02\x04\x02\x12\x03)\x18\x19\n\x9f\x01\n\x02\x04\0\x12\
\x04.\01\x01\x1a\x92\x01\x20Parameters\x20of\x20poisson\x20process\x20di\
stribution,\x20which\x20is\x20a\x20good\x20representation\n\x20of\x20act\
ivity\x20coming\x20in\x20from\x20independent\x20identical\x20stationary\
\x20sources.\n\n\n\n\x03\x04\0\x01\x12\x03.\x08\x15\nV\n\x04\x04\0\x02\0\
\x12\x030\x02\x1a\x1aI\x20The\x20rate\x20of\x20arrivals\x20(a.k.a.\x20la\
mbda\x20parameter\x20of\x20the\x20exp\x20distribution).\n\n\r\n\x05\x04\
\0\x02\0\x04\x12\x040\x02.\x17\n\x0c\n\x05\x04\0\x02\0\x05\x12\x030\x02\
\x08\n\x0c\n\x05\x04\0\x02\0\x01\x12\x030\t\x15\n\x0c\n\x05\x04\0\x02\0\
\x03\x12\x030\x18\x19\nd\n\x02\x04\x01\x12\x035\0\x1b\x1aY\x20Once\x20an\
\x20RPC\x20finishes,\x20immediately\x20start\x20a\x20new\x20one.\n\x20No\
\x20configuration\x20parameters\x20needed.\n\n\n\n\x03\x04\x01\x01\x12\
\x035\x08\x18\n\n\n\x02\x04\x02\x12\x047\0<\x01\n\n\n\x03\x04\x02\x01\
\x12\x037\x08\x12\n\x0c\n\x04\x04\x02\x08\0\x12\x048\x02;\x03\n\x0c\n\
\x05\x04\x02\x08\0\x01\x12\x038\x08\x0c\n\x0b\n\x04\x04\x02\x02\0\x12\
\x039\x04%\n\x0c\n\x05\x04\x02\x02\0\x06\x12\x039\x04\x14\n\x0c\n\x05\
\x04\x02\x02\0\x01\x12\x039\x15\x20\n\x0c\n\x05\x04\x02\x02\0\x03\x12\
\x039#$\n\x0b\n\x04\x04\x02\x02\x01\x12\x03:\x04\x1e\n\x0c\n\x05\x04\x02\
\x02\x01\x06\x12\x03:\x04\x11\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03:\
\x12\x19\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03:\x1c\x1d\n;\n\x02\x04\
\x03\x12\x04?\0C\x01\x1a/\x20presence\x20of\x20SecurityParams\x20implies\
\x20use\x20of\x20TLS\n\n\n\n\x03\x04\x03\x01\x12\x03?\x08\x16\n\x0b\n\
\x04\x04\x03\x02\0\x12\x03@\x02\x17\n\r\n\x05\x04\x03\x02\0\x04\x12\x04@\
\x02?\x18\n\x0c\n\x05\x04\x03\x02\0\x05\x12\x03@\x02\x06\n\x0c\n\x05\x04\
\x03\x02\0\x01\x12\x03@\x07\x12\n\x0c\n\x05\x04\x03\x02\0\x03\x12\x03@\
\x15\x16\n\x0b\n\x04\x04\x03\x02\x01\x12\x03A\x02\"\n\r\n\x05\x04\x03\
\x02\x01\x04\x12\x04A\x02@\x17\n\x0c\n\x05\x04\x03\x02\x01\x05\x12\x03A\
\x02\x08\n\x0c\n\x05\x04\x03\x02\x01\x01\x12\x03A\t\x1d\n\x0c\n\x05\x04\
\x03\x02\x01\x03\x12\x03A\x20!\n\x0b\n\x04\x04\x03\x02\x02\x12\x03B\x02\
\x17\n\r\n\x05\x04\x03\x02\x02\x04\x12\x04B\x02A\"\n\x0c\n\x05\x04\x03\
\x02\x02\x05\x12\x03B\x02\x08\n\x0c\n\x05\x04\x03\x02\x02\x01\x12\x03B\t\
\x12\n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03B\x15\x16\n\n\n\x02\x04\x04\
\x12\x04E\0K\x01\n\n\n\x03\x04\x04\x01\x12\x03E\x08\x12\n\x0b\n\x04\x04\
\x04\x02\0\x12\x03F\x02\x12\n\r\n\x05\x04\x04\x02\0\x04\x12\x04F\x02E\
\x14\n\x0c\n\x05\x04\x04\x02\0\x05\x12\x03F\x02\x08\n\x0c\n\x05\x04\x04\
\x02\0\x01\x12\x03F\t\r\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03F\x10\x11\n\
\x0c\n\x04\x04\x04\x08\0\x12\x04G\x02J\x03\n\x0c\n\x05\x04\x04\x08\0\x01\
\x12\x03G\x08\r\n\x0b\n\x04\x04\x04\x02\x01\x12\x03H\x04\x19\n\x0c\n\x05\
\x04\x04\x02\x01\x05\x12\x03H\x04\n\n\x0c\n\x05\x04\x04\x02\x01\x01\x12\
\x03H\x0b\x14\n\x0c\n\x05\x04\x04\x02\x01\x03\x12\x03H\x17\x18\n\x0b\n\
\x04\x04\x04\x02\x02\x12\x03I\x04\x18\n\x0c\n\x05\x04\x04\x02\x02\x05\
\x12\x03I\x04\t\n\x0c\n\x05\x04\x04\x02\x02\x01\x12\x03I\n\x13\n\x0c\n\
\x05\x04\x04\x02\x02\x03\x12\x03I\x16\x17\n\n\n\x02\x04\x05\x12\x04M\0n\
\x01\n\n\n\x03\x04\x05\x01\x12\x03M\x08\x14\nX\n\x04\x04\x05\x02\0\x12\
\x03O\x02%\x1aK\x20List\x20of\x20targets\x20to\x20connect\x20to.\x20At\
\x20least\x20one\x20target\x20needs\x20to\x20be\x20specified.\n\n\x0c\n\
\x05\x04\x05\x02\0\x04\x12\x03O\x02\n\n\x0c\n\x05\x04\x05\x02\0\x05\x12\
\x03O\x0b\x11\n\x0c\n\x05\x04\x05\x02\0\x01\x12\x03O\x12\x20\n\x0c\n\x05\
\x04\x05\x02\0\x03\x12\x03O#$\n\x0b\n\x04\x04\x05\x02\x01\x12\x03P\x02\
\x1d\n\r\n\x05\x04\x05\x02\x01\x04\x12\x04P\x02O%\n\x0c\n\x05\x04\x05\
\x02\x01\x06\x12\x03P\x02\x0c\n\x0c\n\x05\x04\x05\x02\x01\x01\x12\x03P\r\
\x18\n\x0c\n\x05\x04\x05\x02\x01\x03\x12\x03P\x1b\x1c\n\x0b\n\x04\x04\
\x05\x02\x02\x12\x03Q\x02%\n\r\n\x05\x04\x05\x02\x02\x04\x12\x04Q\x02P\
\x1d\n\x0c\n\x05\x04\x05\x02\x02\x06\x12\x03Q\x02\x10\n\x0c\n\x05\x04\
\x05\x02\x02\x01\x12\x03Q\x11\x20\n\x0c\n\x05\x04\x05\x02\x02\x03\x12\
\x03Q#$\n\x8b\x01\n\x04\x04\x05\x02\x03\x12\x03T\x02)\x1a~\x20How\x20man\
y\x20concurrent\x20RPCs\x20to\x20start\x20for\x20each\x20channel.\n\x20F\
or\x20synchronous\x20client,\x20use\x20a\x20separate\x20thread\x20for\
\x20each\x20outstanding\x20RPC.\n\n\r\n\x05\x04\x05\x02\x03\x04\x12\x04T\
\x02Q%\n\x0c\n\x05\x04\x05\x02\x03\x05\x12\x03T\x02\x07\n\x0c\n\x05\x04\
\x05\x02\x03\x01\x12\x03T\x08$\n\x0c\n\x05\x04\x05\x02\x03\x03\x12\x03T'\
(\n\x86\x01\n\x04\x04\x05\x02\x04\x12\x03W\x02\x1c\x1ay\x20Number\x20of\
\x20independent\x20client\x20channels\x20to\x20create.\n\x20i-th\x20chan\
nel\x20will\x20connect\x20to\x20server_target[i\x20%\x20server_targets.s\
ize()]\n\n\r\n\x05\x04\x05\x02\x04\x04\x12\x04W\x02T)\n\x0c\n\x05\x04\
\x05\x02\x04\x05\x12\x03W\x02\x07\n\x0c\n\x05\x04\x05\x02\x04\x01\x12\
\x03W\x08\x17\n\x0c\n\x05\x04\x05\x02\x04\x03\x12\x03W\x1a\x1b\nT\n\x04\
\x04\x05\x02\x05\x12\x03Y\x02!\x1aG\x20Only\x20for\x20async\x20client.\
\x20Number\x20of\x20threads\x20to\x20use\x20to\x20start/manage\x20RPCs.\
\n\n\r\n\x05\x04\x05\x02\x05\x04\x12\x04Y\x02W\x1c\n\x0c\n\x05\x04\x05\
\x02\x05\x05\x12\x03Y\x02\x07\n\x0c\n\x05\x04\x05\x02\x05\x01\x12\x03Y\
\x08\x1c\n\x0c\n\x05\x04\x05\x02\x05\x03\x12\x03Y\x1f\x20\n\x0b\n\x04\
\x04\x05\x02\x06\x12\x03Z\x02\x17\n\r\n\x05\x04\x05\x02\x06\x04\x12\x04Z\
\x02Y!\n\x0c\n\x05\x04\x05\x02\x06\x06\x12\x03Z\x02\t\n\x0c\n\x05\x04\
\x05\x02\x06\x01\x12\x03Z\n\x12\n\x0c\n\x05\x04\x05\x02\x06\x03\x12\x03Z\
\x15\x16\nZ\n\x04\x04\x05\x02\x07\x12\x03\\\x02\x1e\x1aM\x20The\x20reque\
sted\x20load\x20for\x20the\x20entire\x20client\x20(aggregated\x20over\
\x20all\x20the\x20threads).\n\n\r\n\x05\x04\x05\x02\x07\x04\x12\x04\\\
\x02Z\x17\n\x0c\n\x05\x04\x05\x02\x07\x06\x12\x03\\\x02\x0c\n\x0c\n\x05\
\x04\x05\x02\x07\x01\x12\x03\\\r\x18\n\x0c\n\x05\x04\x05\x02\x07\x03\x12\
\x03\\\x1b\x1d\n\x0b\n\x04\x04\x05\x02\x08\x12\x03]\x02$\n\r\n\x05\x04\
\x05\x02\x08\x04\x12\x04]\x02\\\x1e\n\x0c\n\x05\x04\x05\x02\x08\x06\x12\
\x03]\x02\x0f\n\x0c\n\x05\x04\x05\x02\x08\x01\x12\x03]\x10\x1e\n\x0c\n\
\x05\x04\x05\x02\x08\x03\x12\x03]!#\n\x0b\n\x04\x04\x05\x02\t\x12\x03^\
\x02(\n\r\n\x05\x04\x05\x02\t\x04\x12\x04^\x02]$\n\x0c\n\x05\x04\x05\x02\
\t\x06\x12\x03^\x02\x11\n\x0c\n\x05\x04\x05\x02\t\x01\x12\x03^\x12\"\n\
\x0c\n\x05\x04\x05\x02\t\x03\x12\x03^%'\nH\n\x04\x04\x05\x02\n\x12\x03a\
\x02\x20\x1a;\x20Specify\x20the\x20cores\x20we\x20should\x20run\x20the\
\x20client\x20on,\x20if\x20desired\n\n\x0c\n\x05\x04\x05\x02\n\x04\x12\
\x03a\x02\n\n\x0c\n\x05\x04\x05\x02\n\x05\x12\x03a\x0b\x10\n\x0c\n\x05\
\x04\x05\x02\n\x01\x12\x03a\x11\x1a\n\x0c\n\x05\x04\x05\x02\n\x03\x12\
\x03a\x1d\x1f\n\x0b\n\x04\x04\x05\x02\x0b\x12\x03b\x02\x18\n\r\n\x05\x04\
\x05\x02\x0b\x04\x12\x04b\x02a\x20\n\x0c\n\x05\x04\x05\x02\x0b\x05\x12\
\x03b\x02\x07\n\x0c\n\x05\x04\x05\x02\x0b\x01\x12\x03b\x08\x12\n\x0c\n\
\x05\x04\x05\x02\x0b\x03\x12\x03b\x15\x17\nS\n\x04\x04\x05\x02\x0c\x12\
\x03e\x02\x1f\x1aF\x20If\x20we\x20use\x20an\x20OTHER_CLIENT\x20client_ty\
pe,\x20this\x20string\x20gives\x20more\x20detail\n\n\r\n\x05\x04\x05\x02\
\x0c\x04\x12\x04e\x02b\x18\n\x0c\n\x05\x04\x05\x02\x0c\x05\x12\x03e\x02\
\x08\n\x0c\n\x05\x04\x05\x02\x0c\x01\x12\x03e\t\x19\n\x0c\n\x05\x04\x05\
\x02\x0c\x03\x12\x03e\x1c\x1e\n\x0b\n\x04\x04\x05\x02\r\x12\x03g\x02(\n\
\x0c\n\x05\x04\x05\x02\r\x04\x12\x03g\x02\n\n\x0c\n\x05\x04\x05\x02\r\
\x06\x12\x03g\x0b\x15\n\x0c\n\x05\x04\x05\x02\r\x01\x12\x03g\x16\"\n\x0c\
\n\x05\x04\x05\x02\r\x03\x12\x03g%'\nA\n\x04\x04\x05\x02\x0e\x12\x03j\
\x02\x1c\x1a4\x20Number\x20of\x20threads\x20that\x20share\x20each\x20com\
pletion\x20queue\n\n\r\n\x05\x04\x05\x02\x0e\x04\x12\x04j\x02g(\n\x0c\n\
\x05\x04\x05\x02\x0e\x05\x12\x03j\x02\x07\n\x0c\n\x05\x04\x05\x02\x0e\
\x01\x12\x03j\x08\x16\n\x0c\n\x05\x04\x05\x02\x0e\x03\x12\x03j\x19\x1b\n\
O\n\x04\x04\x05\x02\x0f\x12\x03m\x02!\x1aB\x20Number\x20of\x20messages\
\x20on\x20a\x20stream\x20before\x20it\x20gets\x20finished/restarted\n\n\
\r\n\x05\x04\x05\x02\x0f\x04\x12\x04m\x02j\x1c\n\x0c\n\x05\x04\x05\x02\
\x0f\x05\x12\x03m\x02\x07\n\x0c\n\x05\x04\x05\x02\x0f\x01\x12\x03m\x08\
\x1b\n\x0c\n\x05\x04\x05\x02\x0f\x03\x12\x03m\x1e\x20\n\t\n\x02\x04\x06\
\x12\x03p\0/\n\n\n\x03\x04\x06\x01\x12\x03p\x08\x14\n\x0b\n\x04\x04\x06\
\x02\0\x12\x03p\x17-\n\x0c\n\x05\x04\x06\x02\0\x04\x12\x03p\x17\x16\n\
\x0c\n\x05\x04\x06\x02\0\x06\x12\x03p\x17\"\n\x0c\n\x05\x04\x06\x02\0\
\x01\x12\x03p#(\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x03p+,\n#\n\x02\x04\
\x07\x12\x04s\0v\x01\x1a\x17\x20Request\x20current\x20stats\n\n\n\n\x03\
\x04\x07\x01\x12\x03s\x08\x0c\nL\n\x04\x04\x07\x02\0\x12\x03u\x02\x11\
\x1a?\x20if\x20true,\x20the\x20stats\x20will\x20be\x20reset\x20after\x20\
taking\x20their\x20snapshot.\n\n\r\n\x05\x04\x07\x02\0\x04\x12\x04u\x02s\
\x0e\n\x0c\n\x05\x04\x07\x02\0\x05\x12\x03u\x02\x06\n\x0c\n\x05\x04\x07\
\x02\0\x01\x12\x03u\x07\x0c\n\x0c\n\x05\x04\x07\x02\0\x03\x12\x03u\x0f\
\x10\n\n\n\x02\x04\x08\x12\x04x\0}\x01\n\n\n\x03\x04\x08\x01\x12\x03x\
\x08\x12\n\x0c\n\x04\x04\x08\x08\0\x12\x04y\x02|\x03\n\x0c\n\x05\x04\x08\
\x08\0\x01\x12\x03y\x08\x0f\n\x0b\n\x04\x04\x08\x02\0\x12\x03z\x04\x1b\n\
\x0c\n\x05\x04\x08\x02\0\x06\x12\x03z\x04\x10\n\x0c\n\x05\x04\x08\x02\0\
\x01\x12\x03z\x11\x16\n\x0c\n\x05\x04\x08\x02\0\x03\x12\x03z\x19\x1a\n\
\x0b\n\x04\x04\x08\x02\x01\x12\x03{\x04\x12\n\x0c\n\x05\x04\x08\x02\x01\
\x06\x12\x03{\x04\x08\n\x0c\n\x05\x04\x08\x02\x01\x01\x12\x03{\t\r\n\x0c\
\n\x05\x04\x08\x02\x01\x03\x12\x03{\x10\x11\n\x0b\n\x02\x04\t\x12\x05\
\x7f\0\x9c\x01\x01\n\n\n\x03\x04\t\x01\x12\x03\x7f\x08\x14\n\x0c\n\x04\
\x04\t\x02\0\x12\x04\x80\x01\x02\x1d\n\x0e\n\x05\x04\t\x02\0\x04\x12\x05\
\x80\x01\x02\x7f\x16\n\r\n\x05\x04\t\x02\0\x06\x12\x04\x80\x01\x02\x0c\n\
\r\n\x05\x04\t\x02\0\x01\x12\x04\x80\x01\r\x18\n\r\n\x05\x04\t\x02\0\x03\
\x12\x04\x80\x01\x1b\x1c\n\x0c\n\x04\x04\t\x02\x01\x12\x04\x81\x01\x02%\
\n\x0f\n\x05\x04\t\x02\x01\x04\x12\x06\x81\x01\x02\x80\x01\x1d\n\r\n\x05\
\x04\t\x02\x01\x06\x12\x04\x81\x01\x02\x10\n\r\n\x05\x04\t\x02\x01\x01\
\x12\x04\x81\x01\x11\x20\n\r\n\x05\x04\t\x02\x01\x03\x12\x04\x81\x01#$\n\
E\n\x04\x04\t\x02\x02\x12\x04\x83\x01\x02\x11\x1a7\x20Port\x20on\x20whic\
h\x20to\x20listen.\x20Zero\x20means\x20pick\x20unused\x20port.\n\n\x0f\n\
\x05\x04\t\x02\x02\x04\x12\x06\x83\x01\x02\x81\x01%\n\r\n\x05\x04\t\x02\
\x02\x05\x12\x04\x83\x01\x02\x07\n\r\n\x05\x04\t\x02\x02\x01\x12\x04\x83\
\x01\x08\x0c\n\r\n\x05\x04\t\x02\x02\x03\x12\x04\x83\x01\x0f\x10\nT\n\
\x04\x04\t\x02\x03\x12\x04\x85\x01\x02!\x1aF\x20Only\x20for\x20async\x20\
server.\x20Number\x20of\x20threads\x20used\x20to\x20serve\x20the\x20requ\
ests.\n\n\x0f\n\x05\x04\t\x02\x03\x04\x12\x06\x85\x01\x02\x83\x01\x11\n\
\r\n\x05\x04\t\x02\x03\x05\x12\x04\x85\x01\x02\x07\n\r\n\x05\x04\t\x02\
\x03\x01\x12\x04\x85\x01\x08\x1c\n\r\n\x05\x04\t\x02\x03\x03\x12\x04\x85\
\x01\x1f\x20\nJ\n\x04\x04\t\x02\x04\x12\x04\x87\x01\x02\x17\x1a<\x20Spec\
ify\x20the\x20number\x20of\x20cores\x20to\x20limit\x20server\x20to,\x20i\
f\x20desired\n\n\x0f\n\x05\x04\t\x02\x04\x04\x12\x06\x87\x01\x02\x85\x01\
!\n\r\n\x05\x04\t\x02\x04\x05\x12\x04\x87\x01\x02\x07\n\r\n\x05\x04\t\
\x02\x04\x01\x12\x04\x87\x01\x08\x12\n\r\n\x05\x04\t\x02\x04\x03\x12\x04\
\x87\x01\x15\x16\n\xfc\x01\n\x04\x04\t\x02\x05\x12\x04\x8c\x01\x02#\x1a\
\xed\x01\x20payload\x20config,\x20used\x20in\x20generic\x20server.\n\x20\
Note\x20this\x20must\x20NOT\x20be\x20used\x20in\x20proto\x20(non-generic\
)\x20servers.\x20For\x20proto\x20servers,\n\x20'response\x20sizes'\x20mu\
st\x20be\x20configured\x20from\x20the\x20'response_size'\x20field\x20of\
\x20the\n\x20'SimpleRequest'\x20objects\x20in\x20RPC\x20requests.\n\n\
\x0f\n\x05\x04\t\x02\x05\x04\x12\x06\x8c\x01\x02\x87\x01\x17\n\r\n\x05\
\x04\t\x02\x05\x06\x12\x04\x8c\x01\x02\x0f\n\r\n\x05\x04\t\x02\x05\x01\
\x12\x04\x8c\x01\x10\x1e\n\r\n\x05\x04\t\x02\x05\x03\x12\x04\x8c\x01!\"\
\nI\n\x04\x04\t\x02\x06\x12\x04\x8f\x01\x02\x20\x1a;\x20Specify\x20the\
\x20cores\x20we\x20should\x20run\x20the\x20server\x20on,\x20if\x20desire\
d\n\n\r\n\x05\x04\t\x02\x06\x04\x12\x04\x8f\x01\x02\n\n\r\n\x05\x04\t\
\x02\x06\x05\x12\x04\x8f\x01\x0b\x10\n\r\n\x05\x04\t\x02\x06\x01\x12\x04\
\x8f\x01\x11\x1a\n\r\n\x05\x04\t\x02\x06\x03\x12\x04\x8f\x01\x1d\x1f\nT\
\n\x04\x04\t\x02\x07\x12\x04\x92\x01\x02\x1f\x1aF\x20If\x20we\x20use\x20\
an\x20OTHER_SERVER\x20client_type,\x20this\x20string\x20gives\x20more\
\x20detail\n\n\x0f\n\x05\x04\t\x02\x07\x04\x12\x06\x92\x01\x02\x8f\x01\
\x20\n\r\n\x05\x04\t\x02\x07\x05\x12\x04\x92\x01\x02\x08\n\r\n\x05\x04\t\
\x02\x07\x01\x12\x04\x92\x01\t\x19\n\r\n\x05\x04\t\x02\x07\x03\x12\x04\
\x92\x01\x1c\x1e\nB\n\x04\x04\t\x02\x08\x12\x04\x95\x01\x02\x1c\x1a4\x20\
Number\x20of\x20threads\x20that\x20share\x20each\x20completion\x20queue\
\n\n\x0f\n\x05\x04\t\x02\x08\x04\x12\x06\x95\x01\x02\x92\x01\x1f\n\r\n\
\x05\x04\t\x02\x08\x05\x12\x04\x95\x01\x02\x07\n\r\n\x05\x04\t\x02\x08\
\x01\x12\x04\x95\x01\x08\x16\n\r\n\x05\x04\t\x02\x08\x03\x12\x04\x95\x01\
\x19\x1b\n\x83\x01\n\x04\x04\t\x02\t\x12\x04\x9a\x01\x02#\x1a6\x20Buffer\
\x20pool\x20size\x20(no\x20buffer\x20pool\x20specified\x20if\x20unset)\n\
2=\x20c++-only\x20options\x20(for\x20now)\x20---------------------------\
-----\n\n\x0f\n\x05\x04\t\x02\t\x04\x12\x06\x9a\x01\x02\x95\x01\x1c\n\r\
\n\x05\x04\t\x02\t\x05\x12\x04\x9a\x01\x02\x07\n\r\n\x05\x04\t\x02\t\x01\
\x12\x04\x9a\x01\x08\x1b\n\r\n\x05\x04\t\x02\t\x03\x12\x04\x9a\x01\x1e\"\
\n\x0c\n\x04\x04\t\x02\n\x12\x04\x9b\x01\x02*\n\r\n\x05\x04\t\x02\n\x04\
\x12\x04\x9b\x01\x02\n\n\r\n\x05\x04\t\x02\n\x06\x12\x04\x9b\x01\x0b\x15\
\n\r\n\x05\x04\t\x02\n\x01\x12\x04\x9b\x01\x16\"\n\r\n\x05\x04\t\x02\n\
\x03\x12\x04\x9b\x01%)\n\x0c\n\x02\x04\n\x12\x06\x9e\x01\0\xa3\x01\x01\n\
\x0b\n\x03\x04\n\x01\x12\x04\x9e\x01\x08\x12\n\x0e\n\x04\x04\n\x08\0\x12\
\x06\x9f\x01\x02\xa2\x01\x03\n\r\n\x05\x04\n\x08\0\x01\x12\x04\x9f\x01\
\x08\x0f\n\x0c\n\x04\x04\n\x02\0\x12\x04\xa0\x01\x04\x1b\n\r\n\x05\x04\n\
\x02\0\x06\x12\x04\xa0\x01\x04\x10\n\r\n\x05\x04\n\x02\0\x01\x12\x04\xa0\
\x01\x11\x16\n\r\n\x05\x04\n\x02\0\x03\x12\x04\xa0\x01\x19\x1a\n\x0c\n\
\x04\x04\n\x02\x01\x12\x04\xa1\x01\x04\x12\n\r\n\x05\x04\n\x02\x01\x06\
\x12\x04\xa1\x01\x04\x08\n\r\n\x05\x04\n\x02\x01\x01\x12\x04\xa1\x01\t\r\
\n\r\n\x05\x04\n\x02\x01\x03\x12\x04\xa1\x01\x10\x11\n\x0c\n\x02\x04\x0b\
\x12\x06\xa5\x01\0\xab\x01\x01\n\x0b\n\x03\x04\x0b\x01\x12\x04\xa5\x01\
\x08\x14\n\x0c\n\x04\x04\x0b\x02\0\x12\x04\xa6\x01\x02\x18\n\x0f\n\x05\
\x04\x0b\x02\0\x04\x12\x06\xa6\x01\x02\xa5\x01\x16\n\r\n\x05\x04\x0b\x02\
\0\x06\x12\x04\xa6\x01\x02\r\n\r\n\x05\x04\x0b\x02\0\x01\x12\x04\xa6\x01\
\x0e\x13\n\r\n\x05\x04\x0b\x02\0\x03\x12\x04\xa6\x01\x16\x17\n,\n\x04\
\x04\x0b\x02\x01\x12\x04\xa8\x01\x02\x11\x1a\x1e\x20the\x20port\x20bound\
\x20by\x20the\x20server\n\n\x0f\n\x05\x04\x0b\x02\x01\x04\x12\x06\xa8\
\x01\x02\xa6\x01\x18\n\r\n\x05\x04\x0b\x02\x01\x05\x12\x04\xa8\x01\x02\
\x07\n\r\n\x05\x04\x0b\x02\x01\x01\x12\x04\xa8\x01\x08\x0c\n\r\n\x05\x04\
\x0b\x02\x01\x03\x12\x04\xa8\x01\x0f\x10\n7\n\x04\x04\x0b\x02\x02\x12\
\x04\xaa\x01\x02\x12\x1a)\x20Number\x20of\x20cores\x20available\x20to\
\x20the\x20server\n\n\x0f\n\x05\x04\x0b\x02\x02\x04\x12\x06\xaa\x01\x02\
\xa8\x01\x11\n\r\n\x05\x04\x0b\x02\x02\x05\x12\x04\xaa\x01\x02\x07\n\r\n\
\x05\x04\x0b\x02\x02\x01\x12\x04\xaa\x01\x08\r\n\r\n\x05\x04\x0b\x02\x02\
\x03\x12\x04\xaa\x01\x10\x11\n\x0c\n\x02\x04\x0c\x12\x06\xad\x01\0\xae\
\x01\x01\n\x0b\n\x03\x04\x0c\x01\x12\x04\xad\x01\x08\x13\n\x0c\n\x02\x04\
\r\x12\x06\xb0\x01\0\xb3\x01\x01\n\x0b\n\x03\x04\r\x01\x12\x04\xb0\x01\
\x08\x14\n7\n\x04\x04\r\x02\0\x12\x04\xb2\x01\x02\x12\x1a)\x20Number\x20\
of\x20cores\x20available\x20on\x20the\x20server\n\n\x0f\n\x05\x04\r\x02\
\0\x04\x12\x06\xb2\x01\x02\xb0\x01\x16\n\r\n\x05\x04\r\x02\0\x05\x12\x04\
\xb2\x01\x02\x07\n\r\n\x05\x04\r\x02\0\x01\x12\x04\xb2\x01\x08\r\n\r\n\
\x05\x04\r\x02\0\x03\x12\x04\xb2\x01\x10\x11\n\x0c\n\x02\x04\x0e\x12\x06\
\xb5\x01\0\xb6\x01\x01\n\x0b\n\x03\x04\x0e\x01\x12\x04\xb5\x01\x08\x0c\n\
G\n\x02\x04\x0f\x12\x06\xb9\x01\0\xca\x01\x01\x1a9\x20A\x20single\x20per\
formance\x20scenario:\x20input\x20to\x20qps_json_driver\n\n\x0b\n\x03\
\x04\x0f\x01\x12\x04\xb9\x01\x08\x10\n5\n\x04\x04\x0f\x02\0\x12\x04\xbb\
\x01\x02\x12\x1a'\x20Human\x20readable\x20name\x20for\x20this\x20scenari\
o\n\n\x0f\n\x05\x04\x0f\x02\0\x04\x12\x06\xbb\x01\x02\xb9\x01\x12\n\r\n\
\x05\x04\x0f\x02\0\x05\x12\x04\xbb\x01\x02\x08\n\r\n\x05\x04\x0f\x02\0\
\x01\x12\x04\xbb\x01\t\r\n\r\n\x05\x04\x0f\x02\0\x03\x12\x04\xbb\x01\x10\
\x11\n$\n\x04\x04\x0f\x02\x01\x12\x04\xbd\x01\x02!\x1a\x16\x20Client\x20\
configuration\n\n\x0f\n\x05\x04\x0f\x02\x01\x04\x12\x06\xbd\x01\x02\xbb\
\x01\x12\n\r\n\x05\x04\x0f\x02\x01\x06\x12\x04\xbd\x01\x02\x0e\n\r\n\x05\
\x04\x0f\x02\x01\x01\x12\x04\xbd\x01\x0f\x1c\n\r\n\x05\x04\x0f\x02\x01\
\x03\x12\x04\xbd\x01\x1f\x20\n7\n\x04\x04\x0f\x02\x02\x12\x04\xbf\x01\
\x02\x18\x1a)\x20Number\x20of\x20clients\x20to\x20start\x20for\x20the\
\x20test\n\n\x0f\n\x05\x04\x0f\x02\x02\x04\x12\x06\xbf\x01\x02\xbd\x01!\
\n\r\n\x05\x04\x0f\x02\x02\x05\x12\x04\xbf\x01\x02\x07\n\r\n\x05\x04\x0f\
\x02\x02\x01\x12\x04\xbf\x01\x08\x13\n\r\n\x05\x04\x0f\x02\x02\x03\x12\
\x04\xbf\x01\x16\x17\n$\n\x04\x04\x0f\x02\x03\x12\x04\xc1\x01\x02!\x1a\
\x16\x20Server\x20configuration\n\n\x0f\n\x05\x04\x0f\x02\x03\x04\x12\
\x06\xc1\x01\x02\xbf\x01\x18\n\r\n\x05\x04\x0f\x02\x03\x06\x12\x04\xc1\
\x01\x02\x0e\n\r\n\x05\x04\x0f\x02\x03\x01\x12\x04\xc1\x01\x0f\x1c\n\r\n\
\x05\x04\x0f\x02\x03\x03\x12\x04\xc1\x01\x1f\x20\n7\n\x04\x04\x0f\x02\
\x04\x12\x04\xc3\x01\x02\x18\x1a)\x20Number\x20of\x20servers\x20to\x20st\
art\x20for\x20the\x20test\n\n\x0f\n\x05\x04\x0f\x02\x04\x04\x12\x06\xc3\
\x01\x02\xc1\x01!\n\r\n\x05\x04\x0f\x02\x04\x05\x12\x04\xc3\x01\x02\x07\
\n\r\n\x05\x04\x0f\x02\x04\x01\x12\x04\xc3\x01\x08\x13\n\r\n\x05\x04\x0f\
\x02\x04\x03\x12\x04\xc3\x01\x16\x17\n)\n\x04\x04\x0f\x02\x05\x12\x04\
\xc5\x01\x02\x1b\x1a\x1b\x20Warmup\x20period,\x20in\x20seconds\n\n\x0f\n\
\x05\x04\x0f\x02\x05\x04\x12\x06\xc5\x01\x02\xc3\x01\x18\n\r\n\x05\x04\
\x0f\x02\x05\x05\x12\x04\xc5\x01\x02\x07\n\r\n\x05\x04\x0f\x02\x05\x01\
\x12\x04\xc5\x01\x08\x16\n\r\n\x05\x04\x0f\x02\x05\x03\x12\x04\xc5\x01\
\x19\x1a\n*\n\x04\x04\x0f\x02\x06\x12\x04\xc7\x01\x02\x1e\x1a\x1c\x20Ben\
chmark\x20time,\x20in\x20seconds\n\n\x0f\n\x05\x04\x0f\x02\x06\x04\x12\
\x06\xc7\x01\x02\xc5\x01\x1b\n\r\n\x05\x04\x0f\x02\x06\x05\x12\x04\xc7\
\x01\x02\x07\n\r\n\x05\x04\x0f\x02\x06\x01\x12\x04\xc7\x01\x08\x19\n\r\n\
\x05\x04\x0f\x02\x06\x03\x12\x04\xc7\x01\x1c\x1d\nA\n\x04\x04\x0f\x02\
\x07\x12\x04\xc9\x01\x02%\x1a3\x20Number\x20of\x20workers\x20to\x20spawn\
\x20locally\x20(usually\x20zero)\n\n\x0f\n\x05\x04\x0f\x02\x07\x04\x12\
\x06\xc9\x01\x02\xc7\x01\x1e\n\r\n\x05\x04\x0f\x02\x07\x05\x12\x04\xc9\
\x01\x02\x07\n\r\n\x05\x04\x0f\x02\x07\x01\x12\x04\xc9\x01\x08\x20\n\r\n\
\x05\x04\x0f\x02\x07\x03\x12\x04\xc9\x01#$\nA\n\x02\x04\x10\x12\x06\xcd\
\x01\0\xcf\x01\x01\x1a3\x20A\x20set\x20of\x20scenarios\x20to\x20be\x20ru\
n\x20with\x20qps_json_driver\n\n\x0b\n\x03\x04\x10\x01\x12\x04\xcd\x01\
\x08\x11\n\x0c\n\x04\x04\x10\x02\0\x12\x04\xce\x01\x02\"\n\r\n\x05\x04\
\x10\x02\0\x04\x12\x04\xce\x01\x02\n\n\r\n\x05\x04\x10\x02\0\x06\x12\x04\
\xce\x01\x0b\x13\n\r\n\x05\x04\x10\x02\0\x01\x12\x04\xce\x01\x14\x1d\n\r\
\n\x05\x04\x10\x02\0\x03\x12\x04\xce\x01\x20!\nt\n\x02\x04\x11\x12\x06\
\xd3\x01\0\xf7\x01\x01\x1af\x20Basic\x20summary\x20that\x20can\x20be\x20\
computed\x20from\x20ClientStats\x20and\x20ServerStats\n\x20once\x20the\
\x20scenario\x20has\x20finished.\n\n\x0b\n\x03\x04\x11\x01\x12\x04\xd3\
\x01\x08\x1d\nG\n\x04\x04\x11\x02\0\x12\x04\xd6\x01\x02\x11\x1a9\x20Tota\
l\x20number\x20of\x20operations\x20per\x20second\x20over\x20all\x20clien\
ts.\n\n\x0f\n\x05\x04\x11\x02\0\x04\x12\x06\xd6\x01\x02\xd4\x01\x01\n\r\
\n\x05\x04\x11\x02\0\x05\x12\x04\xd6\x01\x02\x08\n\r\n\x05\x04\x11\x02\0\
\x01\x12\x04\xd6\x01\t\x0c\n\r\n\x05\x04\x11\x02\0\x03\x12\x04\xd6\x01\
\x0f\x10\n(\n\x04\x04\x11\x02\x01\x12\x04\xd8\x01\x02!\x1a\x1a\x20QPS\
\x20per\x20one\x20server\x20core.\n\n\x0f\n\x05\x04\x11\x02\x01\x04\x12\
\x06\xd8\x01\x02\xd6\x01\x11\n\r\n\x05\x04\x11\x02\x01\x05\x12\x04\xd8\
\x01\x02\x08\n\r\n\x05\x04\x11\x02\x01\x01\x12\x04\xd8\x01\t\x1c\n\r\n\
\x05\x04\x11\x02\x01\x03\x12\x04\xd8\x01\x1f\x20\n>\n\x04\x04\x11\x02\
\x02\x12\x04\xda\x01\x02\x20\x1a0\x20server\x20load\x20based\x20on\x20sy\
stem_time\x20(0.85\x20=>\x2085%)\n\n\x0f\n\x05\x04\x11\x02\x02\x04\x12\
\x06\xda\x01\x02\xd8\x01!\n\r\n\x05\x04\x11\x02\x02\x05\x12\x04\xda\x01\
\x02\x08\n\r\n\x05\x04\x11\x02\x02\x01\x12\x04\xda\x01\t\x1b\n\r\n\x05\
\x04\x11\x02\x02\x03\x12\x04\xda\x01\x1e\x1f\n<\n\x04\x04\x11\x02\x03\
\x12\x04\xdc\x01\x02\x1e\x1a.\x20server\x20load\x20based\x20on\x20user_t\
ime\x20(0.85\x20=>\x2085%)\n\n\x0f\n\x05\x04\x11\x02\x03\x04\x12\x06\xdc\
\x01\x02\xda\x01\x20\n\r\n\x05\x04\x11\x02\x03\x05\x12\x04\xdc\x01\x02\
\x08\n\r\n\x05\x04\x11\x02\x03\x01\x12\x04\xdc\x01\t\x19\n\r\n\x05\x04\
\x11\x02\x03\x03\x12\x04\xdc\x01\x1c\x1d\n>\n\x04\x04\x11\x02\x04\x12\
\x04\xde\x01\x02\x20\x1a0\x20client\x20load\x20based\x20on\x20system_tim\
e\x20(0.85\x20=>\x2085%)\n\n\x0f\n\x05\x04\x11\x02\x04\x04\x12\x06\xde\
\x01\x02\xdc\x01\x1e\n\r\n\x05\x04\x11\x02\x04\x05\x12\x04\xde\x01\x02\
\x08\n\r\n\x05\x04\x11\x02\x04\x01\x12\x04\xde\x01\t\x1b\n\r\n\x05\x04\
\x11\x02\x04\x03\x12\x04\xde\x01\x1e\x1f\n<\n\x04\x04\x11\x02\x05\x12\
\x04\xe0\x01\x02\x1e\x1a.\x20client\x20load\x20based\x20on\x20user_time\
\x20(0.85\x20=>\x2085%)\n\n\x0f\n\x05\x04\x11\x02\x05\x04\x12\x06\xe0\
\x01\x02\xde\x01\x20\n\r\n\x05\x04\x11\x02\x05\x05\x12\x04\xe0\x01\x02\
\x08\n\r\n\x05\x04\x11\x02\x05\x01\x12\x04\xe0\x01\t\x19\n\r\n\x05\x04\
\x11\x02\x05\x03\x12\x04\xe0\x01\x1c\x1d\n7\n\x04\x04\x11\x02\x06\x12\
\x04\xe3\x01\x02\x18\x1a)\x20X%\x20latency\x20percentiles\x20(in\x20nano\
seconds)\n\n\x0f\n\x05\x04\x11\x02\x06\x04\x12\x06\xe3\x01\x02\xe0\x01\
\x1e\n\r\n\x05\x04\x11\x02\x06\x05\x12\x04\xe3\x01\x02\x08\n\r\n\x05\x04\
\x11\x02\x06\x01\x12\x04\xe3\x01\t\x13\n\r\n\x05\x04\x11\x02\x06\x03\x12\
\x04\xe3\x01\x16\x17\n\x0c\n\x04\x04\x11\x02\x07\x12\x04\xe4\x01\x02\x18\
\n\x0f\n\x05\x04\x11\x02\x07\x04\x12\x06\xe4\x01\x02\xe3\x01\x18\n\r\n\
\x05\x04\x11\x02\x07\x05\x12\x04\xe4\x01\x02\x08\n\r\n\x05\x04\x11\x02\
\x07\x01\x12\x04\xe4\x01\t\x13\n\r\n\x05\x04\x11\x02\x07\x03\x12\x04\xe4\
\x01\x16\x17\n\x0c\n\x04\x04\x11\x02\x08\x12\x04\xe5\x01\x02\x18\n\x0f\n\
\x05\x04\x11\x02\x08\x04\x12\x06\xe5\x01\x02\xe4\x01\x18\n\r\n\x05\x04\
\x11\x02\x08\x05\x12\x04\xe5\x01\x02\x08\n\r\n\x05\x04\x11\x02\x08\x01\
\x12\x04\xe5\x01\t\x13\n\r\n\x05\x04\x11\x02\x08\x03\x12\x04\xe5\x01\x16\
\x17\n\x0c\n\x04\x04\x11\x02\t\x12\x04\xe6\x01\x02\x19\n\x0f\n\x05\x04\
\x11\x02\t\x04\x12\x06\xe6\x01\x02\xe5\x01\x18\n\r\n\x05\x04\x11\x02\t\
\x05\x12\x04\xe6\x01\x02\x08\n\r\n\x05\x04\x11\x02\t\x01\x12\x04\xe6\x01\
\t\x13\n\r\n\x05\x04\x11\x02\t\x03\x12\x04\xe6\x01\x16\x18\n\x0c\n\x04\
\x04\x11\x02\n\x12\x04\xe7\x01\x02\x1a\n\x0f\n\x05\x04\x11\x02\n\x04\x12\
\x06\xe7\x01\x02\xe6\x01\x19\n\r\n\x05\x04\x11\x02\n\x05\x12\x04\xe7\x01\
\x02\x08\n\r\n\x05\x04\x11\x02\n\x01\x12\x04\xe7\x01\t\x14\n\r\n\x05\x04\
\x11\x02\n\x03\x12\x04\xe7\x01\x17\x19\n+\n\x04\x04\x11\x02\x0b\x12\x04\
\xea\x01\x02\x1f\x1a\x1d\x20server\x20cpu\x20usage\x20percentage\n\n\x0f\
\n\x05\x04\x11\x02\x0b\x04\x12\x06\xea\x01\x02\xe7\x01\x1a\n\r\n\x05\x04\
\x11\x02\x0b\x05\x12\x04\xea\x01\x02\x08\n\r\n\x05\x04\x11\x02\x0b\x01\
\x12\x04\xea\x01\t\x19\n\r\n\x05\x04\x11\x02\x0b\x03\x12\x04\xea\x01\x1c\
\x1e\n8\n\x04\x04\x11\x02\x0c\x12\x04\xed\x01\x02-\x1a*\x20Number\x20of\
\x20requests\x20that\x20succeeded/failed\n\n\x0f\n\x05\x04\x11\x02\x0c\
\x04\x12\x06\xed\x01\x02\xea\x01\x1f\n\r\n\x05\x04\x11\x02\x0c\x05\x12\
\x04\xed\x01\x02\x08\n\r\n\x05\x04\x11\x02\x0c\x01\x12\x04\xed\x01\t'\n\
\r\n\x05\x04\x11\x02\x0c\x03\x12\x04\xed\x01*,\n\x0c\n\x04\x04\x11\x02\r\
\x12\x04\xee\x01\x02)\n\x0f\n\x05\x04\x11\x02\r\x04\x12\x06\xee\x01\x02\
\xed\x01-\n\r\n\x05\x04\x11\x02\r\x05\x12\x04\xee\x01\x02\x08\n\r\n\x05\
\x04\x11\x02\r\x01\x12\x04\xee\x01\t#\n\r\n\x05\x04\x11\x02\r\x03\x12\
\x04\xee\x01&(\nJ\n\x04\x04\x11\x02\x0e\x12\x04\xf1\x01\x02'\x1a<\x20Num\
ber\x20of\x20polls\x20called\x20inside\x20completion\x20queue\x20per\x20\
request\n\n\x0f\n\x05\x04\x11\x02\x0e\x04\x12\x06\xf1\x01\x02\xee\x01)\n\
\r\n\x05\x04\x11\x02\x0e\x05\x12\x04\xf1\x01\x02\x08\n\r\n\x05\x04\x11\
\x02\x0e\x01\x12\x04\xf1\x01\t!\n\r\n\x05\x04\x11\x02\x0e\x03\x12\x04\
\xf1\x01$&\n\x0c\n\x04\x04\x11\x02\x0f\x12\x04\xf2\x01\x02'\n\x0f\n\x05\
\x04\x11\x02\x0f\x04\x12\x06\xf2\x01\x02\xf1\x01'\n\r\n\x05\x04\x11\x02\
\x0f\x05\x12\x04\xf2\x01\x02\x08\n\r\n\x05\x04\x11\x02\x0f\x01\x12\x04\
\xf2\x01\t!\n\r\n\x05\x04\x11\x02\x0f\x03\x12\x04\xf2\x01$&\n?\n\x04\x04\
\x11\x02\x10\x12\x04\xf5\x01\x02)\x1a1\x20Queries\x20per\x20CPU-sec\x20o\
ver\x20all\x20servers\x20or\x20clients\n\n\x0f\n\x05\x04\x11\x02\x10\x04\
\x12\x06\xf5\x01\x02\xf2\x01'\n\r\n\x05\x04\x11\x02\x10\x05\x12\x04\xf5\
\x01\x02\x08\n\r\n\x05\x04\x11\x02\x10\x01\x12\x04\xf5\x01\t#\n\r\n\x05\
\x04\x11\x02\x10\x03\x12\x04\xf5\x01&(\n\x0c\n\x04\x04\x11\x02\x11\x12\
\x04\xf6\x01\x02)\n\x0f\n\x05\x04\x11\x02\x11\x04\x12\x06\xf6\x01\x02\
\xf5\x01)\n\r\n\x05\x04\x11\x02\x11\x05\x12\x04\xf6\x01\x02\x08\n\r\n\
\x05\x04\x11\x02\x11\x01\x12\x04\xf6\x01\t#\n\r\n\x05\x04\x11\x02\x11\
\x03\x12\x04\xf6\x01&(\n7\n\x02\x04\x12\x12\x06\xfa\x01\0\x8c\x02\x01\
\x1a)\x20Results\x20of\x20a\x20single\x20benchmark\x20scenario.\n\n\x0b\
\n\x03\x04\x12\x01\x12\x04\xfa\x01\x08\x16\n0\n\x04\x04\x12\x02\0\x12\
\x04\xfc\x01\x02\x18\x1a\"\x20Inputs\x20used\x20to\x20run\x20the\x20scen\
ario.\n\n\x0f\n\x05\x04\x12\x02\0\x04\x12\x06\xfc\x01\x02\xfa\x01\x18\n\
\r\n\x05\x04\x12\x02\0\x06\x12\x04\xfc\x01\x02\n\n\r\n\x05\x04\x12\x02\0\
\x01\x12\x04\xfc\x01\x0b\x13\n\r\n\x05\x04\x12\x02\0\x03\x12\x04\xfc\x01\
\x16\x17\nF\n\x04\x04\x12\x02\x01\x12\x04\xfe\x01\x02\x1e\x1a8\x20Histog\
rams\x20from\x20all\x20clients\x20merged\x20into\x20one\x20histogram.\n\
\n\x0f\n\x05\x04\x12\x02\x01\x04\x12\x06\xfe\x01\x02\xfc\x01\x18\n\r\n\
\x05\x04\x12\x02\x01\x06\x12\x04\xfe\x01\x02\x0f\n\r\n\x05\x04\x12\x02\
\x01\x01\x12\x04\xfe\x01\x10\x19\n\r\n\x05\x04\x12\x02\x01\x03\x12\x04\
\xfe\x01\x1c\x1d\n,\n\x04\x04\x12\x02\x02\x12\x04\x80\x02\x02(\x1a\x1e\
\x20Client\x20stats\x20for\x20each\x20client\n\n\r\n\x05\x04\x12\x02\x02\
\x04\x12\x04\x80\x02\x02\n\n\r\n\x05\x04\x12\x02\x02\x06\x12\x04\x80\x02\
\x0b\x16\n\r\n\x05\x04\x12\x02\x02\x01\x12\x04\x80\x02\x17#\n\r\n\x05\
\x04\x12\x02\x02\x03\x12\x04\x80\x02&'\n,\n\x04\x04\x12\x02\x03\x12\x04\
\x82\x02\x02(\x1a\x1e\x20Server\x20stats\x20for\x20each\x20server\n\n\r\
\n\x05\x04\x12\x02\x03\x04\x12\x04\x82\x02\x02\n\n\r\n\x05\x04\x12\x02\
\x03\x06\x12\x04\x82\x02\x0b\x16\n\r\n\x05\x04\x12\x02\x03\x01\x12\x04\
\x82\x02\x17#\n\r\n\x05\x04\x12\x02\x03\x03\x12\x04\x82\x02&'\n8\n\x04\
\x04\x12\x02\x04\x12\x04\x84\x02\x02\"\x1a*\x20Number\x20of\x20cores\x20\
available\x20to\x20each\x20server\n\n\r\n\x05\x04\x12\x02\x04\x04\x12\
\x04\x84\x02\x02\n\n\r\n\x05\x04\x12\x02\x04\x05\x12\x04\x84\x02\x0b\x10\
\n\r\n\x05\x04\x12\x02\x04\x01\x12\x04\x84\x02\x11\x1d\n\r\n\x05\x04\x12\
\x02\x04\x03\x12\x04\x84\x02\x20!\n2\n\x04\x04\x12\x02\x05\x12\x04\x86\
\x02\x02$\x1a$\x20An\x20after-the-fact\x20computed\x20summary\n\n\x0f\n\
\x05\x04\x12\x02\x05\x04\x12\x06\x86\x02\x02\x84\x02\"\n\r\n\x05\x04\x12\
\x02\x05\x06\x12\x04\x86\x02\x02\x17\n\r\n\x05\x04\x12\x02\x05\x01\x12\
\x04\x86\x02\x18\x1f\n\r\n\x05\x04\x12\x02\x05\x03\x12\x04\x86\x02\"#\n@\
\n\x04\x04\x12\x02\x06\x12\x04\x88\x02\x02#\x1a2\x20Information\x20on\
\x20success\x20or\x20failure\x20of\x20each\x20worker\n\n\r\n\x05\x04\x12\
\x02\x06\x04\x12\x04\x88\x02\x02\n\n\r\n\x05\x04\x12\x02\x06\x05\x12\x04\
\x88\x02\x0b\x0f\n\r\n\x05\x04\x12\x02\x06\x01\x12\x04\x88\x02\x10\x1e\n\
\r\n\x05\x04\x12\x02\x06\x03\x12\x04\x88\x02!\"\n\x0c\n\x04\x04\x12\x02\
\x07\x12\x04\x89\x02\x02#\n\r\n\x05\x04\x12\x02\x07\x04\x12\x04\x89\x02\
\x02\n\n\r\n\x05\x04\x12\x02\x07\x05\x12\x04\x89\x02\x0b\x0f\n\r\n\x05\
\x04\x12\x02\x07\x01\x12\x04\x89\x02\x10\x1e\n\r\n\x05\x04\x12\x02\x07\
\x03\x12\x04\x89\x02!\"\nH\n\x04\x04\x12\x02\x08\x12\x04\x8b\x02\x022\
\x1a:\x20Number\x20of\x20failed\x20requests\x20(one\x20row\x20per\x20sta\
tus\x20code\x20seen)\n\n\r\n\x05\x04\x12\x02\x08\x04\x12\x04\x8b\x02\x02\
\n\n\r\n\x05\x04\x12\x02\x08\x06\x12\x04\x8b\x02\x0b\x1d\n\r\n\x05\x04\
\x12\x02\x08\x01\x12\x04\x8b\x02\x1e-\n\r\n\x05\x04\x12\x02\x08\x03\x12\
\x04\x8b\x0201b\x06proto3\
";
static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
unsafe {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}
}