#![allow(unknown_lints)]
#![allow(clippy::all)]
#![cfg_attr(rustfmt, rustfmt_skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unsafe_code)]
#![allow(unused_imports)]
#![allow(unused_results)]
use protobuf::Message as Message_imported_for_functions;
use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_7_0;
#[derive(PartialEq,Clone,Default)]
pub struct Hello {
pub hey: ::std::string::String,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Hello {
fn default() -> &'a Hello {
<Hello as ::protobuf::Message>::default_instance()
}
}
impl Hello {
pub fn new() -> Hello {
::std::default::Default::default()
}
pub fn get_hey(&self) -> &str {
&self.hey
}
pub fn clear_hey(&mut self) {
self.hey.clear();
}
pub fn set_hey(&mut self, v: ::std::string::String) {
self.hey = v;
}
pub fn mut_hey(&mut self) -> &mut ::std::string::String {
&mut self.hey
}
pub fn take_hey(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.hey, ::std::string::String::new())
}
}
impl ::protobuf::Message for Hello {
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.hey)?;
},
_ => {
::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.hey.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.hey);
}
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.hey.is_empty() {
os.write_string(1, &self.hey)?;
}
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) -> &::std::any::Any {
self as &::std::any::Any
}
fn as_any_mut(&mut self) -> &mut ::std::any::Any {
self as &mut ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Hello {
Hello::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"hey",
|m: &Hello| { &m.hey },
|m: &mut Hello| { &mut m.hey },
));
::protobuf::reflect::MessageDescriptor::new::<Hello>(
"Hello",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Hello {
static mut instance: ::protobuf::lazy::Lazy<Hello> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Hello,
};
unsafe {
instance.get(Hello::new)
}
}
}
impl ::protobuf::Clear for Hello {
fn clear(&mut self) {
self.hey.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Hello {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Hello {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SnapshotRequest {
pub id: i32,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SnapshotRequest {
fn default() -> &'a SnapshotRequest {
<SnapshotRequest as ::protobuf::Message>::default_instance()
}
}
impl SnapshotRequest {
pub fn new() -> SnapshotRequest {
::std::default::Default::default()
}
pub fn get_id(&self) -> i32 {
self.id
}
pub fn clear_id(&mut self) {
self.id = 0;
}
pub fn set_id(&mut self, v: i32) {
self.id = v;
}
}
impl ::protobuf::Message for SnapshotRequest {
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.id = 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.id != 0 {
my_size += ::protobuf::rt::value_size(1, self.id, ::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.id != 0 {
os.write_int32(1, self.id)?;
}
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) -> &::std::any::Any {
self as &::std::any::Any
}
fn as_any_mut(&mut self) -> &mut ::std::any::Any {
self as &mut ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> SnapshotRequest {
SnapshotRequest::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"id",
|m: &SnapshotRequest| { &m.id },
|m: &mut SnapshotRequest| { &mut m.id },
));
::protobuf::reflect::MessageDescriptor::new::<SnapshotRequest>(
"SnapshotRequest",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static SnapshotRequest {
static mut instance: ::protobuf::lazy::Lazy<SnapshotRequest> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const SnapshotRequest,
};
unsafe {
instance.get(SnapshotRequest::new)
}
}
}
impl ::protobuf::Clear for SnapshotRequest {
fn clear(&mut self) {
self.id = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SnapshotRequest {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SnapshotRequest {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct TaskMetric {
pub id: u64,
pub task_avg: u64,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a TaskMetric {
fn default() -> &'a TaskMetric {
<TaskMetric as ::protobuf::Message>::default_instance()
}
}
impl TaskMetric {
pub fn new() -> TaskMetric {
::std::default::Default::default()
}
pub fn get_id(&self) -> u64 {
self.id
}
pub fn clear_id(&mut self) {
self.id = 0;
}
pub fn set_id(&mut self, v: u64) {
self.id = v;
}
pub fn get_task_avg(&self) -> u64 {
self.task_avg
}
pub fn clear_task_avg(&mut self) {
self.task_avg = 0;
}
pub fn set_task_avg(&mut self, v: u64) {
self.task_avg = v;
}
}
impl ::protobuf::Message for TaskMetric {
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_uint64()?;
self.id = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.task_avg = 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.id != 0 {
my_size += ::protobuf::rt::value_size(1, self.id, ::protobuf::wire_format::WireTypeVarint);
}
if self.task_avg != 0 {
my_size += ::protobuf::rt::value_size(2, self.task_avg, ::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.id != 0 {
os.write_uint64(1, self.id)?;
}
if self.task_avg != 0 {
os.write_uint64(2, self.task_avg)?;
}
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) -> &::std::any::Any {
self as &::std::any::Any
}
fn as_any_mut(&mut self) -> &mut ::std::any::Any {
self as &mut ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> TaskMetric {
TaskMetric::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"id",
|m: &TaskMetric| { &m.id },
|m: &mut TaskMetric| { &mut m.id },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"task_avg",
|m: &TaskMetric| { &m.task_avg },
|m: &mut TaskMetric| { &mut m.task_avg },
));
::protobuf::reflect::MessageDescriptor::new::<TaskMetric>(
"TaskMetric",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static TaskMetric {
static mut instance: ::protobuf::lazy::Lazy<TaskMetric> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const TaskMetric,
};
unsafe {
instance.get(TaskMetric::new)
}
}
}
impl ::protobuf::Clear for TaskMetric {
fn clear(&mut self) {
self.id = 0;
self.task_avg = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for TaskMetric {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for TaskMetric {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct MetricReport {
pub taskMetrics: ::protobuf::RepeatedField<TaskMetric>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MetricReport {
fn default() -> &'a MetricReport {
<MetricReport as ::protobuf::Message>::default_instance()
}
}
impl MetricReport {
pub fn new() -> MetricReport {
::std::default::Default::default()
}
pub fn get_taskMetrics(&self) -> &[TaskMetric] {
&self.taskMetrics
}
pub fn clear_taskMetrics(&mut self) {
self.taskMetrics.clear();
}
pub fn set_taskMetrics(&mut self, v: ::protobuf::RepeatedField<TaskMetric>) {
self.taskMetrics = v;
}
pub fn mut_taskMetrics(&mut self) -> &mut ::protobuf::RepeatedField<TaskMetric> {
&mut self.taskMetrics
}
pub fn take_taskMetrics(&mut self) -> ::protobuf::RepeatedField<TaskMetric> {
::std::mem::replace(&mut self.taskMetrics, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for MetricReport {
fn is_initialized(&self) -> bool {
for v in &self.taskMetrics {
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.taskMetrics)?;
},
_ => {
::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.taskMetrics {
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.taskMetrics {
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) -> &::std::any::Any {
self as &::std::any::Any
}
fn as_any_mut(&mut self) -> &mut ::std::any::Any {
self as &mut ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> MetricReport {
MetricReport::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<TaskMetric>>(
"taskMetrics",
|m: &MetricReport| { &m.taskMetrics },
|m: &mut MetricReport| { &mut m.taskMetrics },
));
::protobuf::reflect::MessageDescriptor::new::<MetricReport>(
"MetricReport",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static MetricReport {
static mut instance: ::protobuf::lazy::Lazy<MetricReport> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const MetricReport,
};
unsafe {
instance.get(MetricReport::new)
}
}
}
impl ::protobuf::Clear for MetricReport {
fn clear(&mut self) {
self.taskMetrics.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for MetricReport {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for MetricReport {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct Ask {
pub askActor: ::std::string::String,
pub msg: ::protobuf::SingularPtrField<KompactAkkaMsg>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Ask {
fn default() -> &'a Ask {
<Ask as ::protobuf::Message>::default_instance()
}
}
impl Ask {
pub fn new() -> Ask {
::std::default::Default::default()
}
pub fn get_askActor(&self) -> &str {
&self.askActor
}
pub fn clear_askActor(&mut self) {
self.askActor.clear();
}
pub fn set_askActor(&mut self, v: ::std::string::String) {
self.askActor = v;
}
pub fn mut_askActor(&mut self) -> &mut ::std::string::String {
&mut self.askActor
}
pub fn take_askActor(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.askActor, ::std::string::String::new())
}
pub fn get_msg(&self) -> &KompactAkkaMsg {
self.msg.as_ref().unwrap_or_else(|| KompactAkkaMsg::default_instance())
}
pub fn clear_msg(&mut self) {
self.msg.clear();
}
pub fn has_msg(&self) -> bool {
self.msg.is_some()
}
pub fn set_msg(&mut self, v: KompactAkkaMsg) {
self.msg = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_msg(&mut self) -> &mut KompactAkkaMsg {
if self.msg.is_none() {
self.msg.set_default();
}
self.msg.as_mut().unwrap()
}
pub fn take_msg(&mut self) -> KompactAkkaMsg {
self.msg.take().unwrap_or_else(|| KompactAkkaMsg::new())
}
}
impl ::protobuf::Message for Ask {
fn is_initialized(&self) -> bool {
for v in &self.msg {
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.askActor)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.msg)?;
},
_ => {
::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.askActor.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.askActor);
}
if let Some(ref v) = self.msg.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 !self.askActor.is_empty() {
os.write_string(1, &self.askActor)?;
}
if let Some(ref v) = self.msg.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)?;
}
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) -> &::std::any::Any {
self as &::std::any::Any
}
fn as_any_mut(&mut self) -> &mut ::std::any::Any {
self as &mut ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Ask {
Ask::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"askActor",
|m: &Ask| { &m.askActor },
|m: &mut Ask| { &mut m.askActor },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<KompactAkkaMsg>>(
"msg",
|m: &Ask| { &m.msg },
|m: &mut Ask| { &mut m.msg },
));
::protobuf::reflect::MessageDescriptor::new::<Ask>(
"Ask",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Ask {
static mut instance: ::protobuf::lazy::Lazy<Ask> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const Ask,
};
unsafe {
instance.get(Ask::new)
}
}
}
impl ::protobuf::Clear for Ask {
fn clear(&mut self) {
self.askActor.clear();
self.msg.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Ask {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Ask {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct AskReply {
pub askActor: ::std::string::String,
pub msg: ::protobuf::SingularPtrField<KompactAkkaMsg>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a AskReply {
fn default() -> &'a AskReply {
<AskReply as ::protobuf::Message>::default_instance()
}
}
impl AskReply {
pub fn new() -> AskReply {
::std::default::Default::default()
}
pub fn get_askActor(&self) -> &str {
&self.askActor
}
pub fn clear_askActor(&mut self) {
self.askActor.clear();
}
pub fn set_askActor(&mut self, v: ::std::string::String) {
self.askActor = v;
}
pub fn mut_askActor(&mut self) -> &mut ::std::string::String {
&mut self.askActor
}
pub fn take_askActor(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.askActor, ::std::string::String::new())
}
pub fn get_msg(&self) -> &KompactAkkaMsg {
self.msg.as_ref().unwrap_or_else(|| KompactAkkaMsg::default_instance())
}
pub fn clear_msg(&mut self) {
self.msg.clear();
}
pub fn has_msg(&self) -> bool {
self.msg.is_some()
}
pub fn set_msg(&mut self, v: KompactAkkaMsg) {
self.msg = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_msg(&mut self) -> &mut KompactAkkaMsg {
if self.msg.is_none() {
self.msg.set_default();
}
self.msg.as_mut().unwrap()
}
pub fn take_msg(&mut self) -> KompactAkkaMsg {
self.msg.take().unwrap_or_else(|| KompactAkkaMsg::new())
}
}
impl ::protobuf::Message for AskReply {
fn is_initialized(&self) -> bool {
for v in &self.msg {
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.askActor)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.msg)?;
},
_ => {
::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.askActor.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.askActor);
}
if let Some(ref v) = self.msg.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 !self.askActor.is_empty() {
os.write_string(1, &self.askActor)?;
}
if let Some(ref v) = self.msg.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)?;
}
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) -> &::std::any::Any {
self as &::std::any::Any
}
fn as_any_mut(&mut self) -> &mut ::std::any::Any {
self as &mut ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> AskReply {
AskReply::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"askActor",
|m: &AskReply| { &m.askActor },
|m: &mut AskReply| { &mut m.askActor },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<KompactAkkaMsg>>(
"msg",
|m: &AskReply| { &m.msg },
|m: &mut AskReply| { &mut m.msg },
));
::protobuf::reflect::MessageDescriptor::new::<AskReply>(
"AskReply",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static AskReply {
static mut instance: ::protobuf::lazy::Lazy<AskReply> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const AskReply,
};
unsafe {
instance.get(AskReply::new)
}
}
}
impl ::protobuf::Clear for AskReply {
fn clear(&mut self) {
self.askActor.clear();
self.msg.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for AskReply {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for AskReply {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct KompactRegistration {
pub id: ::std::string::String,
pub src: ::protobuf::SingularPtrField<KompactAkkaPath>,
pub dst: ::protobuf::SingularPtrField<KompactAkkaPath>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a KompactRegistration {
fn default() -> &'a KompactRegistration {
<KompactRegistration as ::protobuf::Message>::default_instance()
}
}
impl KompactRegistration {
pub fn new() -> KompactRegistration {
::std::default::Default::default()
}
pub fn get_id(&self) -> &str {
&self.id
}
pub fn clear_id(&mut self) {
self.id.clear();
}
pub fn set_id(&mut self, v: ::std::string::String) {
self.id = v;
}
pub fn mut_id(&mut self) -> &mut ::std::string::String {
&mut self.id
}
pub fn take_id(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.id, ::std::string::String::new())
}
pub fn get_src(&self) -> &KompactAkkaPath {
self.src.as_ref().unwrap_or_else(|| KompactAkkaPath::default_instance())
}
pub fn clear_src(&mut self) {
self.src.clear();
}
pub fn has_src(&self) -> bool {
self.src.is_some()
}
pub fn set_src(&mut self, v: KompactAkkaPath) {
self.src = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_src(&mut self) -> &mut KompactAkkaPath {
if self.src.is_none() {
self.src.set_default();
}
self.src.as_mut().unwrap()
}
pub fn take_src(&mut self) -> KompactAkkaPath {
self.src.take().unwrap_or_else(|| KompactAkkaPath::new())
}
pub fn get_dst(&self) -> &KompactAkkaPath {
self.dst.as_ref().unwrap_or_else(|| KompactAkkaPath::default_instance())
}
pub fn clear_dst(&mut self) {
self.dst.clear();
}
pub fn has_dst(&self) -> bool {
self.dst.is_some()
}
pub fn set_dst(&mut self, v: KompactAkkaPath) {
self.dst = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_dst(&mut self) -> &mut KompactAkkaPath {
if self.dst.is_none() {
self.dst.set_default();
}
self.dst.as_mut().unwrap()
}
pub fn take_dst(&mut self) -> KompactAkkaPath {
self.dst.take().unwrap_or_else(|| KompactAkkaPath::new())
}
}
impl ::protobuf::Message for KompactRegistration {
fn is_initialized(&self) -> bool {
for v in &self.src {
if !v.is_initialized() {
return false;
}
};
for v in &self.dst {
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.id)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.src)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.dst)?;
},
_ => {
::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.id.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.id);
}
if let Some(ref v) = self.src.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.dst.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 !self.id.is_empty() {
os.write_string(1, &self.id)?;
}
if let Some(ref v) = self.src.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 let Some(ref v) = self.dst.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)?;
}
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) -> &::std::any::Any {
self as &::std::any::Any
}
fn as_any_mut(&mut self) -> &mut ::std::any::Any {
self as &mut ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> KompactRegistration {
KompactRegistration::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"id",
|m: &KompactRegistration| { &m.id },
|m: &mut KompactRegistration| { &mut m.id },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<KompactAkkaPath>>(
"src",
|m: &KompactRegistration| { &m.src },
|m: &mut KompactRegistration| { &mut m.src },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<KompactAkkaPath>>(
"dst",
|m: &KompactRegistration| { &m.dst },
|m: &mut KompactRegistration| { &mut m.dst },
));
::protobuf::reflect::MessageDescriptor::new::<KompactRegistration>(
"KompactRegistration",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static KompactRegistration {
static mut instance: ::protobuf::lazy::Lazy<KompactRegistration> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const KompactRegistration,
};
unsafe {
instance.get(KompactRegistration::new)
}
}
}
impl ::protobuf::Clear for KompactRegistration {
fn clear(&mut self) {
self.id.clear();
self.src.clear();
self.dst.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for KompactRegistration {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for KompactRegistration {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct KompactAkkaPath {
pub path: ::std::string::String,
pub ip: ::std::string::String,
pub port: i32,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a KompactAkkaPath {
fn default() -> &'a KompactAkkaPath {
<KompactAkkaPath as ::protobuf::Message>::default_instance()
}
}
impl KompactAkkaPath {
pub fn new() -> KompactAkkaPath {
::std::default::Default::default()
}
pub fn get_path(&self) -> &str {
&self.path
}
pub fn clear_path(&mut self) {
self.path.clear();
}
pub fn set_path(&mut self, v: ::std::string::String) {
self.path = v;
}
pub fn mut_path(&mut self) -> &mut ::std::string::String {
&mut self.path
}
pub fn take_path(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.path, ::std::string::String::new())
}
pub fn get_ip(&self) -> &str {
&self.ip
}
pub fn clear_ip(&mut self) {
self.ip.clear();
}
pub fn set_ip(&mut self, v: ::std::string::String) {
self.ip = v;
}
pub fn mut_ip(&mut self) -> &mut ::std::string::String {
&mut self.ip
}
pub fn take_ip(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.ip, ::std::string::String::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;
}
}
impl ::protobuf::Message for KompactAkkaPath {
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.path)?;
},
2 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.ip)?;
},
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.port = 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.path.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.path);
}
if !self.ip.is_empty() {
my_size += ::protobuf::rt::string_size(2, &self.ip);
}
if self.port != 0 {
my_size += ::protobuf::rt::value_size(3, self.port, ::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.path.is_empty() {
os.write_string(1, &self.path)?;
}
if !self.ip.is_empty() {
os.write_string(2, &self.ip)?;
}
if self.port != 0 {
os.write_int32(3, self.port)?;
}
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) -> &::std::any::Any {
self as &::std::any::Any
}
fn as_any_mut(&mut self) -> &mut ::std::any::Any {
self as &mut ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> KompactAkkaPath {
KompactAkkaPath::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"path",
|m: &KompactAkkaPath| { &m.path },
|m: &mut KompactAkkaPath| { &mut m.path },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"ip",
|m: &KompactAkkaPath| { &m.ip },
|m: &mut KompactAkkaPath| { &mut m.ip },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"port",
|m: &KompactAkkaPath| { &m.port },
|m: &mut KompactAkkaPath| { &mut m.port },
));
::protobuf::reflect::MessageDescriptor::new::<KompactAkkaPath>(
"KompactAkkaPath",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static KompactAkkaPath {
static mut instance: ::protobuf::lazy::Lazy<KompactAkkaPath> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const KompactAkkaPath,
};
unsafe {
instance.get(KompactAkkaPath::new)
}
}
}
impl ::protobuf::Clear for KompactAkkaPath {
fn clear(&mut self) {
self.path.clear();
self.ip.clear();
self.port = 0;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for KompactAkkaPath {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for KompactAkkaPath {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct KompactAkkaMsg {
pub payload: ::std::option::Option<KompactAkkaMsg_oneof_payload>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a KompactAkkaMsg {
fn default() -> &'a KompactAkkaMsg {
<KompactAkkaMsg as ::protobuf::Message>::default_instance()
}
}
#[derive(Clone,PartialEq,Debug)]
pub enum KompactAkkaMsg_oneof_payload {
kompactRegistration(KompactRegistration),
hello(Hello),
ask(Ask),
askReply(AskReply),
snapshotRequest(SnapshotRequest),
}
impl KompactAkkaMsg {
pub fn new() -> KompactAkkaMsg {
::std::default::Default::default()
}
pub fn get_kompactRegistration(&self) -> &KompactRegistration {
match self.payload {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::kompactRegistration(ref v)) => v,
_ => KompactRegistration::default_instance(),
}
}
pub fn clear_kompactRegistration(&mut self) {
self.payload = ::std::option::Option::None;
}
pub fn has_kompactRegistration(&self) -> bool {
match self.payload {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::kompactRegistration(..)) => true,
_ => false,
}
}
pub fn set_kompactRegistration(&mut self, v: KompactRegistration) {
self.payload = ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::kompactRegistration(v))
}
pub fn mut_kompactRegistration(&mut self) -> &mut KompactRegistration {
if let ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::kompactRegistration(_)) = self.payload {
} else {
self.payload = ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::kompactRegistration(KompactRegistration::new()));
}
match self.payload {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::kompactRegistration(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_kompactRegistration(&mut self) -> KompactRegistration {
if self.has_kompactRegistration() {
match self.payload.take() {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::kompactRegistration(v)) => v,
_ => panic!(),
}
} else {
KompactRegistration::new()
}
}
pub fn get_hello(&self) -> &Hello {
match self.payload {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::hello(ref v)) => v,
_ => Hello::default_instance(),
}
}
pub fn clear_hello(&mut self) {
self.payload = ::std::option::Option::None;
}
pub fn has_hello(&self) -> bool {
match self.payload {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::hello(..)) => true,
_ => false,
}
}
pub fn set_hello(&mut self, v: Hello) {
self.payload = ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::hello(v))
}
pub fn mut_hello(&mut self) -> &mut Hello {
if let ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::hello(_)) = self.payload {
} else {
self.payload = ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::hello(Hello::new()));
}
match self.payload {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::hello(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_hello(&mut self) -> Hello {
if self.has_hello() {
match self.payload.take() {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::hello(v)) => v,
_ => panic!(),
}
} else {
Hello::new()
}
}
pub fn get_ask(&self) -> &Ask {
match self.payload {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::ask(ref v)) => v,
_ => Ask::default_instance(),
}
}
pub fn clear_ask(&mut self) {
self.payload = ::std::option::Option::None;
}
pub fn has_ask(&self) -> bool {
match self.payload {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::ask(..)) => true,
_ => false,
}
}
pub fn set_ask(&mut self, v: Ask) {
self.payload = ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::ask(v))
}
pub fn mut_ask(&mut self) -> &mut Ask {
if let ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::ask(_)) = self.payload {
} else {
self.payload = ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::ask(Ask::new()));
}
match self.payload {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::ask(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_ask(&mut self) -> Ask {
if self.has_ask() {
match self.payload.take() {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::ask(v)) => v,
_ => panic!(),
}
} else {
Ask::new()
}
}
pub fn get_askReply(&self) -> &AskReply {
match self.payload {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::askReply(ref v)) => v,
_ => AskReply::default_instance(),
}
}
pub fn clear_askReply(&mut self) {
self.payload = ::std::option::Option::None;
}
pub fn has_askReply(&self) -> bool {
match self.payload {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::askReply(..)) => true,
_ => false,
}
}
pub fn set_askReply(&mut self, v: AskReply) {
self.payload = ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::askReply(v))
}
pub fn mut_askReply(&mut self) -> &mut AskReply {
if let ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::askReply(_)) = self.payload {
} else {
self.payload = ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::askReply(AskReply::new()));
}
match self.payload {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::askReply(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_askReply(&mut self) -> AskReply {
if self.has_askReply() {
match self.payload.take() {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::askReply(v)) => v,
_ => panic!(),
}
} else {
AskReply::new()
}
}
pub fn get_snapshotRequest(&self) -> &SnapshotRequest {
match self.payload {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::snapshotRequest(ref v)) => v,
_ => SnapshotRequest::default_instance(),
}
}
pub fn clear_snapshotRequest(&mut self) {
self.payload = ::std::option::Option::None;
}
pub fn has_snapshotRequest(&self) -> bool {
match self.payload {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::snapshotRequest(..)) => true,
_ => false,
}
}
pub fn set_snapshotRequest(&mut self, v: SnapshotRequest) {
self.payload = ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::snapshotRequest(v))
}
pub fn mut_snapshotRequest(&mut self) -> &mut SnapshotRequest {
if let ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::snapshotRequest(_)) = self.payload {
} else {
self.payload = ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::snapshotRequest(SnapshotRequest::new()));
}
match self.payload {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::snapshotRequest(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_snapshotRequest(&mut self) -> SnapshotRequest {
if self.has_snapshotRequest() {
match self.payload.take() {
::std::option::Option::Some(KompactAkkaMsg_oneof_payload::snapshotRequest(v)) => v,
_ => panic!(),
}
} else {
SnapshotRequest::new()
}
}
}
impl ::protobuf::Message for KompactAkkaMsg {
fn is_initialized(&self) -> bool {
if let Some(KompactAkkaMsg_oneof_payload::kompactRegistration(ref v)) = self.payload {
if !v.is_initialized() {
return false;
}
}
if let Some(KompactAkkaMsg_oneof_payload::hello(ref v)) = self.payload {
if !v.is_initialized() {
return false;
}
}
if let Some(KompactAkkaMsg_oneof_payload::ask(ref v)) = self.payload {
if !v.is_initialized() {
return false;
}
}
if let Some(KompactAkkaMsg_oneof_payload::askReply(ref v)) = self.payload {
if !v.is_initialized() {
return false;
}
}
if let Some(KompactAkkaMsg_oneof_payload::snapshotRequest(ref v)) = self.payload {
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.payload = ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::kompactRegistration(is.read_message()?));
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.payload = ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::hello(is.read_message()?));
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.payload = ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::ask(is.read_message()?));
},
4 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.payload = ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::askReply(is.read_message()?));
},
5 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.payload = ::std::option::Option::Some(KompactAkkaMsg_oneof_payload::snapshotRequest(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.payload {
match v {
&KompactAkkaMsg_oneof_payload::kompactRegistration(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&KompactAkkaMsg_oneof_payload::hello(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&KompactAkkaMsg_oneof_payload::ask(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&KompactAkkaMsg_oneof_payload::askReply(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&KompactAkkaMsg_oneof_payload::snapshotRequest(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.payload {
match v {
&KompactAkkaMsg_oneof_payload::kompactRegistration(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)?;
},
&KompactAkkaMsg_oneof_payload::hello(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)?;
},
&KompactAkkaMsg_oneof_payload::ask(ref v) => {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
&KompactAkkaMsg_oneof_payload::askReply(ref v) => {
os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
&KompactAkkaMsg_oneof_payload::snapshotRequest(ref v) => {
os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
};
}
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) -> &::std::any::Any {
self as &::std::any::Any
}
fn as_any_mut(&mut self) -> &mut ::std::any::Any {
self as &mut ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> KompactAkkaMsg {
KompactAkkaMsg::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, KompactRegistration>(
"kompactRegistration",
KompactAkkaMsg::has_kompactRegistration,
KompactAkkaMsg::get_kompactRegistration,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Hello>(
"hello",
KompactAkkaMsg::has_hello,
KompactAkkaMsg::get_hello,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Ask>(
"ask",
KompactAkkaMsg::has_ask,
KompactAkkaMsg::get_ask,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, AskReply>(
"askReply",
KompactAkkaMsg::has_askReply,
KompactAkkaMsg::get_askReply,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, SnapshotRequest>(
"snapshotRequest",
KompactAkkaMsg::has_snapshotRequest,
KompactAkkaMsg::get_snapshotRequest,
));
::protobuf::reflect::MessageDescriptor::new::<KompactAkkaMsg>(
"KompactAkkaMsg",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static KompactAkkaMsg {
static mut instance: ::protobuf::lazy::Lazy<KompactAkkaMsg> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const KompactAkkaMsg,
};
unsafe {
instance.get(KompactAkkaMsg::new)
}
}
}
impl ::protobuf::Clear for KompactAkkaMsg {
fn clear(&mut self) {
self.payload = ::std::option::Option::None;
self.payload = ::std::option::Option::None;
self.payload = ::std::option::Option::None;
self.payload = ::std::option::Option::None;
self.payload = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for KompactAkkaMsg {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for KompactAkkaMsg {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct KompactAkkaEnvelope {
pub src: ::protobuf::SingularPtrField<KompactAkkaPath>,
pub dst: ::protobuf::SingularPtrField<KompactAkkaPath>,
pub msg: ::protobuf::SingularPtrField<KompactAkkaMsg>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a KompactAkkaEnvelope {
fn default() -> &'a KompactAkkaEnvelope {
<KompactAkkaEnvelope as ::protobuf::Message>::default_instance()
}
}
impl KompactAkkaEnvelope {
pub fn new() -> KompactAkkaEnvelope {
::std::default::Default::default()
}
pub fn get_src(&self) -> &KompactAkkaPath {
self.src.as_ref().unwrap_or_else(|| KompactAkkaPath::default_instance())
}
pub fn clear_src(&mut self) {
self.src.clear();
}
pub fn has_src(&self) -> bool {
self.src.is_some()
}
pub fn set_src(&mut self, v: KompactAkkaPath) {
self.src = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_src(&mut self) -> &mut KompactAkkaPath {
if self.src.is_none() {
self.src.set_default();
}
self.src.as_mut().unwrap()
}
pub fn take_src(&mut self) -> KompactAkkaPath {
self.src.take().unwrap_or_else(|| KompactAkkaPath::new())
}
pub fn get_dst(&self) -> &KompactAkkaPath {
self.dst.as_ref().unwrap_or_else(|| KompactAkkaPath::default_instance())
}
pub fn clear_dst(&mut self) {
self.dst.clear();
}
pub fn has_dst(&self) -> bool {
self.dst.is_some()
}
pub fn set_dst(&mut self, v: KompactAkkaPath) {
self.dst = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_dst(&mut self) -> &mut KompactAkkaPath {
if self.dst.is_none() {
self.dst.set_default();
}
self.dst.as_mut().unwrap()
}
pub fn take_dst(&mut self) -> KompactAkkaPath {
self.dst.take().unwrap_or_else(|| KompactAkkaPath::new())
}
pub fn get_msg(&self) -> &KompactAkkaMsg {
self.msg.as_ref().unwrap_or_else(|| KompactAkkaMsg::default_instance())
}
pub fn clear_msg(&mut self) {
self.msg.clear();
}
pub fn has_msg(&self) -> bool {
self.msg.is_some()
}
pub fn set_msg(&mut self, v: KompactAkkaMsg) {
self.msg = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_msg(&mut self) -> &mut KompactAkkaMsg {
if self.msg.is_none() {
self.msg.set_default();
}
self.msg.as_mut().unwrap()
}
pub fn take_msg(&mut self) -> KompactAkkaMsg {
self.msg.take().unwrap_or_else(|| KompactAkkaMsg::new())
}
}
impl ::protobuf::Message for KompactAkkaEnvelope {
fn is_initialized(&self) -> bool {
for v in &self.src {
if !v.is_initialized() {
return false;
}
};
for v in &self.dst {
if !v.is_initialized() {
return false;
}
};
for v in &self.msg {
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.src)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.dst)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.msg)?;
},
_ => {
::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.src.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.dst.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.msg.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.src.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.dst.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 let Some(ref v) = self.msg.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)?;
}
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) -> &::std::any::Any {
self as &::std::any::Any
}
fn as_any_mut(&mut self) -> &mut ::std::any::Any {
self as &mut ::std::any::Any
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> KompactAkkaEnvelope {
KompactAkkaEnvelope::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
};
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<KompactAkkaPath>>(
"src",
|m: &KompactAkkaEnvelope| { &m.src },
|m: &mut KompactAkkaEnvelope| { &mut m.src },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<KompactAkkaPath>>(
"dst",
|m: &KompactAkkaEnvelope| { &m.dst },
|m: &mut KompactAkkaEnvelope| { &mut m.dst },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<KompactAkkaMsg>>(
"msg",
|m: &KompactAkkaEnvelope| { &m.msg },
|m: &mut KompactAkkaEnvelope| { &mut m.msg },
));
::protobuf::reflect::MessageDescriptor::new::<KompactAkkaEnvelope>(
"KompactAkkaEnvelope",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static KompactAkkaEnvelope {
static mut instance: ::protobuf::lazy::Lazy<KompactAkkaEnvelope> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const KompactAkkaEnvelope,
};
unsafe {
instance.get(KompactAkkaEnvelope::new)
}
}
}
impl ::protobuf::Clear for KompactAkkaEnvelope {
fn clear(&mut self) {
self.src.clear();
self.dst.clear();
self.msg.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for KompactAkkaEnvelope {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for KompactAkkaEnvelope {
fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
::protobuf::reflect::ProtobufValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\rruntime.proto\"\x19\n\x05Hello\x12\x10\n\x03hey\x18\x01\x20\x01(\tR\
\x03hey\"!\n\x0fSnapshotRequest\x12\x0e\n\x02id\x18\x01\x20\x01(\x05R\
\x02id\"7\n\nTaskMetric\x12\x0e\n\x02id\x18\x01\x20\x01(\x04R\x02id\x12\
\x19\n\x08task_avg\x18\x02\x20\x01(\x04R\x07taskAvg\"=\n\x0cMetricReport\
\x12-\n\x0btaskMetrics\x18\x01\x20\x03(\x0b2\x0b.TaskMetricR\x0btaskMetr\
ics\"D\n\x03Ask\x12\x1a\n\x08askActor\x18\x01\x20\x01(\tR\x08askActor\
\x12!\n\x03msg\x18\x02\x20\x01(\x0b2\x0f.KompactAkkaMsgR\x03msg\"I\n\x08\
AskReply\x12\x1a\n\x08askActor\x18\x01\x20\x01(\tR\x08askActor\x12!\n\
\x03msg\x18\x02\x20\x01(\x0b2\x0f.KompactAkkaMsgR\x03msg\"m\n\x13Kompact\
Registration\x12\x0e\n\x02id\x18\x01\x20\x01(\tR\x02id\x12\"\n\x03src\
\x18\x02\x20\x01(\x0b2\x10.KompactAkkaPathR\x03src\x12\"\n\x03dst\x18\
\x03\x20\x01(\x0b2\x10.KompactAkkaPathR\x03dst\"I\n\x0fKompactAkkaPath\
\x12\x12\n\x04path\x18\x01\x20\x01(\tR\x04path\x12\x0e\n\x02ip\x18\x02\
\x20\x01(\tR\x02ip\x12\x12\n\x04port\x18\x03\x20\x01(\x05R\x04port\"\x86\
\x02\n\x0eKompactAkkaMsg\x12H\n\x13kompactRegistration\x18\x01\x20\x01(\
\x0b2\x14.KompactRegistrationH\0R\x13kompactRegistration\x12\x1e\n\x05he\
llo\x18\x02\x20\x01(\x0b2\x06.HelloH\0R\x05hello\x12\x18\n\x03ask\x18\
\x03\x20\x01(\x0b2\x04.AskH\0R\x03ask\x12'\n\x08askReply\x18\x04\x20\x01\
(\x0b2\t.AskReplyH\0R\x08askReply\x12<\n\x0fsnapshotRequest\x18\x05\x20\
\x01(\x0b2\x10.SnapshotRequestH\0R\x0fsnapshotRequestB\t\n\x07payload\"\
\x80\x01\n\x13KompactAkkaEnvelope\x12\"\n\x03src\x18\x01\x20\x01(\x0b2\
\x10.KompactAkkaPathR\x03src\x12\"\n\x03dst\x18\x02\x20\x01(\x0b2\x10.Ko\
mpactAkkaPathR\x03dst\x12!\n\x03msg\x18\x03\x20\x01(\x0b2\x0f.KompactAkk\
aMsgR\x03msgB\t\n\x07kompactb\x06proto3\
";
static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
lock: ::protobuf::lazy::ONCE_INIT,
ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto,
};
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
unsafe {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}
}