#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_results)]
#![allow(unused_mut)]
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_2_0;
#[derive(PartialEq,Clone,Default,Debug)]
pub struct AllocateShard {
pub shard_id: u32,
pub rebalancing: bool,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a AllocateShard {
fn default() -> &'a AllocateShard {
<AllocateShard as ::protobuf::Message>::default_instance()
}
}
impl AllocateShard {
pub fn new() -> AllocateShard {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(2);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"shard_id",
|m: &AllocateShard| { &m.shard_id },
|m: &mut AllocateShard| { &mut m.shard_id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"rebalancing",
|m: &AllocateShard| { &m.rebalancing },
|m: &mut AllocateShard| { &mut m.rebalancing },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<AllocateShard>(
"AllocateShard",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for AllocateShard {
const NAME: &'static str = "AllocateShard";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.shard_id = is.read_uint32()?;
},
16 => {
self.rebalancing = is.read_bool()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if self.shard_id != 0 {
my_size += ::protobuf::rt::uint32_size(1, self.shard_id);
}
if self.rebalancing != false {
my_size += 1 + 1;
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if self.shard_id != 0 {
os.write_uint32(1, self.shard_id)?;
}
if self.rebalancing != false {
os.write_bool(2, self.rebalancing)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> AllocateShard {
AllocateShard::new()
}
fn clear(&mut self) {
self.shard_id = 0;
self.rebalancing = false;
self.special_fields.clear();
}
fn default_instance() -> &'static AllocateShard {
static instance: AllocateShard = AllocateShard {
shard_id: 0,
rebalancing: false,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for AllocateShard {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("AllocateShard").unwrap()).clone()
}
}
impl ::std::fmt::Display for AllocateShard {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for AllocateShard {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct RemoteShard {
pub shard_id: u32,
pub node_id: u64,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a RemoteShard {
fn default() -> &'a RemoteShard {
<RemoteShard as ::protobuf::Message>::default_instance()
}
}
impl RemoteShard {
pub fn new() -> RemoteShard {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(2);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"shard_id",
|m: &RemoteShard| { &m.shard_id },
|m: &mut RemoteShard| { &mut m.shard_id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"node_id",
|m: &RemoteShard| { &m.node_id },
|m: &mut RemoteShard| { &mut m.node_id },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RemoteShard>(
"RemoteShard",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for RemoteShard {
const NAME: &'static str = "RemoteShard";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.shard_id = is.read_uint32()?;
},
16 => {
self.node_id = is.read_uint64()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if self.shard_id != 0 {
my_size += ::protobuf::rt::uint32_size(1, self.shard_id);
}
if self.node_id != 0 {
my_size += ::protobuf::rt::uint64_size(2, self.node_id);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if self.shard_id != 0 {
os.write_uint32(1, self.shard_id)?;
}
if self.node_id != 0 {
os.write_uint64(2, self.node_id)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> RemoteShard {
RemoteShard::new()
}
fn clear(&mut self) {
self.shard_id = 0;
self.node_id = 0;
self.special_fields.clear();
}
fn default_instance() -> &'static RemoteShard {
static instance: RemoteShard = RemoteShard {
shard_id: 0,
node_id: 0,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for RemoteShard {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("RemoteShard").unwrap()).clone()
}
}
impl ::std::fmt::Display for RemoteShard {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for RemoteShard {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ShardAllocated {
pub shard: ::protobuf::MessageField<RemoteShard>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a ShardAllocated {
fn default() -> &'a ShardAllocated {
<ShardAllocated as ::protobuf::Message>::default_instance()
}
}
impl ShardAllocated {
pub fn new() -> ShardAllocated {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(1);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, RemoteShard>(
"shard",
|m: &ShardAllocated| { &m.shard },
|m: &mut ShardAllocated| { &mut m.shard },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ShardAllocated>(
"ShardAllocated",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for ShardAllocated {
const NAME: &'static str = "ShardAllocated";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
::protobuf::rt::read_singular_message_into_field(is, &mut self.shard)?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if let Some(v) = self.shard.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if let Some(v) = self.shard.as_ref() {
::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> ShardAllocated {
ShardAllocated::new()
}
fn clear(&mut self) {
self.shard.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static ShardAllocated {
static instance: ShardAllocated = ShardAllocated {
shard: ::protobuf::MessageField::none(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for ShardAllocated {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("ShardAllocated").unwrap()).clone()
}
}
impl ::std::fmt::Display for ShardAllocated {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ShardAllocated {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ShardReallocating {
pub shard_id: u32,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a ShardReallocating {
fn default() -> &'a ShardReallocating {
<ShardReallocating as ::protobuf::Message>::default_instance()
}
}
impl ShardReallocating {
pub fn new() -> ShardReallocating {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(1);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"shard_id",
|m: &ShardReallocating| { &m.shard_id },
|m: &mut ShardReallocating| { &mut m.shard_id },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ShardReallocating>(
"ShardReallocating",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for ShardReallocating {
const NAME: &'static str = "ShardReallocating";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.shard_id = is.read_uint32()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if self.shard_id != 0 {
my_size += ::protobuf::rt::uint32_size(1, self.shard_id);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if self.shard_id != 0 {
os.write_uint32(1, self.shard_id)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> ShardReallocating {
ShardReallocating::new()
}
fn clear(&mut self) {
self.shard_id = 0;
self.special_fields.clear();
}
fn default_instance() -> &'static ShardReallocating {
static instance: ShardReallocating = ShardReallocating {
shard_id: 0,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for ShardReallocating {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("ShardReallocating").unwrap()).clone()
}
}
impl ::std::fmt::Display for ShardReallocating {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ShardReallocating {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct StopShard {
pub shard_id: u32,
pub origin_node_id: u64,
pub request_id: ::std::string::String,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a StopShard {
fn default() -> &'a StopShard {
<StopShard as ::protobuf::Message>::default_instance()
}
}
impl StopShard {
pub fn new() -> StopShard {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"shard_id",
|m: &StopShard| { &m.shard_id },
|m: &mut StopShard| { &mut m.shard_id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"origin_node_id",
|m: &StopShard| { &m.origin_node_id },
|m: &mut StopShard| { &mut m.origin_node_id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"request_id",
|m: &StopShard| { &m.request_id },
|m: &mut StopShard| { &mut m.request_id },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<StopShard>(
"StopShard",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for StopShard {
const NAME: &'static str = "StopShard";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.shard_id = is.read_uint32()?;
},
16 => {
self.origin_node_id = is.read_uint64()?;
},
26 => {
self.request_id = is.read_string()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if self.shard_id != 0 {
my_size += ::protobuf::rt::uint32_size(1, self.shard_id);
}
if self.origin_node_id != 0 {
my_size += ::protobuf::rt::uint64_size(2, self.origin_node_id);
}
if !self.request_id.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.request_id);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if self.shard_id != 0 {
os.write_uint32(1, self.shard_id)?;
}
if self.origin_node_id != 0 {
os.write_uint64(2, self.origin_node_id)?;
}
if !self.request_id.is_empty() {
os.write_string(3, &self.request_id)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> StopShard {
StopShard::new()
}
fn clear(&mut self) {
self.shard_id = 0;
self.origin_node_id = 0;
self.request_id.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static StopShard {
static instance: StopShard = StopShard {
shard_id: 0,
origin_node_id: 0,
request_id: ::std::string::String::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for StopShard {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("StopShard").unwrap()).clone()
}
}
impl ::std::fmt::Display for StopShard {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for StopShard {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ShardStopped {
pub shard_id: u32,
pub origin_node_id: u64,
pub is_successful: bool,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a ShardStopped {
fn default() -> &'a ShardStopped {
<ShardStopped as ::protobuf::Message>::default_instance()
}
}
impl ShardStopped {
pub fn new() -> ShardStopped {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"shard_id",
|m: &ShardStopped| { &m.shard_id },
|m: &mut ShardStopped| { &mut m.shard_id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"origin_node_id",
|m: &ShardStopped| { &m.origin_node_id },
|m: &mut ShardStopped| { &mut m.origin_node_id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"is_successful",
|m: &ShardStopped| { &m.is_successful },
|m: &mut ShardStopped| { &mut m.is_successful },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ShardStopped>(
"ShardStopped",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for ShardStopped {
const NAME: &'static str = "ShardStopped";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.shard_id = is.read_uint32()?;
},
16 => {
self.origin_node_id = is.read_uint64()?;
},
24 => {
self.is_successful = is.read_bool()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if self.shard_id != 0 {
my_size += ::protobuf::rt::uint32_size(1, self.shard_id);
}
if self.origin_node_id != 0 {
my_size += ::protobuf::rt::uint64_size(2, self.origin_node_id);
}
if self.is_successful != false {
my_size += 1 + 1;
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if self.shard_id != 0 {
os.write_uint32(1, self.shard_id)?;
}
if self.origin_node_id != 0 {
os.write_uint64(2, self.origin_node_id)?;
}
if self.is_successful != false {
os.write_bool(3, self.is_successful)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> ShardStopped {
ShardStopped::new()
}
fn clear(&mut self) {
self.shard_id = 0;
self.origin_node_id = 0;
self.is_successful = false;
self.special_fields.clear();
}
fn default_instance() -> &'static ShardStopped {
static instance: ShardStopped = ShardStopped {
shard_id: 0,
origin_node_id: 0,
is_successful: false,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for ShardStopped {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("ShardStopped").unwrap()).clone()
}
}
impl ::std::fmt::Display for ShardStopped {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ShardStopped {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct AllocateShardResult {
pub result_type: ::protobuf::EnumOrUnknown<allocate_shard_result::Type>,
pub allocation: ::protobuf::MessageField<RemoteShard>,
pub err: ::protobuf::EnumOrUnknown<allocate_shard_result::AllocateShardErr>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a AllocateShardResult {
fn default() -> &'a AllocateShardResult {
<AllocateShardResult as ::protobuf::Message>::default_instance()
}
}
impl AllocateShardResult {
pub fn new() -> AllocateShardResult {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"result_type",
|m: &AllocateShardResult| { &m.result_type },
|m: &mut AllocateShardResult| { &mut m.result_type },
));
fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, RemoteShard>(
"allocation",
|m: &AllocateShardResult| { &m.allocation },
|m: &mut AllocateShardResult| { &mut m.allocation },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"err",
|m: &AllocateShardResult| { &m.err },
|m: &mut AllocateShardResult| { &mut m.err },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<AllocateShardResult>(
"AllocateShardResult",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for AllocateShardResult {
const NAME: &'static str = "AllocateShardResult";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.result_type = is.read_enum_or_unknown()?;
},
18 => {
::protobuf::rt::read_singular_message_into_field(is, &mut self.allocation)?;
},
24 => {
self.err = is.read_enum_or_unknown()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if self.result_type != ::protobuf::EnumOrUnknown::new(allocate_shard_result::Type::ALLOCATED) {
my_size += ::protobuf::rt::int32_size(1, self.result_type.value());
}
if let Some(v) = self.allocation.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
}
if self.err != ::protobuf::EnumOrUnknown::new(allocate_shard_result::AllocateShardErr::UNKNOWN) {
my_size += ::protobuf::rt::int32_size(3, self.err.value());
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if self.result_type != ::protobuf::EnumOrUnknown::new(allocate_shard_result::Type::ALLOCATED) {
os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.result_type))?;
}
if let Some(v) = self.allocation.as_ref() {
::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
}
if self.err != ::protobuf::EnumOrUnknown::new(allocate_shard_result::AllocateShardErr::UNKNOWN) {
os.write_enum(3, ::protobuf::EnumOrUnknown::value(&self.err))?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> AllocateShardResult {
AllocateShardResult::new()
}
fn clear(&mut self) {
self.result_type = ::protobuf::EnumOrUnknown::new(allocate_shard_result::Type::ALLOCATED);
self.allocation.clear();
self.err = ::protobuf::EnumOrUnknown::new(allocate_shard_result::AllocateShardErr::UNKNOWN);
self.special_fields.clear();
}
fn default_instance() -> &'static AllocateShardResult {
static instance: AllocateShardResult = AllocateShardResult {
result_type: ::protobuf::EnumOrUnknown::from_i32(0),
allocation: ::protobuf::MessageField::none(),
err: ::protobuf::EnumOrUnknown::from_i32(0),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for AllocateShardResult {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("AllocateShardResult").unwrap()).clone()
}
}
impl ::std::fmt::Display for AllocateShardResult {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for AllocateShardResult {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
pub mod allocate_shard_result {
#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
pub enum Type {
ALLOCATED = 0,
ALREADY_ALLOCATED = 1,
NOT_ALLOCATED = 2,
ERR = 3,
}
impl ::protobuf::Enum for Type {
const NAME: &'static str = "Type";
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<Type> {
match value {
0 => ::std::option::Option::Some(Type::ALLOCATED),
1 => ::std::option::Option::Some(Type::ALREADY_ALLOCATED),
2 => ::std::option::Option::Some(Type::NOT_ALLOCATED),
3 => ::std::option::Option::Some(Type::ERR),
_ => ::std::option::Option::None
}
}
const VALUES: &'static [Type] = &[
Type::ALLOCATED,
Type::ALREADY_ALLOCATED,
Type::NOT_ALLOCATED,
Type::ERR,
];
}
impl ::protobuf::EnumFull for Type {
fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("AllocateShardResult.Type").unwrap()).clone()
}
fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
let index = *self as usize;
Self::enum_descriptor().value_by_index(index)
}
}
impl ::std::default::Default for Type {
fn default() -> Self {
Type::ALLOCATED
}
}
impl Type {
pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
::protobuf::reflect::GeneratedEnumDescriptorData::new::<Type>("AllocateShardResult.Type")
}
}
#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
pub enum AllocateShardErr {
UNKNOWN = 0,
PERSISTENCE = 1,
}
impl ::protobuf::Enum for AllocateShardErr {
const NAME: &'static str = "AllocateShardErr";
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<AllocateShardErr> {
match value {
0 => ::std::option::Option::Some(AllocateShardErr::UNKNOWN),
1 => ::std::option::Option::Some(AllocateShardErr::PERSISTENCE),
_ => ::std::option::Option::None
}
}
const VALUES: &'static [AllocateShardErr] = &[
AllocateShardErr::UNKNOWN,
AllocateShardErr::PERSISTENCE,
];
}
impl ::protobuf::EnumFull for AllocateShardErr {
fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("AllocateShardResult.AllocateShardErr").unwrap()).clone()
}
fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
let index = *self as usize;
Self::enum_descriptor().value_by_index(index)
}
}
impl ::std::default::Default for AllocateShardErr {
fn default() -> Self {
AllocateShardErr::UNKNOWN
}
}
impl AllocateShardErr {
pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
::protobuf::reflect::GeneratedEnumDescriptorData::new::<AllocateShardErr>("AllocateShardResult.AllocateShardErr")
}
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct RemoteEntityRequest {
pub request_id: ::std::string::String,
pub actor_id: ::std::string::String,
pub message_type: ::std::string::String,
pub message: ::std::vec::Vec<u8>,
pub recipe: ::protobuf::MessageField<remote_entity_request::Recipe>,
pub origin_node: u64,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a RemoteEntityRequest {
fn default() -> &'a RemoteEntityRequest {
<RemoteEntityRequest as ::protobuf::Message>::default_instance()
}
}
impl RemoteEntityRequest {
pub fn new() -> RemoteEntityRequest {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(6);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"request_id",
|m: &RemoteEntityRequest| { &m.request_id },
|m: &mut RemoteEntityRequest| { &mut m.request_id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"actor_id",
|m: &RemoteEntityRequest| { &m.actor_id },
|m: &mut RemoteEntityRequest| { &mut m.actor_id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"message_type",
|m: &RemoteEntityRequest| { &m.message_type },
|m: &mut RemoteEntityRequest| { &mut m.message_type },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"message",
|m: &RemoteEntityRequest| { &m.message },
|m: &mut RemoteEntityRequest| { &mut m.message },
));
fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, remote_entity_request::Recipe>(
"recipe",
|m: &RemoteEntityRequest| { &m.recipe },
|m: &mut RemoteEntityRequest| { &mut m.recipe },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"origin_node",
|m: &RemoteEntityRequest| { &m.origin_node },
|m: &mut RemoteEntityRequest| { &mut m.origin_node },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RemoteEntityRequest>(
"RemoteEntityRequest",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for RemoteEntityRequest {
const NAME: &'static str = "RemoteEntityRequest";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.request_id = is.read_string()?;
},
18 => {
self.actor_id = is.read_string()?;
},
26 => {
self.message_type = is.read_string()?;
},
34 => {
self.message = is.read_bytes()?;
},
42 => {
::protobuf::rt::read_singular_message_into_field(is, &mut self.recipe)?;
},
48 => {
self.origin_node = is.read_uint64()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.request_id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.request_id);
}
if !self.actor_id.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.actor_id);
}
if !self.message_type.is_empty() {
my_size += ::protobuf::rt::string_size(3, &self.message_type);
}
if !self.message.is_empty() {
my_size += ::protobuf::rt::bytes_size(4, &self.message);
}
if let Some(v) = self.recipe.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
}
if self.origin_node != 0 {
my_size += ::protobuf::rt::uint64_size(6, self.origin_node);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.request_id.is_empty() {
os.write_string(1, &self.request_id)?;
}
if !self.actor_id.is_empty() {
os.write_string(2, &self.actor_id)?;
}
if !self.message_type.is_empty() {
os.write_string(3, &self.message_type)?;
}
if !self.message.is_empty() {
os.write_bytes(4, &self.message)?;
}
if let Some(v) = self.recipe.as_ref() {
::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
}
if self.origin_node != 0 {
os.write_uint64(6, self.origin_node)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> RemoteEntityRequest {
RemoteEntityRequest::new()
}
fn clear(&mut self) {
self.request_id.clear();
self.actor_id.clear();
self.message_type.clear();
self.message.clear();
self.recipe.clear();
self.origin_node = 0;
self.special_fields.clear();
}
fn default_instance() -> &'static RemoteEntityRequest {
static instance: RemoteEntityRequest = RemoteEntityRequest {
request_id: ::std::string::String::new(),
actor_id: ::std::string::String::new(),
message_type: ::std::string::String::new(),
message: ::std::vec::Vec::new(),
recipe: ::protobuf::MessageField::none(),
origin_node: 0,
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for RemoteEntityRequest {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("RemoteEntityRequest").unwrap()).clone()
}
}
impl ::std::fmt::Display for RemoteEntityRequest {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for RemoteEntityRequest {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
pub mod remote_entity_request {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Recipe {
pub recipe: ::std::vec::Vec<u8>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Recipe {
fn default() -> &'a Recipe {
<Recipe as ::protobuf::Message>::default_instance()
}
}
impl Recipe {
pub fn new() -> Recipe {
::std::default::Default::default()
}
pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(1);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"recipe",
|m: &Recipe| { &m.recipe },
|m: &mut Recipe| { &mut m.recipe },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Recipe>(
"RemoteEntityRequest.Recipe",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for Recipe {
const NAME: &'static str = "Recipe";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.recipe = is.read_bytes()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.recipe.is_empty() {
my_size += ::protobuf::rt::bytes_size(1, &self.recipe);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.recipe.is_empty() {
os.write_bytes(1, &self.recipe)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> Recipe {
Recipe::new()
}
fn clear(&mut self) {
self.recipe.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static Recipe {
static instance: Recipe = Recipe {
recipe: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for Recipe {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| super::file_descriptor().message_by_package_relative_name("RemoteEntityRequest.Recipe").unwrap()).clone()
}
}
impl ::std::fmt::Display for Recipe {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Recipe {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct StartEntity {
pub actor_id: ::std::string::String,
pub recipe: ::std::vec::Vec<u8>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a StartEntity {
fn default() -> &'a StartEntity {
<StartEntity as ::protobuf::Message>::default_instance()
}
}
impl StartEntity {
pub fn new() -> StartEntity {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(2);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"actor_id",
|m: &StartEntity| { &m.actor_id },
|m: &mut StartEntity| { &mut m.actor_id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"recipe",
|m: &StartEntity| { &m.recipe },
|m: &mut StartEntity| { &mut m.recipe },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<StartEntity>(
"StartEntity",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for StartEntity {
const NAME: &'static str = "StartEntity";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.actor_id = is.read_string()?;
},
18 => {
self.recipe = is.read_bytes()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.actor_id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.actor_id);
}
if !self.recipe.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.recipe);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.actor_id.is_empty() {
os.write_string(1, &self.actor_id)?;
}
if !self.recipe.is_empty() {
os.write_bytes(2, &self.recipe)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> StartEntity {
StartEntity::new()
}
fn clear(&mut self) {
self.actor_id.clear();
self.recipe.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static StartEntity {
static instance: StartEntity = StartEntity {
actor_id: ::std::string::String::new(),
recipe: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for StartEntity {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("StartEntity").unwrap()).clone()
}
}
impl ::std::fmt::Display for StartEntity {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for StartEntity {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PassivateEntity {
pub actor_id: ::std::string::String,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a PassivateEntity {
fn default() -> &'a PassivateEntity {
<PassivateEntity as ::protobuf::Message>::default_instance()
}
}
impl PassivateEntity {
pub fn new() -> PassivateEntity {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(1);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"actor_id",
|m: &PassivateEntity| { &m.actor_id },
|m: &mut PassivateEntity| { &mut m.actor_id },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PassivateEntity>(
"PassivateEntity",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for PassivateEntity {
const NAME: &'static str = "PassivateEntity";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.actor_id = is.read_string()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.actor_id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.actor_id);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.actor_id.is_empty() {
os.write_string(1, &self.actor_id)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> PassivateEntity {
PassivateEntity::new()
}
fn clear(&mut self) {
self.actor_id.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static PassivateEntity {
static instance: PassivateEntity = PassivateEntity {
actor_id: ::std::string::String::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for PassivateEntity {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("PassivateEntity").unwrap()).clone()
}
}
impl ::std::fmt::Display for PassivateEntity {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for PassivateEntity {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct RemoveEntity {
pub actor_id: ::std::string::String,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a RemoveEntity {
fn default() -> &'a RemoveEntity {
<RemoveEntity as ::protobuf::Message>::default_instance()
}
}
impl RemoveEntity {
pub fn new() -> RemoveEntity {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(1);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"actor_id",
|m: &RemoveEntity| { &m.actor_id },
|m: &mut RemoveEntity| { &mut m.actor_id },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RemoveEntity>(
"RemoveEntity",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for RemoveEntity {
const NAME: &'static str = "RemoveEntity";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.actor_id = is.read_string()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.actor_id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.actor_id);
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.actor_id.is_empty() {
os.write_string(1, &self.actor_id)?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> RemoveEntity {
RemoveEntity::new()
}
fn clear(&mut self) {
self.actor_id.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static RemoveEntity {
static instance: RemoveEntity = RemoveEntity {
actor_id: ::std::string::String::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for RemoveEntity {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("RemoveEntity").unwrap()).clone()
}
}
impl ::std::fmt::Display for RemoveEntity {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for RemoveEntity {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ShardStateSnapshot {
pub shard_id: u32,
pub node_id: u64,
pub entities: ::std::vec::Vec<shard_state_snapshot::Entity>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a ShardStateSnapshot {
fn default() -> &'a ShardStateSnapshot {
<ShardStateSnapshot as ::protobuf::Message>::default_instance()
}
}
impl ShardStateSnapshot {
pub fn new() -> ShardStateSnapshot {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"shard_id",
|m: &ShardStateSnapshot| { &m.shard_id },
|m: &mut ShardStateSnapshot| { &mut m.shard_id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"node_id",
|m: &ShardStateSnapshot| { &m.node_id },
|m: &mut ShardStateSnapshot| { &mut m.node_id },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"entities",
|m: &ShardStateSnapshot| { &m.entities },
|m: &mut ShardStateSnapshot| { &mut m.entities },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ShardStateSnapshot>(
"ShardStateSnapshot",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for ShardStateSnapshot {
const NAME: &'static str = "ShardStateSnapshot";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.shard_id = is.read_uint32()?;
},
16 => {
self.node_id = is.read_uint64()?;
},
26 => {
self.entities.push(is.read_message()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if self.shard_id != 0 {
my_size += ::protobuf::rt::uint32_size(1, self.shard_id);
}
if self.node_id != 0 {
my_size += ::protobuf::rt::uint64_size(2, self.node_id);
}
for value in &self.entities {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if self.shard_id != 0 {
os.write_uint32(1, self.shard_id)?;
}
if self.node_id != 0 {
os.write_uint64(2, self.node_id)?;
}
for v in &self.entities {
::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
};
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> ShardStateSnapshot {
ShardStateSnapshot::new()
}
fn clear(&mut self) {
self.shard_id = 0;
self.node_id = 0;
self.entities.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static ShardStateSnapshot {
static instance: ShardStateSnapshot = ShardStateSnapshot {
shard_id: 0,
node_id: 0,
entities: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for ShardStateSnapshot {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("ShardStateSnapshot").unwrap()).clone()
}
}
impl ::std::fmt::Display for ShardStateSnapshot {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ShardStateSnapshot {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
pub mod shard_state_snapshot {
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Entity {
pub actor_id: ::std::string::String,
pub recipe: ::std::vec::Vec<u8>,
pub state: ::protobuf::EnumOrUnknown<super::EntityState>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Entity {
fn default() -> &'a Entity {
<Entity as ::protobuf::Message>::default_instance()
}
}
impl Entity {
pub fn new() -> Entity {
::std::default::Default::default()
}
pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"actor_id",
|m: &Entity| { &m.actor_id },
|m: &mut Entity| { &mut m.actor_id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"recipe",
|m: &Entity| { &m.recipe },
|m: &mut Entity| { &mut m.recipe },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"state",
|m: &Entity| { &m.state },
|m: &mut Entity| { &mut m.state },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Entity>(
"ShardStateSnapshot.Entity",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for Entity {
const NAME: &'static str = "Entity";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.actor_id = is.read_string()?;
},
18 => {
self.recipe = is.read_bytes()?;
},
24 => {
self.state = is.read_enum_or_unknown()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.actor_id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.actor_id);
}
if !self.recipe.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.recipe);
}
if self.state != ::protobuf::EnumOrUnknown::new(super::EntityState::IDLE) {
my_size += ::protobuf::rt::int32_size(3, self.state.value());
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.actor_id.is_empty() {
os.write_string(1, &self.actor_id)?;
}
if !self.recipe.is_empty() {
os.write_bytes(2, &self.recipe)?;
}
if self.state != ::protobuf::EnumOrUnknown::new(super::EntityState::IDLE) {
os.write_enum(3, ::protobuf::EnumOrUnknown::value(&self.state))?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> Entity {
Entity::new()
}
fn clear(&mut self) {
self.actor_id.clear();
self.recipe.clear();
self.state = ::protobuf::EnumOrUnknown::new(super::EntityState::IDLE);
self.special_fields.clear();
}
fn default_instance() -> &'static Entity {
static instance: Entity = Entity {
actor_id: ::std::string::String::new(),
recipe: ::std::vec::Vec::new(),
state: ::protobuf::EnumOrUnknown::from_i32(0),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for Entity {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| super::file_descriptor().message_by_package_relative_name("ShardStateSnapshot.Entity").unwrap()).clone()
}
}
impl ::std::fmt::Display for Entity {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Entity {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GetShardingStats {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a GetShardingStats {
fn default() -> &'a GetShardingStats {
<GetShardingStats as ::protobuf::Message>::default_instance()
}
}
impl GetShardingStats {
pub fn new() -> GetShardingStats {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(0);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetShardingStats>(
"GetShardingStats",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for GetShardingStats {
const NAME: &'static str = "GetShardingStats";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> GetShardingStats {
GetShardingStats::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static GetShardingStats {
static instance: GetShardingStats = GetShardingStats {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for GetShardingStats {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("GetShardingStats").unwrap()).clone()
}
}
impl ::std::fmt::Display for GetShardingStats {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for GetShardingStats {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct NodeStats {
pub node_id: u64,
pub shard_count: u64,
pub status: ::protobuf::EnumOrUnknown<ShardHostStatus>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a NodeStats {
fn default() -> &'a NodeStats {
<NodeStats as ::protobuf::Message>::default_instance()
}
}
impl NodeStats {
pub fn new() -> NodeStats {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"node_id",
|m: &NodeStats| { &m.node_id },
|m: &mut NodeStats| { &mut m.node_id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"shard_count",
|m: &NodeStats| { &m.shard_count },
|m: &mut NodeStats| { &mut m.shard_count },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"status",
|m: &NodeStats| { &m.status },
|m: &mut NodeStats| { &mut m.status },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<NodeStats>(
"NodeStats",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for NodeStats {
const NAME: &'static str = "NodeStats";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.node_id = is.read_uint64()?;
},
16 => {
self.shard_count = is.read_uint64()?;
},
24 => {
self.status = is.read_enum_or_unknown()?;
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if self.node_id != 0 {
my_size += ::protobuf::rt::uint64_size(1, self.node_id);
}
if self.shard_count != 0 {
my_size += ::protobuf::rt::uint64_size(2, self.shard_count);
}
if self.status != ::protobuf::EnumOrUnknown::new(ShardHostStatus::UNKNOWN) {
my_size += ::protobuf::rt::int32_size(3, self.status.value());
}
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if self.node_id != 0 {
os.write_uint64(1, self.node_id)?;
}
if self.shard_count != 0 {
os.write_uint64(2, self.shard_count)?;
}
if self.status != ::protobuf::EnumOrUnknown::new(ShardHostStatus::UNKNOWN) {
os.write_enum(3, ::protobuf::EnumOrUnknown::value(&self.status))?;
}
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> NodeStats {
NodeStats::new()
}
fn clear(&mut self) {
self.node_id = 0;
self.shard_count = 0;
self.status = ::protobuf::EnumOrUnknown::new(ShardHostStatus::UNKNOWN);
self.special_fields.clear();
}
fn default_instance() -> &'static NodeStats {
static instance: NodeStats = NodeStats {
node_id: 0,
shard_count: 0,
status: ::protobuf::EnumOrUnknown::from_i32(0),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for NodeStats {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("NodeStats").unwrap()).clone()
}
}
impl ::std::fmt::Display for NodeStats {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for NodeStats {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ShardingStats {
pub entity_type: ::std::string::String,
pub total_shards: u64,
pub shards: ::std::vec::Vec<RemoteShard>,
pub nodes: ::std::vec::Vec<NodeStats>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a ShardingStats {
fn default() -> &'a ShardingStats {
<ShardingStats as ::protobuf::Message>::default_instance()
}
}
impl ShardingStats {
pub fn new() -> ShardingStats {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(4);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"entity_type",
|m: &ShardingStats| { &m.entity_type },
|m: &mut ShardingStats| { &mut m.entity_type },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"total_shards",
|m: &ShardingStats| { &m.total_shards },
|m: &mut ShardingStats| { &mut m.total_shards },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"shards",
|m: &ShardingStats| { &m.shards },
|m: &mut ShardingStats| { &mut m.shards },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"nodes",
|m: &ShardingStats| { &m.nodes },
|m: &mut ShardingStats| { &mut m.nodes },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ShardingStats>(
"ShardingStats",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for ShardingStats {
const NAME: &'static str = "ShardingStats";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
10 => {
self.entity_type = is.read_string()?;
},
16 => {
self.total_shards = is.read_uint64()?;
},
26 => {
self.shards.push(is.read_message()?);
},
34 => {
self.nodes.push(is.read_message()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if !self.entity_type.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.entity_type);
}
if self.total_shards != 0 {
my_size += ::protobuf::rt::uint64_size(2, self.total_shards);
}
for value in &self.shards {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
for value in &self.nodes {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
};
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if !self.entity_type.is_empty() {
os.write_string(1, &self.entity_type)?;
}
if self.total_shards != 0 {
os.write_uint64(2, self.total_shards)?;
}
for v in &self.shards {
::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
};
for v in &self.nodes {
::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
};
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> ShardingStats {
ShardingStats::new()
}
fn clear(&mut self) {
self.entity_type.clear();
self.total_shards = 0;
self.shards.clear();
self.nodes.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static ShardingStats {
static instance: ShardingStats = ShardingStats {
entity_type: ::std::string::String::new(),
total_shards: 0,
shards: ::std::vec::Vec::new(),
nodes: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for ShardingStats {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("ShardingStats").unwrap()).clone()
}
}
impl ::std::fmt::Display for ShardingStats {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ShardingStats {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct GetShardStats {
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a GetShardStats {
fn default() -> &'a GetShardStats {
<GetShardStats as ::protobuf::Message>::default_instance()
}
}
impl GetShardStats {
pub fn new() -> GetShardStats {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(0);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetShardStats>(
"GetShardStats",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for GetShardStats {
const NAME: &'static str = "GetShardStats";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> GetShardStats {
GetShardStats::new()
}
fn clear(&mut self) {
self.special_fields.clear();
}
fn default_instance() -> &'static GetShardStats {
static instance: GetShardStats = GetShardStats {
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for GetShardStats {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("GetShardStats").unwrap()).clone()
}
}
impl ::std::fmt::Display for GetShardStats {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for GetShardStats {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ShardStats {
pub shard_id: u32,
pub node_id: u64,
pub entities: ::std::vec::Vec<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a ShardStats {
fn default() -> &'a ShardStats {
<ShardStats as ::protobuf::Message>::default_instance()
}
}
impl ShardStats {
pub fn new() -> ShardStats {
::std::default::Default::default()
}
fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
let mut fields = ::std::vec::Vec::with_capacity(3);
let mut oneofs = ::std::vec::Vec::with_capacity(0);
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"shard_id",
|m: &ShardStats| { &m.shard_id },
|m: &mut ShardStats| { &mut m.shard_id },
));
fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
"node_id",
|m: &ShardStats| { &m.node_id },
|m: &mut ShardStats| { &mut m.node_id },
));
fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
"entities",
|m: &ShardStats| { &m.entities },
|m: &mut ShardStats| { &mut m.entities },
));
::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ShardStats>(
"ShardStats",
fields,
oneofs,
)
}
}
impl ::protobuf::Message for ShardStats {
const NAME: &'static str = "ShardStats";
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
while let Some(tag) = is.read_raw_tag_or_eof()? {
match tag {
8 => {
self.shard_id = is.read_uint32()?;
},
16 => {
self.node_id = is.read_uint64()?;
},
26 => {
self.entities.push(is.read_string()?);
},
tag => {
::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u64 {
let mut my_size = 0;
if self.shard_id != 0 {
my_size += ::protobuf::rt::uint32_size(1, self.shard_id);
}
if self.node_id != 0 {
my_size += ::protobuf::rt::uint64_size(2, self.node_id);
}
for value in &self.entities {
my_size += ::protobuf::rt::string_size(3, &value);
};
my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
self.special_fields.cached_size().set(my_size as u32);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
if self.shard_id != 0 {
os.write_uint32(1, self.shard_id)?;
}
if self.node_id != 0 {
os.write_uint64(2, self.node_id)?;
}
for v in &self.entities {
os.write_string(3, &v)?;
};
os.write_unknown_fields(self.special_fields.unknown_fields())?;
::std::result::Result::Ok(())
}
fn special_fields(&self) -> &::protobuf::SpecialFields {
&self.special_fields
}
fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
&mut self.special_fields
}
fn new() -> ShardStats {
ShardStats::new()
}
fn clear(&mut self) {
self.shard_id = 0;
self.node_id = 0;
self.entities.clear();
self.special_fields.clear();
}
fn default_instance() -> &'static ShardStats {
static instance: ShardStats = ShardStats {
shard_id: 0,
node_id: 0,
entities: ::std::vec::Vec::new(),
special_fields: ::protobuf::SpecialFields::new(),
};
&instance
}
}
impl ::protobuf::MessageFull for ShardStats {
fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().message_by_package_relative_name("ShardStats").unwrap()).clone()
}
}
impl ::std::fmt::Display for ShardStats {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for ShardStats {
type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}
#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
pub enum EntityState {
IDLE = 0,
ACTIVE = 1,
PASSIVATED = 2,
}
impl ::protobuf::Enum for EntityState {
const NAME: &'static str = "EntityState";
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<EntityState> {
match value {
0 => ::std::option::Option::Some(EntityState::IDLE),
1 => ::std::option::Option::Some(EntityState::ACTIVE),
2 => ::std::option::Option::Some(EntityState::PASSIVATED),
_ => ::std::option::Option::None
}
}
const VALUES: &'static [EntityState] = &[
EntityState::IDLE,
EntityState::ACTIVE,
EntityState::PASSIVATED,
];
}
impl ::protobuf::EnumFull for EntityState {
fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().enum_by_package_relative_name("EntityState").unwrap()).clone()
}
fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
let index = *self as usize;
Self::enum_descriptor().value_by_index(index)
}
}
impl ::std::default::Default for EntityState {
fn default() -> Self {
EntityState::IDLE
}
}
impl EntityState {
fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
::protobuf::reflect::GeneratedEnumDescriptorData::new::<EntityState>("EntityState")
}
}
#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
pub enum ShardHostStatus {
UNKNOWN = 0,
STARTING = 1,
READY = 2,
UNAVAILABLE = 3,
}
impl ::protobuf::Enum for ShardHostStatus {
const NAME: &'static str = "ShardHostStatus";
fn value(&self) -> i32 {
*self as i32
}
fn from_i32(value: i32) -> ::std::option::Option<ShardHostStatus> {
match value {
0 => ::std::option::Option::Some(ShardHostStatus::UNKNOWN),
1 => ::std::option::Option::Some(ShardHostStatus::STARTING),
2 => ::std::option::Option::Some(ShardHostStatus::READY),
3 => ::std::option::Option::Some(ShardHostStatus::UNAVAILABLE),
_ => ::std::option::Option::None
}
}
const VALUES: &'static [ShardHostStatus] = &[
ShardHostStatus::UNKNOWN,
ShardHostStatus::STARTING,
ShardHostStatus::READY,
ShardHostStatus::UNAVAILABLE,
];
}
impl ::protobuf::EnumFull for ShardHostStatus {
fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
descriptor.get(|| file_descriptor().enum_by_package_relative_name("ShardHostStatus").unwrap()).clone()
}
fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
let index = *self as usize;
Self::enum_descriptor().value_by_index(index)
}
}
impl ::std::default::Default for ShardHostStatus {
fn default() -> Self {
ShardHostStatus::UNKNOWN
}
}
impl ShardHostStatus {
fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
::protobuf::reflect::GeneratedEnumDescriptorData::new::<ShardHostStatus>("ShardHostStatus")
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x0esharding.proto\x12\x0fcoerce.sharding\"L\n\rAllocateShard\x12\x19\
\n\x08shard_id\x18\x01\x20\x01(\rR\x07shardId\x12\x20\n\x0brebalancing\
\x18\x02\x20\x01(\x08R\x0brebalancing\"A\n\x0bRemoteShard\x12\x19\n\x08s\
hard_id\x18\x01\x20\x01(\rR\x07shardId\x12\x17\n\x07node_id\x18\x02\x20\
\x01(\x04R\x06nodeId\"D\n\x0eShardAllocated\x122\n\x05shard\x18\x01\x20\
\x01(\x0b2\x1c.coerce.sharding.RemoteShardR\x05shard\".\n\x11ShardReallo\
cating\x12\x19\n\x08shard_id\x18\x01\x20\x01(\rR\x07shardId\"k\n\tStopSh\
ard\x12\x19\n\x08shard_id\x18\x01\x20\x01(\rR\x07shardId\x12$\n\x0eorigi\
n_node_id\x18\x02\x20\x01(\x04R\x0coriginNodeId\x12\x1d\n\nrequest_id\
\x18\x03\x20\x01(\tR\trequestId\"t\n\x0cShardStopped\x12\x19\n\x08shard_\
id\x18\x01\x20\x01(\rR\x07shardId\x12$\n\x0eorigin_node_id\x18\x02\x20\
\x01(\x04R\x0coriginNodeId\x12#\n\ris_successful\x18\x03\x20\x01(\x08R\
\x0cisSuccessful\"\xe4\x02\n\x13AllocateShardResult\x12J\n\x0bresult_typ\
e\x18\x01\x20\x01(\x0e2).coerce.sharding.AllocateShardResult.TypeR\nresu\
ltType\x12<\n\nallocation\x18\x02\x20\x01(\x0b2\x1c.coerce.sharding.Remo\
teShardR\nallocation\x12G\n\x03err\x18\x03\x20\x01(\x0e25.coerce.shardin\
g.AllocateShardResult.AllocateShardErrR\x03err\"H\n\x04Type\x12\r\n\tALL\
OCATED\x10\0\x12\x15\n\x11ALREADY_ALLOCATED\x10\x01\x12\x11\n\rNOT_ALLOC\
ATED\x10\x02\x12\x07\n\x03ERR\x10\x03\"0\n\x10AllocateShardErr\x12\x0b\n\
\x07UNKNOWN\x10\0\x12\x0f\n\x0bPERSISTENCE\x10\x01\"\x94\x02\n\x13Remote\
EntityRequest\x12\x1d\n\nrequest_id\x18\x01\x20\x01(\tR\trequestId\x12\
\x19\n\x08actor_id\x18\x02\x20\x01(\tR\x07actorId\x12!\n\x0cmessage_type\
\x18\x03\x20\x01(\tR\x0bmessageType\x12\x18\n\x07message\x18\x04\x20\x01\
(\x0cR\x07message\x12C\n\x06recipe\x18\x05\x20\x01(\x0b2+.coerce.shardin\
g.RemoteEntityRequest.RecipeR\x06recipe\x12\x1f\n\x0borigin_node\x18\x06\
\x20\x01(\x04R\noriginNode\x1a\x20\n\x06Recipe\x12\x16\n\x06recipe\x18\
\x01\x20\x01(\x0cR\x06recipe\"@\n\x0bStartEntity\x12\x19\n\x08actor_id\
\x18\x01\x20\x01(\tR\x07actorId\x12\x16\n\x06recipe\x18\x02\x20\x01(\x0c\
R\x06recipe\",\n\x0fPassivateEntity\x12\x19\n\x08actor_id\x18\x01\x20\
\x01(\tR\x07actorId\")\n\x0cRemoveEntity\x12\x19\n\x08actor_id\x18\x01\
\x20\x01(\tR\x07actorId\"\x81\x02\n\x12ShardStateSnapshot\x12\x19\n\x08s\
hard_id\x18\x01\x20\x01(\rR\x07shardId\x12\x17\n\x07node_id\x18\x02\x20\
\x01(\x04R\x06nodeId\x12F\n\x08entities\x18\x03\x20\x03(\x0b2*.coerce.sh\
arding.ShardStateSnapshot.EntityR\x08entities\x1ao\n\x06Entity\x12\x19\n\
\x08actor_id\x18\x01\x20\x01(\tR\x07actorId\x12\x16\n\x06recipe\x18\x02\
\x20\x01(\x0cR\x06recipe\x122\n\x05state\x18\x03\x20\x01(\x0e2\x1c.coerc\
e.sharding.EntityStateR\x05state\"\x12\n\x10GetShardingStats\"\x7f\n\tNo\
deStats\x12\x17\n\x07node_id\x18\x01\x20\x01(\x04R\x06nodeId\x12\x1f\n\
\x0bshard_count\x18\x02\x20\x01(\x04R\nshardCount\x128\n\x06status\x18\
\x03\x20\x01(\x0e2\x20.coerce.sharding.ShardHostStatusR\x06status\"\xbb\
\x01\n\rShardingStats\x12\x1f\n\x0bentity_type\x18\x01\x20\x01(\tR\nenti\
tyType\x12!\n\x0ctotal_shards\x18\x02\x20\x01(\x04R\x0btotalShards\x124\
\n\x06shards\x18\x03\x20\x03(\x0b2\x1c.coerce.sharding.RemoteShardR\x06s\
hards\x120\n\x05nodes\x18\x04\x20\x03(\x0b2\x1a.coerce.sharding.NodeStat\
sR\x05nodes\"\x0f\n\rGetShardStats\"\\\n\nShardStats\x12\x19\n\x08shard_\
id\x18\x01\x20\x01(\rR\x07shardId\x12\x17\n\x07node_id\x18\x02\x20\x01(\
\x04R\x06nodeId\x12\x1a\n\x08entities\x18\x03\x20\x03(\tR\x08entities*3\
\n\x0bEntityState\x12\x08\n\x04IDLE\x10\0\x12\n\n\x06ACTIVE\x10\x01\x12\
\x0e\n\nPASSIVATED\x10\x02*H\n\x0fShardHostStatus\x12\x0b\n\x07UNKNOWN\
\x10\0\x12\x0c\n\x08STARTING\x10\x01\x12\t\n\x05READY\x10\x02\x12\x0f\n\
\x0bUNAVAILABLE\x10\x03b\x06proto3\
";
fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
file_descriptor_proto_lazy.get(|| {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
})
}
pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
file_descriptor.get(|| {
let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
let mut deps = ::std::vec::Vec::with_capacity(0);
let mut messages = ::std::vec::Vec::with_capacity(19);
messages.push(AllocateShard::generated_message_descriptor_data());
messages.push(RemoteShard::generated_message_descriptor_data());
messages.push(ShardAllocated::generated_message_descriptor_data());
messages.push(ShardReallocating::generated_message_descriptor_data());
messages.push(StopShard::generated_message_descriptor_data());
messages.push(ShardStopped::generated_message_descriptor_data());
messages.push(AllocateShardResult::generated_message_descriptor_data());
messages.push(RemoteEntityRequest::generated_message_descriptor_data());
messages.push(StartEntity::generated_message_descriptor_data());
messages.push(PassivateEntity::generated_message_descriptor_data());
messages.push(RemoveEntity::generated_message_descriptor_data());
messages.push(ShardStateSnapshot::generated_message_descriptor_data());
messages.push(GetShardingStats::generated_message_descriptor_data());
messages.push(NodeStats::generated_message_descriptor_data());
messages.push(ShardingStats::generated_message_descriptor_data());
messages.push(GetShardStats::generated_message_descriptor_data());
messages.push(ShardStats::generated_message_descriptor_data());
messages.push(remote_entity_request::Recipe::generated_message_descriptor_data());
messages.push(shard_state_snapshot::Entity::generated_message_descriptor_data());
let mut enums = ::std::vec::Vec::with_capacity(4);
enums.push(EntityState::generated_enum_descriptor_data());
enums.push(ShardHostStatus::generated_enum_descriptor_data());
enums.push(allocate_shard_result::Type::generated_enum_descriptor_data());
enums.push(allocate_shard_result::AllocateShardErr::generated_enum_descriptor_data());
::protobuf::reflect::GeneratedFileDescriptor::new_generated(
file_descriptor_proto(),
deps,
messages,
enums,
)
});
::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
})
}