coerce/remote/net/proto/
network.rs

1// This file is generated by rust-protobuf 3.2.0. Do not edit
2// .proto file is parsed by protoc 3.13.0
3// @generated
4
5// https://github.com/rust-lang/rust-clippy/issues/702
6#![allow(unknown_lints)]
7#![allow(clippy::all)]
8
9#![allow(unused_attributes)]
10#![cfg_attr(rustfmt, rustfmt::skip)]
11
12#![allow(box_pointers)]
13#![allow(dead_code)]
14#![allow(missing_docs)]
15#![allow(non_camel_case_types)]
16#![allow(non_snake_case)]
17#![allow(non_upper_case_globals)]
18#![allow(trivial_casts)]
19#![allow(unused_results)]
20#![allow(unused_mut)]
21
22//! Generated file from `network.proto`
23
24/// Generated files are compatible only with the same version
25/// of protobuf runtime.
26const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_2_0;
27
28#[derive(PartialEq,Clone,Default,Debug)]
29// @@protoc_insertion_point(message:coerce.network.RemoteNode)
30pub struct RemoteNode {
31    // message fields
32    // @@protoc_insertion_point(field:coerce.network.RemoteNode.node_id)
33    pub node_id: u64,
34    // @@protoc_insertion_point(field:coerce.network.RemoteNode.addr)
35    pub addr: ::std::string::String,
36    // @@protoc_insertion_point(field:coerce.network.RemoteNode.node_started_at)
37    pub node_started_at: ::protobuf::MessageField<::protobuf::well_known_types::timestamp::Timestamp>,
38    // @@protoc_insertion_point(field:coerce.network.RemoteNode.tag)
39    pub tag: ::std::string::String,
40    // @@protoc_insertion_point(field:coerce.network.RemoteNode.attributes)
41    pub attributes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
42    // special fields
43    // @@protoc_insertion_point(special_field:coerce.network.RemoteNode.special_fields)
44    pub special_fields: ::protobuf::SpecialFields,
45}
46
47impl<'a> ::std::default::Default for &'a RemoteNode {
48    fn default() -> &'a RemoteNode {
49        <RemoteNode as ::protobuf::Message>::default_instance()
50    }
51}
52
53impl RemoteNode {
54    pub fn new() -> RemoteNode {
55        ::std::default::Default::default()
56    }
57
58    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
59        let mut fields = ::std::vec::Vec::with_capacity(5);
60        let mut oneofs = ::std::vec::Vec::with_capacity(0);
61        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
62            "node_id",
63            |m: &RemoteNode| { &m.node_id },
64            |m: &mut RemoteNode| { &mut m.node_id },
65        ));
66        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
67            "addr",
68            |m: &RemoteNode| { &m.addr },
69            |m: &mut RemoteNode| { &mut m.addr },
70        ));
71        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, ::protobuf::well_known_types::timestamp::Timestamp>(
72            "node_started_at",
73            |m: &RemoteNode| { &m.node_started_at },
74            |m: &mut RemoteNode| { &mut m.node_started_at },
75        ));
76        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
77            "tag",
78            |m: &RemoteNode| { &m.tag },
79            |m: &mut RemoteNode| { &mut m.tag },
80        ));
81        fields.push(::protobuf::reflect::rt::v2::make_map_simpler_accessor::<_, _, _>(
82            "attributes",
83            |m: &RemoteNode| { &m.attributes },
84            |m: &mut RemoteNode| { &mut m.attributes },
85        ));
86        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RemoteNode>(
87            "RemoteNode",
88            fields,
89            oneofs,
90        )
91    }
92}
93
94impl ::protobuf::Message for RemoteNode {
95    const NAME: &'static str = "RemoteNode";
96
97    fn is_initialized(&self) -> bool {
98        true
99    }
100
101    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
102        while let Some(tag) = is.read_raw_tag_or_eof()? {
103            match tag {
104                8 => {
105                    self.node_id = is.read_uint64()?;
106                },
107                18 => {
108                    self.addr = is.read_string()?;
109                },
110                26 => {
111                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.node_started_at)?;
112                },
113                34 => {
114                    self.tag = is.read_string()?;
115                },
116                42 => {
117                    let len = is.read_raw_varint32()?;
118                    let old_limit = is.push_limit(len as u64)?;
119                    let mut key = ::std::default::Default::default();
120                    let mut value = ::std::default::Default::default();
121                    while let Some(tag) = is.read_raw_tag_or_eof()? {
122                        match tag {
123                            10 => key = is.read_string()?,
124                            18 => value = is.read_string()?,
125                            _ => ::protobuf::rt::skip_field_for_tag(tag, is)?,
126                        };
127                    }
128                    is.pop_limit(old_limit);
129                    self.attributes.insert(key, value);
130                },
131                tag => {
132                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
133                },
134            };
135        }
136        ::std::result::Result::Ok(())
137    }
138
139    // Compute sizes of nested messages
140    #[allow(unused_variables)]
141    fn compute_size(&self) -> u64 {
142        let mut my_size = 0;
143        if self.node_id != 0 {
144            my_size += ::protobuf::rt::uint64_size(1, self.node_id);
145        }
146        if !self.addr.is_empty() {
147            my_size += ::protobuf::rt::string_size(2, &self.addr);
148        }
149        if let Some(v) = self.node_started_at.as_ref() {
150            let len = v.compute_size();
151            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
152        }
153        if !self.tag.is_empty() {
154            my_size += ::protobuf::rt::string_size(4, &self.tag);
155        }
156        for (k, v) in &self.attributes {
157            let mut entry_size = 0;
158            entry_size += ::protobuf::rt::string_size(1, &k);
159            entry_size += ::protobuf::rt::string_size(2, &v);
160            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(entry_size) + entry_size
161        };
162        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
163        self.special_fields.cached_size().set(my_size as u32);
164        my_size
165    }
166
167    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
168        if self.node_id != 0 {
169            os.write_uint64(1, self.node_id)?;
170        }
171        if !self.addr.is_empty() {
172            os.write_string(2, &self.addr)?;
173        }
174        if let Some(v) = self.node_started_at.as_ref() {
175            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
176        }
177        if !self.tag.is_empty() {
178            os.write_string(4, &self.tag)?;
179        }
180        for (k, v) in &self.attributes {
181            let mut entry_size = 0;
182            entry_size += ::protobuf::rt::string_size(1, &k);
183            entry_size += ::protobuf::rt::string_size(2, &v);
184            os.write_raw_varint32(42)?; // Tag.
185            os.write_raw_varint32(entry_size as u32)?;
186            os.write_string(1, &k)?;
187            os.write_string(2, &v)?;
188        };
189        os.write_unknown_fields(self.special_fields.unknown_fields())?;
190        ::std::result::Result::Ok(())
191    }
192
193    fn special_fields(&self) -> &::protobuf::SpecialFields {
194        &self.special_fields
195    }
196
197    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
198        &mut self.special_fields
199    }
200
201    fn new() -> RemoteNode {
202        RemoteNode::new()
203    }
204
205    fn clear(&mut self) {
206        self.node_id = 0;
207        self.addr.clear();
208        self.node_started_at.clear();
209        self.tag.clear();
210        self.attributes.clear();
211        self.special_fields.clear();
212    }
213
214    fn default_instance() -> &'static RemoteNode {
215        static instance: ::protobuf::rt::Lazy<RemoteNode> = ::protobuf::rt::Lazy::new();
216        instance.get(RemoteNode::new)
217    }
218}
219
220impl ::protobuf::MessageFull for RemoteNode {
221    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
222        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
223        descriptor.get(|| file_descriptor().message_by_package_relative_name("RemoteNode").unwrap()).clone()
224    }
225}
226
227impl ::std::fmt::Display for RemoteNode {
228    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
229        ::protobuf::text_format::fmt(self, f)
230    }
231}
232
233impl ::protobuf::reflect::ProtobufValue for RemoteNode {
234    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
235}
236
237#[derive(PartialEq,Clone,Default,Debug)]
238// @@protoc_insertion_point(message:coerce.network.IdentifyEvent)
239pub struct IdentifyEvent {
240    // message fields
241    // @@protoc_insertion_point(field:coerce.network.IdentifyEvent.source_node_id)
242    pub source_node_id: u64,
243    // @@protoc_insertion_point(field:coerce.network.IdentifyEvent.source_node_tag)
244    pub source_node_tag: ::std::string::String,
245    // @@protoc_insertion_point(field:coerce.network.IdentifyEvent.token)
246    pub token: ::std::string::String,
247    // special fields
248    // @@protoc_insertion_point(special_field:coerce.network.IdentifyEvent.special_fields)
249    pub special_fields: ::protobuf::SpecialFields,
250}
251
252impl<'a> ::std::default::Default for &'a IdentifyEvent {
253    fn default() -> &'a IdentifyEvent {
254        <IdentifyEvent as ::protobuf::Message>::default_instance()
255    }
256}
257
258impl IdentifyEvent {
259    pub fn new() -> IdentifyEvent {
260        ::std::default::Default::default()
261    }
262
263    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
264        let mut fields = ::std::vec::Vec::with_capacity(3);
265        let mut oneofs = ::std::vec::Vec::with_capacity(0);
266        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
267            "source_node_id",
268            |m: &IdentifyEvent| { &m.source_node_id },
269            |m: &mut IdentifyEvent| { &mut m.source_node_id },
270        ));
271        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
272            "source_node_tag",
273            |m: &IdentifyEvent| { &m.source_node_tag },
274            |m: &mut IdentifyEvent| { &mut m.source_node_tag },
275        ));
276        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
277            "token",
278            |m: &IdentifyEvent| { &m.token },
279            |m: &mut IdentifyEvent| { &mut m.token },
280        ));
281        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<IdentifyEvent>(
282            "IdentifyEvent",
283            fields,
284            oneofs,
285        )
286    }
287}
288
289impl ::protobuf::Message for IdentifyEvent {
290    const NAME: &'static str = "IdentifyEvent";
291
292    fn is_initialized(&self) -> bool {
293        true
294    }
295
296    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
297        while let Some(tag) = is.read_raw_tag_or_eof()? {
298            match tag {
299                8 => {
300                    self.source_node_id = is.read_uint64()?;
301                },
302                18 => {
303                    self.source_node_tag = is.read_string()?;
304                },
305                26 => {
306                    self.token = is.read_string()?;
307                },
308                tag => {
309                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
310                },
311            };
312        }
313        ::std::result::Result::Ok(())
314    }
315
316    // Compute sizes of nested messages
317    #[allow(unused_variables)]
318    fn compute_size(&self) -> u64 {
319        let mut my_size = 0;
320        if self.source_node_id != 0 {
321            my_size += ::protobuf::rt::uint64_size(1, self.source_node_id);
322        }
323        if !self.source_node_tag.is_empty() {
324            my_size += ::protobuf::rt::string_size(2, &self.source_node_tag);
325        }
326        if !self.token.is_empty() {
327            my_size += ::protobuf::rt::string_size(3, &self.token);
328        }
329        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
330        self.special_fields.cached_size().set(my_size as u32);
331        my_size
332    }
333
334    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
335        if self.source_node_id != 0 {
336            os.write_uint64(1, self.source_node_id)?;
337        }
338        if !self.source_node_tag.is_empty() {
339            os.write_string(2, &self.source_node_tag)?;
340        }
341        if !self.token.is_empty() {
342            os.write_string(3, &self.token)?;
343        }
344        os.write_unknown_fields(self.special_fields.unknown_fields())?;
345        ::std::result::Result::Ok(())
346    }
347
348    fn special_fields(&self) -> &::protobuf::SpecialFields {
349        &self.special_fields
350    }
351
352    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
353        &mut self.special_fields
354    }
355
356    fn new() -> IdentifyEvent {
357        IdentifyEvent::new()
358    }
359
360    fn clear(&mut self) {
361        self.source_node_id = 0;
362        self.source_node_tag.clear();
363        self.token.clear();
364        self.special_fields.clear();
365    }
366
367    fn default_instance() -> &'static IdentifyEvent {
368        static instance: IdentifyEvent = IdentifyEvent {
369            source_node_id: 0,
370            source_node_tag: ::std::string::String::new(),
371            token: ::std::string::String::new(),
372            special_fields: ::protobuf::SpecialFields::new(),
373        };
374        &instance
375    }
376}
377
378impl ::protobuf::MessageFull for IdentifyEvent {
379    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
380        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
381        descriptor.get(|| file_descriptor().message_by_package_relative_name("IdentifyEvent").unwrap()).clone()
382    }
383}
384
385impl ::std::fmt::Display for IdentifyEvent {
386    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
387        ::protobuf::text_format::fmt(self, f)
388    }
389}
390
391impl ::protobuf::reflect::ProtobufValue for IdentifyEvent {
392    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
393}
394
395#[derive(PartialEq,Clone,Default,Debug)]
396// @@protoc_insertion_point(message:coerce.network.NodeIdentity)
397pub struct NodeIdentity {
398    // message fields
399    // @@protoc_insertion_point(field:coerce.network.NodeIdentity.node_id)
400    pub node_id: u64,
401    // @@protoc_insertion_point(field:coerce.network.NodeIdentity.node_tag)
402    pub node_tag: ::std::string::String,
403    // @@protoc_insertion_point(field:coerce.network.NodeIdentity.addr)
404    pub addr: ::std::string::String,
405    // @@protoc_insertion_point(field:coerce.network.NodeIdentity.application_version)
406    pub application_version: ::std::string::String,
407    // @@protoc_insertion_point(field:coerce.network.NodeIdentity.protocol_version)
408    pub protocol_version: ::std::string::String,
409    // @@protoc_insertion_point(field:coerce.network.NodeIdentity.node_started_at)
410    pub node_started_at: ::protobuf::MessageField<::protobuf::well_known_types::timestamp::Timestamp>,
411    // @@protoc_insertion_point(field:coerce.network.NodeIdentity.peers)
412    pub peers: ::std::vec::Vec<RemoteNode>,
413    // @@protoc_insertion_point(field:coerce.network.NodeIdentity.capabilities)
414    pub capabilities: ::protobuf::MessageField<SystemCapabilities>,
415    // @@protoc_insertion_point(field:coerce.network.NodeIdentity.attributes)
416    pub attributes: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
417    // special fields
418    // @@protoc_insertion_point(special_field:coerce.network.NodeIdentity.special_fields)
419    pub special_fields: ::protobuf::SpecialFields,
420}
421
422impl<'a> ::std::default::Default for &'a NodeIdentity {
423    fn default() -> &'a NodeIdentity {
424        <NodeIdentity as ::protobuf::Message>::default_instance()
425    }
426}
427
428impl NodeIdentity {
429    pub fn new() -> NodeIdentity {
430        ::std::default::Default::default()
431    }
432
433    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
434        let mut fields = ::std::vec::Vec::with_capacity(9);
435        let mut oneofs = ::std::vec::Vec::with_capacity(0);
436        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
437            "node_id",
438            |m: &NodeIdentity| { &m.node_id },
439            |m: &mut NodeIdentity| { &mut m.node_id },
440        ));
441        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
442            "node_tag",
443            |m: &NodeIdentity| { &m.node_tag },
444            |m: &mut NodeIdentity| { &mut m.node_tag },
445        ));
446        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
447            "addr",
448            |m: &NodeIdentity| { &m.addr },
449            |m: &mut NodeIdentity| { &mut m.addr },
450        ));
451        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
452            "application_version",
453            |m: &NodeIdentity| { &m.application_version },
454            |m: &mut NodeIdentity| { &mut m.application_version },
455        ));
456        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
457            "protocol_version",
458            |m: &NodeIdentity| { &m.protocol_version },
459            |m: &mut NodeIdentity| { &mut m.protocol_version },
460        ));
461        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, ::protobuf::well_known_types::timestamp::Timestamp>(
462            "node_started_at",
463            |m: &NodeIdentity| { &m.node_started_at },
464            |m: &mut NodeIdentity| { &mut m.node_started_at },
465        ));
466        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
467            "peers",
468            |m: &NodeIdentity| { &m.peers },
469            |m: &mut NodeIdentity| { &mut m.peers },
470        ));
471        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, SystemCapabilities>(
472            "capabilities",
473            |m: &NodeIdentity| { &m.capabilities },
474            |m: &mut NodeIdentity| { &mut m.capabilities },
475        ));
476        fields.push(::protobuf::reflect::rt::v2::make_map_simpler_accessor::<_, _, _>(
477            "attributes",
478            |m: &NodeIdentity| { &m.attributes },
479            |m: &mut NodeIdentity| { &mut m.attributes },
480        ));
481        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<NodeIdentity>(
482            "NodeIdentity",
483            fields,
484            oneofs,
485        )
486    }
487}
488
489impl ::protobuf::Message for NodeIdentity {
490    const NAME: &'static str = "NodeIdentity";
491
492    fn is_initialized(&self) -> bool {
493        true
494    }
495
496    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
497        while let Some(tag) = is.read_raw_tag_or_eof()? {
498            match tag {
499                8 => {
500                    self.node_id = is.read_uint64()?;
501                },
502                18 => {
503                    self.node_tag = is.read_string()?;
504                },
505                26 => {
506                    self.addr = is.read_string()?;
507                },
508                34 => {
509                    self.application_version = is.read_string()?;
510                },
511                42 => {
512                    self.protocol_version = is.read_string()?;
513                },
514                50 => {
515                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.node_started_at)?;
516                },
517                58 => {
518                    self.peers.push(is.read_message()?);
519                },
520                66 => {
521                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.capabilities)?;
522                },
523                74 => {
524                    let len = is.read_raw_varint32()?;
525                    let old_limit = is.push_limit(len as u64)?;
526                    let mut key = ::std::default::Default::default();
527                    let mut value = ::std::default::Default::default();
528                    while let Some(tag) = is.read_raw_tag_or_eof()? {
529                        match tag {
530                            10 => key = is.read_string()?,
531                            18 => value = is.read_string()?,
532                            _ => ::protobuf::rt::skip_field_for_tag(tag, is)?,
533                        };
534                    }
535                    is.pop_limit(old_limit);
536                    self.attributes.insert(key, value);
537                },
538                tag => {
539                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
540                },
541            };
542        }
543        ::std::result::Result::Ok(())
544    }
545
546    // Compute sizes of nested messages
547    #[allow(unused_variables)]
548    fn compute_size(&self) -> u64 {
549        let mut my_size = 0;
550        if self.node_id != 0 {
551            my_size += ::protobuf::rt::uint64_size(1, self.node_id);
552        }
553        if !self.node_tag.is_empty() {
554            my_size += ::protobuf::rt::string_size(2, &self.node_tag);
555        }
556        if !self.addr.is_empty() {
557            my_size += ::protobuf::rt::string_size(3, &self.addr);
558        }
559        if !self.application_version.is_empty() {
560            my_size += ::protobuf::rt::string_size(4, &self.application_version);
561        }
562        if !self.protocol_version.is_empty() {
563            my_size += ::protobuf::rt::string_size(5, &self.protocol_version);
564        }
565        if let Some(v) = self.node_started_at.as_ref() {
566            let len = v.compute_size();
567            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
568        }
569        for value in &self.peers {
570            let len = value.compute_size();
571            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
572        };
573        if let Some(v) = self.capabilities.as_ref() {
574            let len = v.compute_size();
575            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
576        }
577        for (k, v) in &self.attributes {
578            let mut entry_size = 0;
579            entry_size += ::protobuf::rt::string_size(1, &k);
580            entry_size += ::protobuf::rt::string_size(2, &v);
581            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(entry_size) + entry_size
582        };
583        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
584        self.special_fields.cached_size().set(my_size as u32);
585        my_size
586    }
587
588    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
589        if self.node_id != 0 {
590            os.write_uint64(1, self.node_id)?;
591        }
592        if !self.node_tag.is_empty() {
593            os.write_string(2, &self.node_tag)?;
594        }
595        if !self.addr.is_empty() {
596            os.write_string(3, &self.addr)?;
597        }
598        if !self.application_version.is_empty() {
599            os.write_string(4, &self.application_version)?;
600        }
601        if !self.protocol_version.is_empty() {
602            os.write_string(5, &self.protocol_version)?;
603        }
604        if let Some(v) = self.node_started_at.as_ref() {
605            ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
606        }
607        for v in &self.peers {
608            ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
609        };
610        if let Some(v) = self.capabilities.as_ref() {
611            ::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
612        }
613        for (k, v) in &self.attributes {
614            let mut entry_size = 0;
615            entry_size += ::protobuf::rt::string_size(1, &k);
616            entry_size += ::protobuf::rt::string_size(2, &v);
617            os.write_raw_varint32(74)?; // Tag.
618            os.write_raw_varint32(entry_size as u32)?;
619            os.write_string(1, &k)?;
620            os.write_string(2, &v)?;
621        };
622        os.write_unknown_fields(self.special_fields.unknown_fields())?;
623        ::std::result::Result::Ok(())
624    }
625
626    fn special_fields(&self) -> &::protobuf::SpecialFields {
627        &self.special_fields
628    }
629
630    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
631        &mut self.special_fields
632    }
633
634    fn new() -> NodeIdentity {
635        NodeIdentity::new()
636    }
637
638    fn clear(&mut self) {
639        self.node_id = 0;
640        self.node_tag.clear();
641        self.addr.clear();
642        self.application_version.clear();
643        self.protocol_version.clear();
644        self.node_started_at.clear();
645        self.peers.clear();
646        self.capabilities.clear();
647        self.attributes.clear();
648        self.special_fields.clear();
649    }
650
651    fn default_instance() -> &'static NodeIdentity {
652        static instance: ::protobuf::rt::Lazy<NodeIdentity> = ::protobuf::rt::Lazy::new();
653        instance.get(NodeIdentity::new)
654    }
655}
656
657impl ::protobuf::MessageFull for NodeIdentity {
658    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
659        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
660        descriptor.get(|| file_descriptor().message_by_package_relative_name("NodeIdentity").unwrap()).clone()
661    }
662}
663
664impl ::std::fmt::Display for NodeIdentity {
665    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
666        ::protobuf::text_format::fmt(self, f)
667    }
668}
669
670impl ::protobuf::reflect::ProtobufValue for NodeIdentity {
671    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
672}
673
674#[derive(PartialEq,Clone,Default,Debug)]
675// @@protoc_insertion_point(message:coerce.network.SystemCapabilities)
676pub struct SystemCapabilities {
677    // message fields
678    // @@protoc_insertion_point(field:coerce.network.SystemCapabilities.actors)
679    pub actors: ::std::vec::Vec<::std::string::String>,
680    // @@protoc_insertion_point(field:coerce.network.SystemCapabilities.messages)
681    pub messages: ::std::vec::Vec<::std::string::String>,
682    // special fields
683    // @@protoc_insertion_point(special_field:coerce.network.SystemCapabilities.special_fields)
684    pub special_fields: ::protobuf::SpecialFields,
685}
686
687impl<'a> ::std::default::Default for &'a SystemCapabilities {
688    fn default() -> &'a SystemCapabilities {
689        <SystemCapabilities as ::protobuf::Message>::default_instance()
690    }
691}
692
693impl SystemCapabilities {
694    pub fn new() -> SystemCapabilities {
695        ::std::default::Default::default()
696    }
697
698    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
699        let mut fields = ::std::vec::Vec::with_capacity(2);
700        let mut oneofs = ::std::vec::Vec::with_capacity(0);
701        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
702            "actors",
703            |m: &SystemCapabilities| { &m.actors },
704            |m: &mut SystemCapabilities| { &mut m.actors },
705        ));
706        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
707            "messages",
708            |m: &SystemCapabilities| { &m.messages },
709            |m: &mut SystemCapabilities| { &mut m.messages },
710        ));
711        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SystemCapabilities>(
712            "SystemCapabilities",
713            fields,
714            oneofs,
715        )
716    }
717}
718
719impl ::protobuf::Message for SystemCapabilities {
720    const NAME: &'static str = "SystemCapabilities";
721
722    fn is_initialized(&self) -> bool {
723        true
724    }
725
726    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
727        while let Some(tag) = is.read_raw_tag_or_eof()? {
728            match tag {
729                10 => {
730                    self.actors.push(is.read_string()?);
731                },
732                18 => {
733                    self.messages.push(is.read_string()?);
734                },
735                tag => {
736                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
737                },
738            };
739        }
740        ::std::result::Result::Ok(())
741    }
742
743    // Compute sizes of nested messages
744    #[allow(unused_variables)]
745    fn compute_size(&self) -> u64 {
746        let mut my_size = 0;
747        for value in &self.actors {
748            my_size += ::protobuf::rt::string_size(1, &value);
749        };
750        for value in &self.messages {
751            my_size += ::protobuf::rt::string_size(2, &value);
752        };
753        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
754        self.special_fields.cached_size().set(my_size as u32);
755        my_size
756    }
757
758    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
759        for v in &self.actors {
760            os.write_string(1, &v)?;
761        };
762        for v in &self.messages {
763            os.write_string(2, &v)?;
764        };
765        os.write_unknown_fields(self.special_fields.unknown_fields())?;
766        ::std::result::Result::Ok(())
767    }
768
769    fn special_fields(&self) -> &::protobuf::SpecialFields {
770        &self.special_fields
771    }
772
773    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
774        &mut self.special_fields
775    }
776
777    fn new() -> SystemCapabilities {
778        SystemCapabilities::new()
779    }
780
781    fn clear(&mut self) {
782        self.actors.clear();
783        self.messages.clear();
784        self.special_fields.clear();
785    }
786
787    fn default_instance() -> &'static SystemCapabilities {
788        static instance: SystemCapabilities = SystemCapabilities {
789            actors: ::std::vec::Vec::new(),
790            messages: ::std::vec::Vec::new(),
791            special_fields: ::protobuf::SpecialFields::new(),
792        };
793        &instance
794    }
795}
796
797impl ::protobuf::MessageFull for SystemCapabilities {
798    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
799        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
800        descriptor.get(|| file_descriptor().message_by_package_relative_name("SystemCapabilities").unwrap()).clone()
801    }
802}
803
804impl ::std::fmt::Display for SystemCapabilities {
805    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
806        ::protobuf::text_format::fmt(self, f)
807    }
808}
809
810impl ::protobuf::reflect::ProtobufValue for SystemCapabilities {
811    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
812}
813
814#[derive(PartialEq,Clone,Default,Debug)]
815// @@protoc_insertion_point(message:coerce.network.ClientHandshake)
816pub struct ClientHandshake {
817    // message fields
818    // @@protoc_insertion_point(field:coerce.network.ClientHandshake.node_id)
819    pub node_id: u64,
820    // @@protoc_insertion_point(field:coerce.network.ClientHandshake.nodes)
821    pub nodes: ::std::vec::Vec<RemoteNode>,
822    // @@protoc_insertion_point(field:coerce.network.ClientHandshake.node_tag)
823    pub node_tag: ::std::string::String,
824    // @@protoc_insertion_point(field:coerce.network.ClientHandshake.trace_id)
825    pub trace_id: ::std::string::String,
826    // @@protoc_insertion_point(field:coerce.network.ClientHandshake.node_started_at)
827    pub node_started_at: ::protobuf::MessageField<::protobuf::well_known_types::timestamp::Timestamp>,
828    // special fields
829    // @@protoc_insertion_point(special_field:coerce.network.ClientHandshake.special_fields)
830    pub special_fields: ::protobuf::SpecialFields,
831}
832
833impl<'a> ::std::default::Default for &'a ClientHandshake {
834    fn default() -> &'a ClientHandshake {
835        <ClientHandshake as ::protobuf::Message>::default_instance()
836    }
837}
838
839impl ClientHandshake {
840    pub fn new() -> ClientHandshake {
841        ::std::default::Default::default()
842    }
843
844    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
845        let mut fields = ::std::vec::Vec::with_capacity(5);
846        let mut oneofs = ::std::vec::Vec::with_capacity(0);
847        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
848            "node_id",
849            |m: &ClientHandshake| { &m.node_id },
850            |m: &mut ClientHandshake| { &mut m.node_id },
851        ));
852        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
853            "nodes",
854            |m: &ClientHandshake| { &m.nodes },
855            |m: &mut ClientHandshake| { &mut m.nodes },
856        ));
857        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
858            "node_tag",
859            |m: &ClientHandshake| { &m.node_tag },
860            |m: &mut ClientHandshake| { &mut m.node_tag },
861        ));
862        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
863            "trace_id",
864            |m: &ClientHandshake| { &m.trace_id },
865            |m: &mut ClientHandshake| { &mut m.trace_id },
866        ));
867        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, ::protobuf::well_known_types::timestamp::Timestamp>(
868            "node_started_at",
869            |m: &ClientHandshake| { &m.node_started_at },
870            |m: &mut ClientHandshake| { &mut m.node_started_at },
871        ));
872        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ClientHandshake>(
873            "ClientHandshake",
874            fields,
875            oneofs,
876        )
877    }
878}
879
880impl ::protobuf::Message for ClientHandshake {
881    const NAME: &'static str = "ClientHandshake";
882
883    fn is_initialized(&self) -> bool {
884        true
885    }
886
887    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
888        while let Some(tag) = is.read_raw_tag_or_eof()? {
889            match tag {
890                8 => {
891                    self.node_id = is.read_uint64()?;
892                },
893                18 => {
894                    self.nodes.push(is.read_message()?);
895                },
896                26 => {
897                    self.node_tag = is.read_string()?;
898                },
899                34 => {
900                    self.trace_id = is.read_string()?;
901                },
902                42 => {
903                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.node_started_at)?;
904                },
905                tag => {
906                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
907                },
908            };
909        }
910        ::std::result::Result::Ok(())
911    }
912
913    // Compute sizes of nested messages
914    #[allow(unused_variables)]
915    fn compute_size(&self) -> u64 {
916        let mut my_size = 0;
917        if self.node_id != 0 {
918            my_size += ::protobuf::rt::uint64_size(1, self.node_id);
919        }
920        for value in &self.nodes {
921            let len = value.compute_size();
922            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
923        };
924        if !self.node_tag.is_empty() {
925            my_size += ::protobuf::rt::string_size(3, &self.node_tag);
926        }
927        if !self.trace_id.is_empty() {
928            my_size += ::protobuf::rt::string_size(4, &self.trace_id);
929        }
930        if let Some(v) = self.node_started_at.as_ref() {
931            let len = v.compute_size();
932            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
933        }
934        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
935        self.special_fields.cached_size().set(my_size as u32);
936        my_size
937    }
938
939    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
940        if self.node_id != 0 {
941            os.write_uint64(1, self.node_id)?;
942        }
943        for v in &self.nodes {
944            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
945        };
946        if !self.node_tag.is_empty() {
947            os.write_string(3, &self.node_tag)?;
948        }
949        if !self.trace_id.is_empty() {
950            os.write_string(4, &self.trace_id)?;
951        }
952        if let Some(v) = self.node_started_at.as_ref() {
953            ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
954        }
955        os.write_unknown_fields(self.special_fields.unknown_fields())?;
956        ::std::result::Result::Ok(())
957    }
958
959    fn special_fields(&self) -> &::protobuf::SpecialFields {
960        &self.special_fields
961    }
962
963    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
964        &mut self.special_fields
965    }
966
967    fn new() -> ClientHandshake {
968        ClientHandshake::new()
969    }
970
971    fn clear(&mut self) {
972        self.node_id = 0;
973        self.nodes.clear();
974        self.node_tag.clear();
975        self.trace_id.clear();
976        self.node_started_at.clear();
977        self.special_fields.clear();
978    }
979
980    fn default_instance() -> &'static ClientHandshake {
981        static instance: ClientHandshake = ClientHandshake {
982            node_id: 0,
983            nodes: ::std::vec::Vec::new(),
984            node_tag: ::std::string::String::new(),
985            trace_id: ::std::string::String::new(),
986            node_started_at: ::protobuf::MessageField::none(),
987            special_fields: ::protobuf::SpecialFields::new(),
988        };
989        &instance
990    }
991}
992
993impl ::protobuf::MessageFull for ClientHandshake {
994    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
995        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
996        descriptor.get(|| file_descriptor().message_by_package_relative_name("ClientHandshake").unwrap()).clone()
997    }
998}
999
1000impl ::std::fmt::Display for ClientHandshake {
1001    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1002        ::protobuf::text_format::fmt(self, f)
1003    }
1004}
1005
1006impl ::protobuf::reflect::ProtobufValue for ClientHandshake {
1007    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1008}
1009
1010#[derive(PartialEq,Clone,Default,Debug)]
1011// @@protoc_insertion_point(message:coerce.network.ClientResult)
1012pub struct ClientResult {
1013    // message fields
1014    // @@protoc_insertion_point(field:coerce.network.ClientResult.message_id)
1015    pub message_id: ::std::string::String,
1016    // @@protoc_insertion_point(field:coerce.network.ClientResult.result)
1017    pub result: ::std::vec::Vec<u8>,
1018    // @@protoc_insertion_point(field:coerce.network.ClientResult.trace_id)
1019    pub trace_id: ::std::string::String,
1020    // special fields
1021    // @@protoc_insertion_point(special_field:coerce.network.ClientResult.special_fields)
1022    pub special_fields: ::protobuf::SpecialFields,
1023}
1024
1025impl<'a> ::std::default::Default for &'a ClientResult {
1026    fn default() -> &'a ClientResult {
1027        <ClientResult as ::protobuf::Message>::default_instance()
1028    }
1029}
1030
1031impl ClientResult {
1032    pub fn new() -> ClientResult {
1033        ::std::default::Default::default()
1034    }
1035
1036    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1037        let mut fields = ::std::vec::Vec::with_capacity(3);
1038        let mut oneofs = ::std::vec::Vec::with_capacity(0);
1039        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1040            "message_id",
1041            |m: &ClientResult| { &m.message_id },
1042            |m: &mut ClientResult| { &mut m.message_id },
1043        ));
1044        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1045            "result",
1046            |m: &ClientResult| { &m.result },
1047            |m: &mut ClientResult| { &mut m.result },
1048        ));
1049        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1050            "trace_id",
1051            |m: &ClientResult| { &m.trace_id },
1052            |m: &mut ClientResult| { &mut m.trace_id },
1053        ));
1054        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ClientResult>(
1055            "ClientResult",
1056            fields,
1057            oneofs,
1058        )
1059    }
1060}
1061
1062impl ::protobuf::Message for ClientResult {
1063    const NAME: &'static str = "ClientResult";
1064
1065    fn is_initialized(&self) -> bool {
1066        true
1067    }
1068
1069    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1070        while let Some(tag) = is.read_raw_tag_or_eof()? {
1071            match tag {
1072                10 => {
1073                    self.message_id = is.read_string()?;
1074                },
1075                18 => {
1076                    self.result = is.read_bytes()?;
1077                },
1078                26 => {
1079                    self.trace_id = is.read_string()?;
1080                },
1081                tag => {
1082                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1083                },
1084            };
1085        }
1086        ::std::result::Result::Ok(())
1087    }
1088
1089    // Compute sizes of nested messages
1090    #[allow(unused_variables)]
1091    fn compute_size(&self) -> u64 {
1092        let mut my_size = 0;
1093        if !self.message_id.is_empty() {
1094            my_size += ::protobuf::rt::string_size(1, &self.message_id);
1095        }
1096        if !self.result.is_empty() {
1097            my_size += ::protobuf::rt::bytes_size(2, &self.result);
1098        }
1099        if !self.trace_id.is_empty() {
1100            my_size += ::protobuf::rt::string_size(3, &self.trace_id);
1101        }
1102        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1103        self.special_fields.cached_size().set(my_size as u32);
1104        my_size
1105    }
1106
1107    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1108        if !self.message_id.is_empty() {
1109            os.write_string(1, &self.message_id)?;
1110        }
1111        if !self.result.is_empty() {
1112            os.write_bytes(2, &self.result)?;
1113        }
1114        if !self.trace_id.is_empty() {
1115            os.write_string(3, &self.trace_id)?;
1116        }
1117        os.write_unknown_fields(self.special_fields.unknown_fields())?;
1118        ::std::result::Result::Ok(())
1119    }
1120
1121    fn special_fields(&self) -> &::protobuf::SpecialFields {
1122        &self.special_fields
1123    }
1124
1125    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1126        &mut self.special_fields
1127    }
1128
1129    fn new() -> ClientResult {
1130        ClientResult::new()
1131    }
1132
1133    fn clear(&mut self) {
1134        self.message_id.clear();
1135        self.result.clear();
1136        self.trace_id.clear();
1137        self.special_fields.clear();
1138    }
1139
1140    fn default_instance() -> &'static ClientResult {
1141        static instance: ClientResult = ClientResult {
1142            message_id: ::std::string::String::new(),
1143            result: ::std::vec::Vec::new(),
1144            trace_id: ::std::string::String::new(),
1145            special_fields: ::protobuf::SpecialFields::new(),
1146        };
1147        &instance
1148    }
1149}
1150
1151impl ::protobuf::MessageFull for ClientResult {
1152    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1153        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1154        descriptor.get(|| file_descriptor().message_by_package_relative_name("ClientResult").unwrap()).clone()
1155    }
1156}
1157
1158impl ::std::fmt::Display for ClientResult {
1159    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1160        ::protobuf::text_format::fmt(self, f)
1161    }
1162}
1163
1164impl ::protobuf::reflect::ProtobufValue for ClientResult {
1165    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1166}
1167
1168#[derive(PartialEq,Clone,Default,Debug)]
1169// @@protoc_insertion_point(message:coerce.network.ClientErr)
1170pub struct ClientErr {
1171    // message fields
1172    // @@protoc_insertion_point(field:coerce.network.ClientErr.message_id)
1173    pub message_id: ::std::string::String,
1174    // @@protoc_insertion_point(field:coerce.network.ClientErr.error)
1175    pub error: ::protobuf::MessageField<ActorRefErr>,
1176    // @@protoc_insertion_point(field:coerce.network.ClientErr.trace_id)
1177    pub trace_id: ::std::string::String,
1178    // special fields
1179    // @@protoc_insertion_point(special_field:coerce.network.ClientErr.special_fields)
1180    pub special_fields: ::protobuf::SpecialFields,
1181}
1182
1183impl<'a> ::std::default::Default for &'a ClientErr {
1184    fn default() -> &'a ClientErr {
1185        <ClientErr as ::protobuf::Message>::default_instance()
1186    }
1187}
1188
1189impl ClientErr {
1190    pub fn new() -> ClientErr {
1191        ::std::default::Default::default()
1192    }
1193
1194    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1195        let mut fields = ::std::vec::Vec::with_capacity(3);
1196        let mut oneofs = ::std::vec::Vec::with_capacity(0);
1197        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1198            "message_id",
1199            |m: &ClientErr| { &m.message_id },
1200            |m: &mut ClientErr| { &mut m.message_id },
1201        ));
1202        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, ActorRefErr>(
1203            "error",
1204            |m: &ClientErr| { &m.error },
1205            |m: &mut ClientErr| { &mut m.error },
1206        ));
1207        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1208            "trace_id",
1209            |m: &ClientErr| { &m.trace_id },
1210            |m: &mut ClientErr| { &mut m.trace_id },
1211        ));
1212        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ClientErr>(
1213            "ClientErr",
1214            fields,
1215            oneofs,
1216        )
1217    }
1218}
1219
1220impl ::protobuf::Message for ClientErr {
1221    const NAME: &'static str = "ClientErr";
1222
1223    fn is_initialized(&self) -> bool {
1224        true
1225    }
1226
1227    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1228        while let Some(tag) = is.read_raw_tag_or_eof()? {
1229            match tag {
1230                10 => {
1231                    self.message_id = is.read_string()?;
1232                },
1233                18 => {
1234                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.error)?;
1235                },
1236                26 => {
1237                    self.trace_id = is.read_string()?;
1238                },
1239                tag => {
1240                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1241                },
1242            };
1243        }
1244        ::std::result::Result::Ok(())
1245    }
1246
1247    // Compute sizes of nested messages
1248    #[allow(unused_variables)]
1249    fn compute_size(&self) -> u64 {
1250        let mut my_size = 0;
1251        if !self.message_id.is_empty() {
1252            my_size += ::protobuf::rt::string_size(1, &self.message_id);
1253        }
1254        if let Some(v) = self.error.as_ref() {
1255            let len = v.compute_size();
1256            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
1257        }
1258        if !self.trace_id.is_empty() {
1259            my_size += ::protobuf::rt::string_size(3, &self.trace_id);
1260        }
1261        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1262        self.special_fields.cached_size().set(my_size as u32);
1263        my_size
1264    }
1265
1266    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1267        if !self.message_id.is_empty() {
1268            os.write_string(1, &self.message_id)?;
1269        }
1270        if let Some(v) = self.error.as_ref() {
1271            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
1272        }
1273        if !self.trace_id.is_empty() {
1274            os.write_string(3, &self.trace_id)?;
1275        }
1276        os.write_unknown_fields(self.special_fields.unknown_fields())?;
1277        ::std::result::Result::Ok(())
1278    }
1279
1280    fn special_fields(&self) -> &::protobuf::SpecialFields {
1281        &self.special_fields
1282    }
1283
1284    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1285        &mut self.special_fields
1286    }
1287
1288    fn new() -> ClientErr {
1289        ClientErr::new()
1290    }
1291
1292    fn clear(&mut self) {
1293        self.message_id.clear();
1294        self.error.clear();
1295        self.trace_id.clear();
1296        self.special_fields.clear();
1297    }
1298
1299    fn default_instance() -> &'static ClientErr {
1300        static instance: ClientErr = ClientErr {
1301            message_id: ::std::string::String::new(),
1302            error: ::protobuf::MessageField::none(),
1303            trace_id: ::std::string::String::new(),
1304            special_fields: ::protobuf::SpecialFields::new(),
1305        };
1306        &instance
1307    }
1308}
1309
1310impl ::protobuf::MessageFull for ClientErr {
1311    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1312        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1313        descriptor.get(|| file_descriptor().message_by_package_relative_name("ClientErr").unwrap()).clone()
1314    }
1315}
1316
1317impl ::std::fmt::Display for ClientErr {
1318    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1319        ::protobuf::text_format::fmt(self, f)
1320    }
1321}
1322
1323impl ::protobuf::reflect::ProtobufValue for ClientErr {
1324    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1325}
1326
1327#[derive(PartialEq,Clone,Default,Debug)]
1328// @@protoc_insertion_point(message:coerce.network.PingEvent)
1329pub struct PingEvent {
1330    // message fields
1331    // @@protoc_insertion_point(field:coerce.network.PingEvent.message_id)
1332    pub message_id: ::std::string::String,
1333    // @@protoc_insertion_point(field:coerce.network.PingEvent.trace_id)
1334    pub trace_id: ::std::string::String,
1335    // @@protoc_insertion_point(field:coerce.network.PingEvent.node_id)
1336    pub node_id: u64,
1337    // @@protoc_insertion_point(field:coerce.network.PingEvent.system_terminated)
1338    pub system_terminated: bool,
1339    // special fields
1340    // @@protoc_insertion_point(special_field:coerce.network.PingEvent.special_fields)
1341    pub special_fields: ::protobuf::SpecialFields,
1342}
1343
1344impl<'a> ::std::default::Default for &'a PingEvent {
1345    fn default() -> &'a PingEvent {
1346        <PingEvent as ::protobuf::Message>::default_instance()
1347    }
1348}
1349
1350impl PingEvent {
1351    pub fn new() -> PingEvent {
1352        ::std::default::Default::default()
1353    }
1354
1355    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1356        let mut fields = ::std::vec::Vec::with_capacity(4);
1357        let mut oneofs = ::std::vec::Vec::with_capacity(0);
1358        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1359            "message_id",
1360            |m: &PingEvent| { &m.message_id },
1361            |m: &mut PingEvent| { &mut m.message_id },
1362        ));
1363        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1364            "trace_id",
1365            |m: &PingEvent| { &m.trace_id },
1366            |m: &mut PingEvent| { &mut m.trace_id },
1367        ));
1368        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1369            "node_id",
1370            |m: &PingEvent| { &m.node_id },
1371            |m: &mut PingEvent| { &mut m.node_id },
1372        ));
1373        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1374            "system_terminated",
1375            |m: &PingEvent| { &m.system_terminated },
1376            |m: &mut PingEvent| { &mut m.system_terminated },
1377        ));
1378        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PingEvent>(
1379            "PingEvent",
1380            fields,
1381            oneofs,
1382        )
1383    }
1384}
1385
1386impl ::protobuf::Message for PingEvent {
1387    const NAME: &'static str = "PingEvent";
1388
1389    fn is_initialized(&self) -> bool {
1390        true
1391    }
1392
1393    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1394        while let Some(tag) = is.read_raw_tag_or_eof()? {
1395            match tag {
1396                10 => {
1397                    self.message_id = is.read_string()?;
1398                },
1399                18 => {
1400                    self.trace_id = is.read_string()?;
1401                },
1402                24 => {
1403                    self.node_id = is.read_uint64()?;
1404                },
1405                32 => {
1406                    self.system_terminated = is.read_bool()?;
1407                },
1408                tag => {
1409                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1410                },
1411            };
1412        }
1413        ::std::result::Result::Ok(())
1414    }
1415
1416    // Compute sizes of nested messages
1417    #[allow(unused_variables)]
1418    fn compute_size(&self) -> u64 {
1419        let mut my_size = 0;
1420        if !self.message_id.is_empty() {
1421            my_size += ::protobuf::rt::string_size(1, &self.message_id);
1422        }
1423        if !self.trace_id.is_empty() {
1424            my_size += ::protobuf::rt::string_size(2, &self.trace_id);
1425        }
1426        if self.node_id != 0 {
1427            my_size += ::protobuf::rt::uint64_size(3, self.node_id);
1428        }
1429        if self.system_terminated != false {
1430            my_size += 1 + 1;
1431        }
1432        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1433        self.special_fields.cached_size().set(my_size as u32);
1434        my_size
1435    }
1436
1437    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1438        if !self.message_id.is_empty() {
1439            os.write_string(1, &self.message_id)?;
1440        }
1441        if !self.trace_id.is_empty() {
1442            os.write_string(2, &self.trace_id)?;
1443        }
1444        if self.node_id != 0 {
1445            os.write_uint64(3, self.node_id)?;
1446        }
1447        if self.system_terminated != false {
1448            os.write_bool(4, self.system_terminated)?;
1449        }
1450        os.write_unknown_fields(self.special_fields.unknown_fields())?;
1451        ::std::result::Result::Ok(())
1452    }
1453
1454    fn special_fields(&self) -> &::protobuf::SpecialFields {
1455        &self.special_fields
1456    }
1457
1458    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1459        &mut self.special_fields
1460    }
1461
1462    fn new() -> PingEvent {
1463        PingEvent::new()
1464    }
1465
1466    fn clear(&mut self) {
1467        self.message_id.clear();
1468        self.trace_id.clear();
1469        self.node_id = 0;
1470        self.system_terminated = false;
1471        self.special_fields.clear();
1472    }
1473
1474    fn default_instance() -> &'static PingEvent {
1475        static instance: PingEvent = PingEvent {
1476            message_id: ::std::string::String::new(),
1477            trace_id: ::std::string::String::new(),
1478            node_id: 0,
1479            system_terminated: false,
1480            special_fields: ::protobuf::SpecialFields::new(),
1481        };
1482        &instance
1483    }
1484}
1485
1486impl ::protobuf::MessageFull for PingEvent {
1487    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1488        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1489        descriptor.get(|| file_descriptor().message_by_package_relative_name("PingEvent").unwrap()).clone()
1490    }
1491}
1492
1493impl ::std::fmt::Display for PingEvent {
1494    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1495        ::protobuf::text_format::fmt(self, f)
1496    }
1497}
1498
1499impl ::protobuf::reflect::ProtobufValue for PingEvent {
1500    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1501}
1502
1503#[derive(PartialEq,Clone,Default,Debug)]
1504// @@protoc_insertion_point(message:coerce.network.PongEvent)
1505pub struct PongEvent {
1506    // message fields
1507    // @@protoc_insertion_point(field:coerce.network.PongEvent.message_id)
1508    pub message_id: ::std::string::String,
1509    // @@protoc_insertion_point(field:coerce.network.PongEvent.trace_id)
1510    pub trace_id: ::std::string::String,
1511    // special fields
1512    // @@protoc_insertion_point(special_field:coerce.network.PongEvent.special_fields)
1513    pub special_fields: ::protobuf::SpecialFields,
1514}
1515
1516impl<'a> ::std::default::Default for &'a PongEvent {
1517    fn default() -> &'a PongEvent {
1518        <PongEvent as ::protobuf::Message>::default_instance()
1519    }
1520}
1521
1522impl PongEvent {
1523    pub fn new() -> PongEvent {
1524        ::std::default::Default::default()
1525    }
1526
1527    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1528        let mut fields = ::std::vec::Vec::with_capacity(2);
1529        let mut oneofs = ::std::vec::Vec::with_capacity(0);
1530        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1531            "message_id",
1532            |m: &PongEvent| { &m.message_id },
1533            |m: &mut PongEvent| { &mut m.message_id },
1534        ));
1535        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1536            "trace_id",
1537            |m: &PongEvent| { &m.trace_id },
1538            |m: &mut PongEvent| { &mut m.trace_id },
1539        ));
1540        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PongEvent>(
1541            "PongEvent",
1542            fields,
1543            oneofs,
1544        )
1545    }
1546}
1547
1548impl ::protobuf::Message for PongEvent {
1549    const NAME: &'static str = "PongEvent";
1550
1551    fn is_initialized(&self) -> bool {
1552        true
1553    }
1554
1555    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1556        while let Some(tag) = is.read_raw_tag_or_eof()? {
1557            match tag {
1558                10 => {
1559                    self.message_id = is.read_string()?;
1560                },
1561                18 => {
1562                    self.trace_id = is.read_string()?;
1563                },
1564                tag => {
1565                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1566                },
1567            };
1568        }
1569        ::std::result::Result::Ok(())
1570    }
1571
1572    // Compute sizes of nested messages
1573    #[allow(unused_variables)]
1574    fn compute_size(&self) -> u64 {
1575        let mut my_size = 0;
1576        if !self.message_id.is_empty() {
1577            my_size += ::protobuf::rt::string_size(1, &self.message_id);
1578        }
1579        if !self.trace_id.is_empty() {
1580            my_size += ::protobuf::rt::string_size(2, &self.trace_id);
1581        }
1582        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1583        self.special_fields.cached_size().set(my_size as u32);
1584        my_size
1585    }
1586
1587    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1588        if !self.message_id.is_empty() {
1589            os.write_string(1, &self.message_id)?;
1590        }
1591        if !self.trace_id.is_empty() {
1592            os.write_string(2, &self.trace_id)?;
1593        }
1594        os.write_unknown_fields(self.special_fields.unknown_fields())?;
1595        ::std::result::Result::Ok(())
1596    }
1597
1598    fn special_fields(&self) -> &::protobuf::SpecialFields {
1599        &self.special_fields
1600    }
1601
1602    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1603        &mut self.special_fields
1604    }
1605
1606    fn new() -> PongEvent {
1607        PongEvent::new()
1608    }
1609
1610    fn clear(&mut self) {
1611        self.message_id.clear();
1612        self.trace_id.clear();
1613        self.special_fields.clear();
1614    }
1615
1616    fn default_instance() -> &'static PongEvent {
1617        static instance: PongEvent = PongEvent {
1618            message_id: ::std::string::String::new(),
1619            trace_id: ::std::string::String::new(),
1620            special_fields: ::protobuf::SpecialFields::new(),
1621        };
1622        &instance
1623    }
1624}
1625
1626impl ::protobuf::MessageFull for PongEvent {
1627    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1628        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1629        descriptor.get(|| file_descriptor().message_by_package_relative_name("PongEvent").unwrap()).clone()
1630    }
1631}
1632
1633impl ::std::fmt::Display for PongEvent {
1634    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1635        ::protobuf::text_format::fmt(self, f)
1636    }
1637}
1638
1639impl ::protobuf::reflect::ProtobufValue for PongEvent {
1640    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1641}
1642
1643#[derive(PartialEq,Clone,Default,Debug)]
1644// @@protoc_insertion_point(message:coerce.network.CreateActorEvent)
1645pub struct CreateActorEvent {
1646    // message fields
1647    // @@protoc_insertion_point(field:coerce.network.CreateActorEvent.message_id)
1648    pub message_id: ::std::string::String,
1649    // @@protoc_insertion_point(field:coerce.network.CreateActorEvent.actor_id)
1650    pub actor_id: ::std::string::String,
1651    // @@protoc_insertion_point(field:coerce.network.CreateActorEvent.actor_type)
1652    pub actor_type: ::std::string::String,
1653    // @@protoc_insertion_point(field:coerce.network.CreateActorEvent.recipe)
1654    pub recipe: ::std::vec::Vec<u8>,
1655    // @@protoc_insertion_point(field:coerce.network.CreateActorEvent.trace_id)
1656    pub trace_id: ::std::string::String,
1657    // special fields
1658    // @@protoc_insertion_point(special_field:coerce.network.CreateActorEvent.special_fields)
1659    pub special_fields: ::protobuf::SpecialFields,
1660}
1661
1662impl<'a> ::std::default::Default for &'a CreateActorEvent {
1663    fn default() -> &'a CreateActorEvent {
1664        <CreateActorEvent as ::protobuf::Message>::default_instance()
1665    }
1666}
1667
1668impl CreateActorEvent {
1669    pub fn new() -> CreateActorEvent {
1670        ::std::default::Default::default()
1671    }
1672
1673    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1674        let mut fields = ::std::vec::Vec::with_capacity(5);
1675        let mut oneofs = ::std::vec::Vec::with_capacity(0);
1676        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1677            "message_id",
1678            |m: &CreateActorEvent| { &m.message_id },
1679            |m: &mut CreateActorEvent| { &mut m.message_id },
1680        ));
1681        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1682            "actor_id",
1683            |m: &CreateActorEvent| { &m.actor_id },
1684            |m: &mut CreateActorEvent| { &mut m.actor_id },
1685        ));
1686        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1687            "actor_type",
1688            |m: &CreateActorEvent| { &m.actor_type },
1689            |m: &mut CreateActorEvent| { &mut m.actor_type },
1690        ));
1691        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1692            "recipe",
1693            |m: &CreateActorEvent| { &m.recipe },
1694            |m: &mut CreateActorEvent| { &mut m.recipe },
1695        ));
1696        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1697            "trace_id",
1698            |m: &CreateActorEvent| { &m.trace_id },
1699            |m: &mut CreateActorEvent| { &mut m.trace_id },
1700        ));
1701        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<CreateActorEvent>(
1702            "CreateActorEvent",
1703            fields,
1704            oneofs,
1705        )
1706    }
1707}
1708
1709impl ::protobuf::Message for CreateActorEvent {
1710    const NAME: &'static str = "CreateActorEvent";
1711
1712    fn is_initialized(&self) -> bool {
1713        true
1714    }
1715
1716    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1717        while let Some(tag) = is.read_raw_tag_or_eof()? {
1718            match tag {
1719                10 => {
1720                    self.message_id = is.read_string()?;
1721                },
1722                18 => {
1723                    self.actor_id = is.read_string()?;
1724                },
1725                26 => {
1726                    self.actor_type = is.read_string()?;
1727                },
1728                34 => {
1729                    self.recipe = is.read_bytes()?;
1730                },
1731                42 => {
1732                    self.trace_id = is.read_string()?;
1733                },
1734                tag => {
1735                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1736                },
1737            };
1738        }
1739        ::std::result::Result::Ok(())
1740    }
1741
1742    // Compute sizes of nested messages
1743    #[allow(unused_variables)]
1744    fn compute_size(&self) -> u64 {
1745        let mut my_size = 0;
1746        if !self.message_id.is_empty() {
1747            my_size += ::protobuf::rt::string_size(1, &self.message_id);
1748        }
1749        if !self.actor_id.is_empty() {
1750            my_size += ::protobuf::rt::string_size(2, &self.actor_id);
1751        }
1752        if !self.actor_type.is_empty() {
1753            my_size += ::protobuf::rt::string_size(3, &self.actor_type);
1754        }
1755        if !self.recipe.is_empty() {
1756            my_size += ::protobuf::rt::bytes_size(4, &self.recipe);
1757        }
1758        if !self.trace_id.is_empty() {
1759            my_size += ::protobuf::rt::string_size(5, &self.trace_id);
1760        }
1761        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1762        self.special_fields.cached_size().set(my_size as u32);
1763        my_size
1764    }
1765
1766    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1767        if !self.message_id.is_empty() {
1768            os.write_string(1, &self.message_id)?;
1769        }
1770        if !self.actor_id.is_empty() {
1771            os.write_string(2, &self.actor_id)?;
1772        }
1773        if !self.actor_type.is_empty() {
1774            os.write_string(3, &self.actor_type)?;
1775        }
1776        if !self.recipe.is_empty() {
1777            os.write_bytes(4, &self.recipe)?;
1778        }
1779        if !self.trace_id.is_empty() {
1780            os.write_string(5, &self.trace_id)?;
1781        }
1782        os.write_unknown_fields(self.special_fields.unknown_fields())?;
1783        ::std::result::Result::Ok(())
1784    }
1785
1786    fn special_fields(&self) -> &::protobuf::SpecialFields {
1787        &self.special_fields
1788    }
1789
1790    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1791        &mut self.special_fields
1792    }
1793
1794    fn new() -> CreateActorEvent {
1795        CreateActorEvent::new()
1796    }
1797
1798    fn clear(&mut self) {
1799        self.message_id.clear();
1800        self.actor_id.clear();
1801        self.actor_type.clear();
1802        self.recipe.clear();
1803        self.trace_id.clear();
1804        self.special_fields.clear();
1805    }
1806
1807    fn default_instance() -> &'static CreateActorEvent {
1808        static instance: CreateActorEvent = CreateActorEvent {
1809            message_id: ::std::string::String::new(),
1810            actor_id: ::std::string::String::new(),
1811            actor_type: ::std::string::String::new(),
1812            recipe: ::std::vec::Vec::new(),
1813            trace_id: ::std::string::String::new(),
1814            special_fields: ::protobuf::SpecialFields::new(),
1815        };
1816        &instance
1817    }
1818}
1819
1820impl ::protobuf::MessageFull for CreateActorEvent {
1821    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1822        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1823        descriptor.get(|| file_descriptor().message_by_package_relative_name("CreateActorEvent").unwrap()).clone()
1824    }
1825}
1826
1827impl ::std::fmt::Display for CreateActorEvent {
1828    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1829        ::protobuf::text_format::fmt(self, f)
1830    }
1831}
1832
1833impl ::protobuf::reflect::ProtobufValue for CreateActorEvent {
1834    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1835}
1836
1837#[derive(PartialEq,Clone,Default,Debug)]
1838// @@protoc_insertion_point(message:coerce.network.FindActorEvent)
1839pub struct FindActorEvent {
1840    // message fields
1841    // @@protoc_insertion_point(field:coerce.network.FindActorEvent.message_id)
1842    pub message_id: ::std::string::String,
1843    // @@protoc_insertion_point(field:coerce.network.FindActorEvent.actor_id)
1844    pub actor_id: ::std::string::String,
1845    // @@protoc_insertion_point(field:coerce.network.FindActorEvent.trace_id)
1846    pub trace_id: ::std::string::String,
1847    // special fields
1848    // @@protoc_insertion_point(special_field:coerce.network.FindActorEvent.special_fields)
1849    pub special_fields: ::protobuf::SpecialFields,
1850}
1851
1852impl<'a> ::std::default::Default for &'a FindActorEvent {
1853    fn default() -> &'a FindActorEvent {
1854        <FindActorEvent as ::protobuf::Message>::default_instance()
1855    }
1856}
1857
1858impl FindActorEvent {
1859    pub fn new() -> FindActorEvent {
1860        ::std::default::Default::default()
1861    }
1862
1863    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1864        let mut fields = ::std::vec::Vec::with_capacity(3);
1865        let mut oneofs = ::std::vec::Vec::with_capacity(0);
1866        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1867            "message_id",
1868            |m: &FindActorEvent| { &m.message_id },
1869            |m: &mut FindActorEvent| { &mut m.message_id },
1870        ));
1871        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1872            "actor_id",
1873            |m: &FindActorEvent| { &m.actor_id },
1874            |m: &mut FindActorEvent| { &mut m.actor_id },
1875        ));
1876        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1877            "trace_id",
1878            |m: &FindActorEvent| { &m.trace_id },
1879            |m: &mut FindActorEvent| { &mut m.trace_id },
1880        ));
1881        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<FindActorEvent>(
1882            "FindActorEvent",
1883            fields,
1884            oneofs,
1885        )
1886    }
1887}
1888
1889impl ::protobuf::Message for FindActorEvent {
1890    const NAME: &'static str = "FindActorEvent";
1891
1892    fn is_initialized(&self) -> bool {
1893        true
1894    }
1895
1896    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1897        while let Some(tag) = is.read_raw_tag_or_eof()? {
1898            match tag {
1899                10 => {
1900                    self.message_id = is.read_string()?;
1901                },
1902                18 => {
1903                    self.actor_id = is.read_string()?;
1904                },
1905                26 => {
1906                    self.trace_id = is.read_string()?;
1907                },
1908                tag => {
1909                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1910                },
1911            };
1912        }
1913        ::std::result::Result::Ok(())
1914    }
1915
1916    // Compute sizes of nested messages
1917    #[allow(unused_variables)]
1918    fn compute_size(&self) -> u64 {
1919        let mut my_size = 0;
1920        if !self.message_id.is_empty() {
1921            my_size += ::protobuf::rt::string_size(1, &self.message_id);
1922        }
1923        if !self.actor_id.is_empty() {
1924            my_size += ::protobuf::rt::string_size(2, &self.actor_id);
1925        }
1926        if !self.trace_id.is_empty() {
1927            my_size += ::protobuf::rt::string_size(3, &self.trace_id);
1928        }
1929        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1930        self.special_fields.cached_size().set(my_size as u32);
1931        my_size
1932    }
1933
1934    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1935        if !self.message_id.is_empty() {
1936            os.write_string(1, &self.message_id)?;
1937        }
1938        if !self.actor_id.is_empty() {
1939            os.write_string(2, &self.actor_id)?;
1940        }
1941        if !self.trace_id.is_empty() {
1942            os.write_string(3, &self.trace_id)?;
1943        }
1944        os.write_unknown_fields(self.special_fields.unknown_fields())?;
1945        ::std::result::Result::Ok(())
1946    }
1947
1948    fn special_fields(&self) -> &::protobuf::SpecialFields {
1949        &self.special_fields
1950    }
1951
1952    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1953        &mut self.special_fields
1954    }
1955
1956    fn new() -> FindActorEvent {
1957        FindActorEvent::new()
1958    }
1959
1960    fn clear(&mut self) {
1961        self.message_id.clear();
1962        self.actor_id.clear();
1963        self.trace_id.clear();
1964        self.special_fields.clear();
1965    }
1966
1967    fn default_instance() -> &'static FindActorEvent {
1968        static instance: FindActorEvent = FindActorEvent {
1969            message_id: ::std::string::String::new(),
1970            actor_id: ::std::string::String::new(),
1971            trace_id: ::std::string::String::new(),
1972            special_fields: ::protobuf::SpecialFields::new(),
1973        };
1974        &instance
1975    }
1976}
1977
1978impl ::protobuf::MessageFull for FindActorEvent {
1979    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1980        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1981        descriptor.get(|| file_descriptor().message_by_package_relative_name("FindActorEvent").unwrap()).clone()
1982    }
1983}
1984
1985impl ::std::fmt::Display for FindActorEvent {
1986    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1987        ::protobuf::text_format::fmt(self, f)
1988    }
1989}
1990
1991impl ::protobuf::reflect::ProtobufValue for FindActorEvent {
1992    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1993}
1994
1995#[derive(PartialEq,Clone,Default,Debug)]
1996// @@protoc_insertion_point(message:coerce.network.ActorAddress)
1997pub struct ActorAddress {
1998    // message fields
1999    // @@protoc_insertion_point(field:coerce.network.ActorAddress.actor_id)
2000    pub actor_id: ::std::string::String,
2001    // @@protoc_insertion_point(field:coerce.network.ActorAddress.node_id)
2002    pub node_id: ::protobuf::MessageField<::protobuf::well_known_types::wrappers::UInt64Value>,
2003    // @@protoc_insertion_point(field:coerce.network.ActorAddress.trace_id)
2004    pub trace_id: ::std::string::String,
2005    // special fields
2006    // @@protoc_insertion_point(special_field:coerce.network.ActorAddress.special_fields)
2007    pub special_fields: ::protobuf::SpecialFields,
2008}
2009
2010impl<'a> ::std::default::Default for &'a ActorAddress {
2011    fn default() -> &'a ActorAddress {
2012        <ActorAddress as ::protobuf::Message>::default_instance()
2013    }
2014}
2015
2016impl ActorAddress {
2017    pub fn new() -> ActorAddress {
2018        ::std::default::Default::default()
2019    }
2020
2021    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
2022        let mut fields = ::std::vec::Vec::with_capacity(3);
2023        let mut oneofs = ::std::vec::Vec::with_capacity(0);
2024        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2025            "actor_id",
2026            |m: &ActorAddress| { &m.actor_id },
2027            |m: &mut ActorAddress| { &mut m.actor_id },
2028        ));
2029        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, ::protobuf::well_known_types::wrappers::UInt64Value>(
2030            "node_id",
2031            |m: &ActorAddress| { &m.node_id },
2032            |m: &mut ActorAddress| { &mut m.node_id },
2033        ));
2034        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2035            "trace_id",
2036            |m: &ActorAddress| { &m.trace_id },
2037            |m: &mut ActorAddress| { &mut m.trace_id },
2038        ));
2039        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ActorAddress>(
2040            "ActorAddress",
2041            fields,
2042            oneofs,
2043        )
2044    }
2045}
2046
2047impl ::protobuf::Message for ActorAddress {
2048    const NAME: &'static str = "ActorAddress";
2049
2050    fn is_initialized(&self) -> bool {
2051        true
2052    }
2053
2054    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
2055        while let Some(tag) = is.read_raw_tag_or_eof()? {
2056            match tag {
2057                10 => {
2058                    self.actor_id = is.read_string()?;
2059                },
2060                18 => {
2061                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.node_id)?;
2062                },
2063                26 => {
2064                    self.trace_id = is.read_string()?;
2065                },
2066                tag => {
2067                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2068                },
2069            };
2070        }
2071        ::std::result::Result::Ok(())
2072    }
2073
2074    // Compute sizes of nested messages
2075    #[allow(unused_variables)]
2076    fn compute_size(&self) -> u64 {
2077        let mut my_size = 0;
2078        if !self.actor_id.is_empty() {
2079            my_size += ::protobuf::rt::string_size(1, &self.actor_id);
2080        }
2081        if let Some(v) = self.node_id.as_ref() {
2082            let len = v.compute_size();
2083            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
2084        }
2085        if !self.trace_id.is_empty() {
2086            my_size += ::protobuf::rt::string_size(3, &self.trace_id);
2087        }
2088        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2089        self.special_fields.cached_size().set(my_size as u32);
2090        my_size
2091    }
2092
2093    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
2094        if !self.actor_id.is_empty() {
2095            os.write_string(1, &self.actor_id)?;
2096        }
2097        if let Some(v) = self.node_id.as_ref() {
2098            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
2099        }
2100        if !self.trace_id.is_empty() {
2101            os.write_string(3, &self.trace_id)?;
2102        }
2103        os.write_unknown_fields(self.special_fields.unknown_fields())?;
2104        ::std::result::Result::Ok(())
2105    }
2106
2107    fn special_fields(&self) -> &::protobuf::SpecialFields {
2108        &self.special_fields
2109    }
2110
2111    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2112        &mut self.special_fields
2113    }
2114
2115    fn new() -> ActorAddress {
2116        ActorAddress::new()
2117    }
2118
2119    fn clear(&mut self) {
2120        self.actor_id.clear();
2121        self.node_id.clear();
2122        self.trace_id.clear();
2123        self.special_fields.clear();
2124    }
2125
2126    fn default_instance() -> &'static ActorAddress {
2127        static instance: ActorAddress = ActorAddress {
2128            actor_id: ::std::string::String::new(),
2129            node_id: ::protobuf::MessageField::none(),
2130            trace_id: ::std::string::String::new(),
2131            special_fields: ::protobuf::SpecialFields::new(),
2132        };
2133        &instance
2134    }
2135}
2136
2137impl ::protobuf::MessageFull for ActorAddress {
2138    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2139        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2140        descriptor.get(|| file_descriptor().message_by_package_relative_name("ActorAddress").unwrap()).clone()
2141    }
2142}
2143
2144impl ::std::fmt::Display for ActorAddress {
2145    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2146        ::protobuf::text_format::fmt(self, f)
2147    }
2148}
2149
2150impl ::protobuf::reflect::ProtobufValue for ActorAddress {
2151    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2152}
2153
2154#[derive(PartialEq,Clone,Default,Debug)]
2155// @@protoc_insertion_point(message:coerce.network.MessageRequest)
2156pub struct MessageRequest {
2157    // message fields
2158    // @@protoc_insertion_point(field:coerce.network.MessageRequest.message_id)
2159    pub message_id: ::std::string::String,
2160    // @@protoc_insertion_point(field:coerce.network.MessageRequest.handler_type)
2161    pub handler_type: ::std::string::String,
2162    // @@protoc_insertion_point(field:coerce.network.MessageRequest.actor_id)
2163    pub actor_id: ::std::string::String,
2164    // @@protoc_insertion_point(field:coerce.network.MessageRequest.message)
2165    pub message: ::std::vec::Vec<u8>,
2166    // @@protoc_insertion_point(field:coerce.network.MessageRequest.trace_id)
2167    pub trace_id: ::std::string::String,
2168    // @@protoc_insertion_point(field:coerce.network.MessageRequest.requires_response)
2169    pub requires_response: bool,
2170    // @@protoc_insertion_point(field:coerce.network.MessageRequest.origin_node_id)
2171    pub origin_node_id: u64,
2172    // special fields
2173    // @@protoc_insertion_point(special_field:coerce.network.MessageRequest.special_fields)
2174    pub special_fields: ::protobuf::SpecialFields,
2175}
2176
2177impl<'a> ::std::default::Default for &'a MessageRequest {
2178    fn default() -> &'a MessageRequest {
2179        <MessageRequest as ::protobuf::Message>::default_instance()
2180    }
2181}
2182
2183impl MessageRequest {
2184    pub fn new() -> MessageRequest {
2185        ::std::default::Default::default()
2186    }
2187
2188    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
2189        let mut fields = ::std::vec::Vec::with_capacity(7);
2190        let mut oneofs = ::std::vec::Vec::with_capacity(0);
2191        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2192            "message_id",
2193            |m: &MessageRequest| { &m.message_id },
2194            |m: &mut MessageRequest| { &mut m.message_id },
2195        ));
2196        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2197            "handler_type",
2198            |m: &MessageRequest| { &m.handler_type },
2199            |m: &mut MessageRequest| { &mut m.handler_type },
2200        ));
2201        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2202            "actor_id",
2203            |m: &MessageRequest| { &m.actor_id },
2204            |m: &mut MessageRequest| { &mut m.actor_id },
2205        ));
2206        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2207            "message",
2208            |m: &MessageRequest| { &m.message },
2209            |m: &mut MessageRequest| { &mut m.message },
2210        ));
2211        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2212            "trace_id",
2213            |m: &MessageRequest| { &m.trace_id },
2214            |m: &mut MessageRequest| { &mut m.trace_id },
2215        ));
2216        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2217            "requires_response",
2218            |m: &MessageRequest| { &m.requires_response },
2219            |m: &mut MessageRequest| { &mut m.requires_response },
2220        ));
2221        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2222            "origin_node_id",
2223            |m: &MessageRequest| { &m.origin_node_id },
2224            |m: &mut MessageRequest| { &mut m.origin_node_id },
2225        ));
2226        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<MessageRequest>(
2227            "MessageRequest",
2228            fields,
2229            oneofs,
2230        )
2231    }
2232}
2233
2234impl ::protobuf::Message for MessageRequest {
2235    const NAME: &'static str = "MessageRequest";
2236
2237    fn is_initialized(&self) -> bool {
2238        true
2239    }
2240
2241    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
2242        while let Some(tag) = is.read_raw_tag_or_eof()? {
2243            match tag {
2244                10 => {
2245                    self.message_id = is.read_string()?;
2246                },
2247                18 => {
2248                    self.handler_type = is.read_string()?;
2249                },
2250                26 => {
2251                    self.actor_id = is.read_string()?;
2252                },
2253                34 => {
2254                    self.message = is.read_bytes()?;
2255                },
2256                42 => {
2257                    self.trace_id = is.read_string()?;
2258                },
2259                48 => {
2260                    self.requires_response = is.read_bool()?;
2261                },
2262                56 => {
2263                    self.origin_node_id = is.read_uint64()?;
2264                },
2265                tag => {
2266                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2267                },
2268            };
2269        }
2270        ::std::result::Result::Ok(())
2271    }
2272
2273    // Compute sizes of nested messages
2274    #[allow(unused_variables)]
2275    fn compute_size(&self) -> u64 {
2276        let mut my_size = 0;
2277        if !self.message_id.is_empty() {
2278            my_size += ::protobuf::rt::string_size(1, &self.message_id);
2279        }
2280        if !self.handler_type.is_empty() {
2281            my_size += ::protobuf::rt::string_size(2, &self.handler_type);
2282        }
2283        if !self.actor_id.is_empty() {
2284            my_size += ::protobuf::rt::string_size(3, &self.actor_id);
2285        }
2286        if !self.message.is_empty() {
2287            my_size += ::protobuf::rt::bytes_size(4, &self.message);
2288        }
2289        if !self.trace_id.is_empty() {
2290            my_size += ::protobuf::rt::string_size(5, &self.trace_id);
2291        }
2292        if self.requires_response != false {
2293            my_size += 1 + 1;
2294        }
2295        if self.origin_node_id != 0 {
2296            my_size += ::protobuf::rt::uint64_size(7, self.origin_node_id);
2297        }
2298        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2299        self.special_fields.cached_size().set(my_size as u32);
2300        my_size
2301    }
2302
2303    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
2304        if !self.message_id.is_empty() {
2305            os.write_string(1, &self.message_id)?;
2306        }
2307        if !self.handler_type.is_empty() {
2308            os.write_string(2, &self.handler_type)?;
2309        }
2310        if !self.actor_id.is_empty() {
2311            os.write_string(3, &self.actor_id)?;
2312        }
2313        if !self.message.is_empty() {
2314            os.write_bytes(4, &self.message)?;
2315        }
2316        if !self.trace_id.is_empty() {
2317            os.write_string(5, &self.trace_id)?;
2318        }
2319        if self.requires_response != false {
2320            os.write_bool(6, self.requires_response)?;
2321        }
2322        if self.origin_node_id != 0 {
2323            os.write_uint64(7, self.origin_node_id)?;
2324        }
2325        os.write_unknown_fields(self.special_fields.unknown_fields())?;
2326        ::std::result::Result::Ok(())
2327    }
2328
2329    fn special_fields(&self) -> &::protobuf::SpecialFields {
2330        &self.special_fields
2331    }
2332
2333    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2334        &mut self.special_fields
2335    }
2336
2337    fn new() -> MessageRequest {
2338        MessageRequest::new()
2339    }
2340
2341    fn clear(&mut self) {
2342        self.message_id.clear();
2343        self.handler_type.clear();
2344        self.actor_id.clear();
2345        self.message.clear();
2346        self.trace_id.clear();
2347        self.requires_response = false;
2348        self.origin_node_id = 0;
2349        self.special_fields.clear();
2350    }
2351
2352    fn default_instance() -> &'static MessageRequest {
2353        static instance: MessageRequest = MessageRequest {
2354            message_id: ::std::string::String::new(),
2355            handler_type: ::std::string::String::new(),
2356            actor_id: ::std::string::String::new(),
2357            message: ::std::vec::Vec::new(),
2358            trace_id: ::std::string::String::new(),
2359            requires_response: false,
2360            origin_node_id: 0,
2361            special_fields: ::protobuf::SpecialFields::new(),
2362        };
2363        &instance
2364    }
2365}
2366
2367impl ::protobuf::MessageFull for MessageRequest {
2368    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2369        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2370        descriptor.get(|| file_descriptor().message_by_package_relative_name("MessageRequest").unwrap()).clone()
2371    }
2372}
2373
2374impl ::std::fmt::Display for MessageRequest {
2375    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2376        ::protobuf::text_format::fmt(self, f)
2377    }
2378}
2379
2380impl ::protobuf::reflect::ProtobufValue for MessageRequest {
2381    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2382}
2383
2384#[derive(PartialEq,Clone,Default,Debug)]
2385// @@protoc_insertion_point(message:coerce.network.SessionHandshake)
2386pub struct SessionHandshake {
2387    // message fields
2388    // @@protoc_insertion_point(field:coerce.network.SessionHandshake.node_id)
2389    pub node_id: u64,
2390    // @@protoc_insertion_point(field:coerce.network.SessionHandshake.nodes)
2391    pub nodes: ::std::vec::Vec<RemoteNode>,
2392    // @@protoc_insertion_point(field:coerce.network.SessionHandshake.token)
2393    pub token: ::std::vec::Vec<u8>,
2394    // @@protoc_insertion_point(field:coerce.network.SessionHandshake.node_tag)
2395    pub node_tag: ::std::string::String,
2396    // @@protoc_insertion_point(field:coerce.network.SessionHandshake.client_type)
2397    pub client_type: ::protobuf::EnumOrUnknown<ClientType>,
2398    // @@protoc_insertion_point(field:coerce.network.SessionHandshake.trace_id)
2399    pub trace_id: ::std::string::String,
2400    // special fields
2401    // @@protoc_insertion_point(special_field:coerce.network.SessionHandshake.special_fields)
2402    pub special_fields: ::protobuf::SpecialFields,
2403}
2404
2405impl<'a> ::std::default::Default for &'a SessionHandshake {
2406    fn default() -> &'a SessionHandshake {
2407        <SessionHandshake as ::protobuf::Message>::default_instance()
2408    }
2409}
2410
2411impl SessionHandshake {
2412    pub fn new() -> SessionHandshake {
2413        ::std::default::Default::default()
2414    }
2415
2416    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
2417        let mut fields = ::std::vec::Vec::with_capacity(6);
2418        let mut oneofs = ::std::vec::Vec::with_capacity(0);
2419        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2420            "node_id",
2421            |m: &SessionHandshake| { &m.node_id },
2422            |m: &mut SessionHandshake| { &mut m.node_id },
2423        ));
2424        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
2425            "nodes",
2426            |m: &SessionHandshake| { &m.nodes },
2427            |m: &mut SessionHandshake| { &mut m.nodes },
2428        ));
2429        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2430            "token",
2431            |m: &SessionHandshake| { &m.token },
2432            |m: &mut SessionHandshake| { &mut m.token },
2433        ));
2434        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2435            "node_tag",
2436            |m: &SessionHandshake| { &m.node_tag },
2437            |m: &mut SessionHandshake| { &mut m.node_tag },
2438        ));
2439        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2440            "client_type",
2441            |m: &SessionHandshake| { &m.client_type },
2442            |m: &mut SessionHandshake| { &mut m.client_type },
2443        ));
2444        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2445            "trace_id",
2446            |m: &SessionHandshake| { &m.trace_id },
2447            |m: &mut SessionHandshake| { &mut m.trace_id },
2448        ));
2449        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SessionHandshake>(
2450            "SessionHandshake",
2451            fields,
2452            oneofs,
2453        )
2454    }
2455}
2456
2457impl ::protobuf::Message for SessionHandshake {
2458    const NAME: &'static str = "SessionHandshake";
2459
2460    fn is_initialized(&self) -> bool {
2461        true
2462    }
2463
2464    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
2465        while let Some(tag) = is.read_raw_tag_or_eof()? {
2466            match tag {
2467                8 => {
2468                    self.node_id = is.read_uint64()?;
2469                },
2470                18 => {
2471                    self.nodes.push(is.read_message()?);
2472                },
2473                26 => {
2474                    self.token = is.read_bytes()?;
2475                },
2476                34 => {
2477                    self.node_tag = is.read_string()?;
2478                },
2479                40 => {
2480                    self.client_type = is.read_enum_or_unknown()?;
2481                },
2482                50 => {
2483                    self.trace_id = is.read_string()?;
2484                },
2485                tag => {
2486                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2487                },
2488            };
2489        }
2490        ::std::result::Result::Ok(())
2491    }
2492
2493    // Compute sizes of nested messages
2494    #[allow(unused_variables)]
2495    fn compute_size(&self) -> u64 {
2496        let mut my_size = 0;
2497        if self.node_id != 0 {
2498            my_size += ::protobuf::rt::uint64_size(1, self.node_id);
2499        }
2500        for value in &self.nodes {
2501            let len = value.compute_size();
2502            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
2503        };
2504        if !self.token.is_empty() {
2505            my_size += ::protobuf::rt::bytes_size(3, &self.token);
2506        }
2507        if !self.node_tag.is_empty() {
2508            my_size += ::protobuf::rt::string_size(4, &self.node_tag);
2509        }
2510        if self.client_type != ::protobuf::EnumOrUnknown::new(ClientType::Client) {
2511            my_size += ::protobuf::rt::int32_size(5, self.client_type.value());
2512        }
2513        if !self.trace_id.is_empty() {
2514            my_size += ::protobuf::rt::string_size(6, &self.trace_id);
2515        }
2516        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2517        self.special_fields.cached_size().set(my_size as u32);
2518        my_size
2519    }
2520
2521    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
2522        if self.node_id != 0 {
2523            os.write_uint64(1, self.node_id)?;
2524        }
2525        for v in &self.nodes {
2526            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
2527        };
2528        if !self.token.is_empty() {
2529            os.write_bytes(3, &self.token)?;
2530        }
2531        if !self.node_tag.is_empty() {
2532            os.write_string(4, &self.node_tag)?;
2533        }
2534        if self.client_type != ::protobuf::EnumOrUnknown::new(ClientType::Client) {
2535            os.write_enum(5, ::protobuf::EnumOrUnknown::value(&self.client_type))?;
2536        }
2537        if !self.trace_id.is_empty() {
2538            os.write_string(6, &self.trace_id)?;
2539        }
2540        os.write_unknown_fields(self.special_fields.unknown_fields())?;
2541        ::std::result::Result::Ok(())
2542    }
2543
2544    fn special_fields(&self) -> &::protobuf::SpecialFields {
2545        &self.special_fields
2546    }
2547
2548    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2549        &mut self.special_fields
2550    }
2551
2552    fn new() -> SessionHandshake {
2553        SessionHandshake::new()
2554    }
2555
2556    fn clear(&mut self) {
2557        self.node_id = 0;
2558        self.nodes.clear();
2559        self.token.clear();
2560        self.node_tag.clear();
2561        self.client_type = ::protobuf::EnumOrUnknown::new(ClientType::Client);
2562        self.trace_id.clear();
2563        self.special_fields.clear();
2564    }
2565
2566    fn default_instance() -> &'static SessionHandshake {
2567        static instance: SessionHandshake = SessionHandshake {
2568            node_id: 0,
2569            nodes: ::std::vec::Vec::new(),
2570            token: ::std::vec::Vec::new(),
2571            node_tag: ::std::string::String::new(),
2572            client_type: ::protobuf::EnumOrUnknown::from_i32(0),
2573            trace_id: ::std::string::String::new(),
2574            special_fields: ::protobuf::SpecialFields::new(),
2575        };
2576        &instance
2577    }
2578}
2579
2580impl ::protobuf::MessageFull for SessionHandshake {
2581    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2582        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2583        descriptor.get(|| file_descriptor().message_by_package_relative_name("SessionHandshake").unwrap()).clone()
2584    }
2585}
2586
2587impl ::std::fmt::Display for SessionHandshake {
2588    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2589        ::protobuf::text_format::fmt(self, f)
2590    }
2591}
2592
2593impl ::protobuf::reflect::ProtobufValue for SessionHandshake {
2594    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2595}
2596
2597#[derive(PartialEq,Clone,Default,Debug)]
2598// @@protoc_insertion_point(message:coerce.network.StreamPublishEvent)
2599pub struct StreamPublishEvent {
2600    // message fields
2601    // @@protoc_insertion_point(field:coerce.network.StreamPublishEvent.topic)
2602    pub topic: ::std::string::String,
2603    // @@protoc_insertion_point(field:coerce.network.StreamPublishEvent.key)
2604    pub key: ::std::string::String,
2605    // @@protoc_insertion_point(field:coerce.network.StreamPublishEvent.message)
2606    pub message: ::std::vec::Vec<u8>,
2607    // @@protoc_insertion_point(field:coerce.network.StreamPublishEvent.trace_id)
2608    pub trace_id: ::std::string::String,
2609    // special fields
2610    // @@protoc_insertion_point(special_field:coerce.network.StreamPublishEvent.special_fields)
2611    pub special_fields: ::protobuf::SpecialFields,
2612}
2613
2614impl<'a> ::std::default::Default for &'a StreamPublishEvent {
2615    fn default() -> &'a StreamPublishEvent {
2616        <StreamPublishEvent as ::protobuf::Message>::default_instance()
2617    }
2618}
2619
2620impl StreamPublishEvent {
2621    pub fn new() -> StreamPublishEvent {
2622        ::std::default::Default::default()
2623    }
2624
2625    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
2626        let mut fields = ::std::vec::Vec::with_capacity(4);
2627        let mut oneofs = ::std::vec::Vec::with_capacity(0);
2628        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2629            "topic",
2630            |m: &StreamPublishEvent| { &m.topic },
2631            |m: &mut StreamPublishEvent| { &mut m.topic },
2632        ));
2633        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2634            "key",
2635            |m: &StreamPublishEvent| { &m.key },
2636            |m: &mut StreamPublishEvent| { &mut m.key },
2637        ));
2638        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2639            "message",
2640            |m: &StreamPublishEvent| { &m.message },
2641            |m: &mut StreamPublishEvent| { &mut m.message },
2642        ));
2643        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2644            "trace_id",
2645            |m: &StreamPublishEvent| { &m.trace_id },
2646            |m: &mut StreamPublishEvent| { &mut m.trace_id },
2647        ));
2648        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<StreamPublishEvent>(
2649            "StreamPublishEvent",
2650            fields,
2651            oneofs,
2652        )
2653    }
2654}
2655
2656impl ::protobuf::Message for StreamPublishEvent {
2657    const NAME: &'static str = "StreamPublishEvent";
2658
2659    fn is_initialized(&self) -> bool {
2660        true
2661    }
2662
2663    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
2664        while let Some(tag) = is.read_raw_tag_or_eof()? {
2665            match tag {
2666                10 => {
2667                    self.topic = is.read_string()?;
2668                },
2669                18 => {
2670                    self.key = is.read_string()?;
2671                },
2672                26 => {
2673                    self.message = is.read_bytes()?;
2674                },
2675                34 => {
2676                    self.trace_id = is.read_string()?;
2677                },
2678                tag => {
2679                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2680                },
2681            };
2682        }
2683        ::std::result::Result::Ok(())
2684    }
2685
2686    // Compute sizes of nested messages
2687    #[allow(unused_variables)]
2688    fn compute_size(&self) -> u64 {
2689        let mut my_size = 0;
2690        if !self.topic.is_empty() {
2691            my_size += ::protobuf::rt::string_size(1, &self.topic);
2692        }
2693        if !self.key.is_empty() {
2694            my_size += ::protobuf::rt::string_size(2, &self.key);
2695        }
2696        if !self.message.is_empty() {
2697            my_size += ::protobuf::rt::bytes_size(3, &self.message);
2698        }
2699        if !self.trace_id.is_empty() {
2700            my_size += ::protobuf::rt::string_size(4, &self.trace_id);
2701        }
2702        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2703        self.special_fields.cached_size().set(my_size as u32);
2704        my_size
2705    }
2706
2707    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
2708        if !self.topic.is_empty() {
2709            os.write_string(1, &self.topic)?;
2710        }
2711        if !self.key.is_empty() {
2712            os.write_string(2, &self.key)?;
2713        }
2714        if !self.message.is_empty() {
2715            os.write_bytes(3, &self.message)?;
2716        }
2717        if !self.trace_id.is_empty() {
2718            os.write_string(4, &self.trace_id)?;
2719        }
2720        os.write_unknown_fields(self.special_fields.unknown_fields())?;
2721        ::std::result::Result::Ok(())
2722    }
2723
2724    fn special_fields(&self) -> &::protobuf::SpecialFields {
2725        &self.special_fields
2726    }
2727
2728    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2729        &mut self.special_fields
2730    }
2731
2732    fn new() -> StreamPublishEvent {
2733        StreamPublishEvent::new()
2734    }
2735
2736    fn clear(&mut self) {
2737        self.topic.clear();
2738        self.key.clear();
2739        self.message.clear();
2740        self.trace_id.clear();
2741        self.special_fields.clear();
2742    }
2743
2744    fn default_instance() -> &'static StreamPublishEvent {
2745        static instance: StreamPublishEvent = StreamPublishEvent {
2746            topic: ::std::string::String::new(),
2747            key: ::std::string::String::new(),
2748            message: ::std::vec::Vec::new(),
2749            trace_id: ::std::string::String::new(),
2750            special_fields: ::protobuf::SpecialFields::new(),
2751        };
2752        &instance
2753    }
2754}
2755
2756impl ::protobuf::MessageFull for StreamPublishEvent {
2757    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2758        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2759        descriptor.get(|| file_descriptor().message_by_package_relative_name("StreamPublishEvent").unwrap()).clone()
2760    }
2761}
2762
2763impl ::std::fmt::Display for StreamPublishEvent {
2764    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2765        ::protobuf::text_format::fmt(self, f)
2766    }
2767}
2768
2769impl ::protobuf::reflect::ProtobufValue for StreamPublishEvent {
2770    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2771}
2772
2773#[derive(PartialEq,Clone,Default,Debug)]
2774// @@protoc_insertion_point(message:coerce.network.NewNodeEvent)
2775pub struct NewNodeEvent {
2776    // message fields
2777    // @@protoc_insertion_point(field:coerce.network.NewNodeEvent.node)
2778    pub node: ::protobuf::MessageField<RemoteNode>,
2779    // @@protoc_insertion_point(field:coerce.network.NewNodeEvent.trace_id)
2780    pub trace_id: ::std::string::String,
2781    // special fields
2782    // @@protoc_insertion_point(special_field:coerce.network.NewNodeEvent.special_fields)
2783    pub special_fields: ::protobuf::SpecialFields,
2784}
2785
2786impl<'a> ::std::default::Default for &'a NewNodeEvent {
2787    fn default() -> &'a NewNodeEvent {
2788        <NewNodeEvent as ::protobuf::Message>::default_instance()
2789    }
2790}
2791
2792impl NewNodeEvent {
2793    pub fn new() -> NewNodeEvent {
2794        ::std::default::Default::default()
2795    }
2796
2797    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
2798        let mut fields = ::std::vec::Vec::with_capacity(2);
2799        let mut oneofs = ::std::vec::Vec::with_capacity(0);
2800        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, RemoteNode>(
2801            "node",
2802            |m: &NewNodeEvent| { &m.node },
2803            |m: &mut NewNodeEvent| { &mut m.node },
2804        ));
2805        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2806            "trace_id",
2807            |m: &NewNodeEvent| { &m.trace_id },
2808            |m: &mut NewNodeEvent| { &mut m.trace_id },
2809        ));
2810        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<NewNodeEvent>(
2811            "NewNodeEvent",
2812            fields,
2813            oneofs,
2814        )
2815    }
2816}
2817
2818impl ::protobuf::Message for NewNodeEvent {
2819    const NAME: &'static str = "NewNodeEvent";
2820
2821    fn is_initialized(&self) -> bool {
2822        true
2823    }
2824
2825    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
2826        while let Some(tag) = is.read_raw_tag_or_eof()? {
2827            match tag {
2828                10 => {
2829                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.node)?;
2830                },
2831                18 => {
2832                    self.trace_id = is.read_string()?;
2833                },
2834                tag => {
2835                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2836                },
2837            };
2838        }
2839        ::std::result::Result::Ok(())
2840    }
2841
2842    // Compute sizes of nested messages
2843    #[allow(unused_variables)]
2844    fn compute_size(&self) -> u64 {
2845        let mut my_size = 0;
2846        if let Some(v) = self.node.as_ref() {
2847            let len = v.compute_size();
2848            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
2849        }
2850        if !self.trace_id.is_empty() {
2851            my_size += ::protobuf::rt::string_size(2, &self.trace_id);
2852        }
2853        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2854        self.special_fields.cached_size().set(my_size as u32);
2855        my_size
2856    }
2857
2858    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
2859        if let Some(v) = self.node.as_ref() {
2860            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
2861        }
2862        if !self.trace_id.is_empty() {
2863            os.write_string(2, &self.trace_id)?;
2864        }
2865        os.write_unknown_fields(self.special_fields.unknown_fields())?;
2866        ::std::result::Result::Ok(())
2867    }
2868
2869    fn special_fields(&self) -> &::protobuf::SpecialFields {
2870        &self.special_fields
2871    }
2872
2873    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2874        &mut self.special_fields
2875    }
2876
2877    fn new() -> NewNodeEvent {
2878        NewNodeEvent::new()
2879    }
2880
2881    fn clear(&mut self) {
2882        self.node.clear();
2883        self.trace_id.clear();
2884        self.special_fields.clear();
2885    }
2886
2887    fn default_instance() -> &'static NewNodeEvent {
2888        static instance: NewNodeEvent = NewNodeEvent {
2889            node: ::protobuf::MessageField::none(),
2890            trace_id: ::std::string::String::new(),
2891            special_fields: ::protobuf::SpecialFields::new(),
2892        };
2893        &instance
2894    }
2895}
2896
2897impl ::protobuf::MessageFull for NewNodeEvent {
2898    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2899        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2900        descriptor.get(|| file_descriptor().message_by_package_relative_name("NewNodeEvent").unwrap()).clone()
2901    }
2902}
2903
2904impl ::std::fmt::Display for NewNodeEvent {
2905    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2906        ::protobuf::text_format::fmt(self, f)
2907    }
2908}
2909
2910impl ::protobuf::reflect::ProtobufValue for NewNodeEvent {
2911    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2912}
2913
2914#[derive(PartialEq,Clone,Default,Debug)]
2915// @@protoc_insertion_point(message:coerce.network.NodeRemovedEvent)
2916pub struct NodeRemovedEvent {
2917    // message fields
2918    // @@protoc_insertion_point(field:coerce.network.NodeRemovedEvent.node)
2919    pub node: ::protobuf::MessageField<RemoteNode>,
2920    // @@protoc_insertion_point(field:coerce.network.NodeRemovedEvent.trace_id)
2921    pub trace_id: ::std::string::String,
2922    // special fields
2923    // @@protoc_insertion_point(special_field:coerce.network.NodeRemovedEvent.special_fields)
2924    pub special_fields: ::protobuf::SpecialFields,
2925}
2926
2927impl<'a> ::std::default::Default for &'a NodeRemovedEvent {
2928    fn default() -> &'a NodeRemovedEvent {
2929        <NodeRemovedEvent as ::protobuf::Message>::default_instance()
2930    }
2931}
2932
2933impl NodeRemovedEvent {
2934    pub fn new() -> NodeRemovedEvent {
2935        ::std::default::Default::default()
2936    }
2937
2938    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
2939        let mut fields = ::std::vec::Vec::with_capacity(2);
2940        let mut oneofs = ::std::vec::Vec::with_capacity(0);
2941        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, RemoteNode>(
2942            "node",
2943            |m: &NodeRemovedEvent| { &m.node },
2944            |m: &mut NodeRemovedEvent| { &mut m.node },
2945        ));
2946        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2947            "trace_id",
2948            |m: &NodeRemovedEvent| { &m.trace_id },
2949            |m: &mut NodeRemovedEvent| { &mut m.trace_id },
2950        ));
2951        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<NodeRemovedEvent>(
2952            "NodeRemovedEvent",
2953            fields,
2954            oneofs,
2955        )
2956    }
2957}
2958
2959impl ::protobuf::Message for NodeRemovedEvent {
2960    const NAME: &'static str = "NodeRemovedEvent";
2961
2962    fn is_initialized(&self) -> bool {
2963        true
2964    }
2965
2966    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
2967        while let Some(tag) = is.read_raw_tag_or_eof()? {
2968            match tag {
2969                10 => {
2970                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.node)?;
2971                },
2972                18 => {
2973                    self.trace_id = is.read_string()?;
2974                },
2975                tag => {
2976                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2977                },
2978            };
2979        }
2980        ::std::result::Result::Ok(())
2981    }
2982
2983    // Compute sizes of nested messages
2984    #[allow(unused_variables)]
2985    fn compute_size(&self) -> u64 {
2986        let mut my_size = 0;
2987        if let Some(v) = self.node.as_ref() {
2988            let len = v.compute_size();
2989            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
2990        }
2991        if !self.trace_id.is_empty() {
2992            my_size += ::protobuf::rt::string_size(2, &self.trace_id);
2993        }
2994        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2995        self.special_fields.cached_size().set(my_size as u32);
2996        my_size
2997    }
2998
2999    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
3000        if let Some(v) = self.node.as_ref() {
3001            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
3002        }
3003        if !self.trace_id.is_empty() {
3004            os.write_string(2, &self.trace_id)?;
3005        }
3006        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3007        ::std::result::Result::Ok(())
3008    }
3009
3010    fn special_fields(&self) -> &::protobuf::SpecialFields {
3011        &self.special_fields
3012    }
3013
3014    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
3015        &mut self.special_fields
3016    }
3017
3018    fn new() -> NodeRemovedEvent {
3019        NodeRemovedEvent::new()
3020    }
3021
3022    fn clear(&mut self) {
3023        self.node.clear();
3024        self.trace_id.clear();
3025        self.special_fields.clear();
3026    }
3027
3028    fn default_instance() -> &'static NodeRemovedEvent {
3029        static instance: NodeRemovedEvent = NodeRemovedEvent {
3030            node: ::protobuf::MessageField::none(),
3031            trace_id: ::std::string::String::new(),
3032            special_fields: ::protobuf::SpecialFields::new(),
3033        };
3034        &instance
3035    }
3036}
3037
3038impl ::protobuf::MessageFull for NodeRemovedEvent {
3039    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
3040        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
3041        descriptor.get(|| file_descriptor().message_by_package_relative_name("NodeRemovedEvent").unwrap()).clone()
3042    }
3043}
3044
3045impl ::std::fmt::Display for NodeRemovedEvent {
3046    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3047        ::protobuf::text_format::fmt(self, f)
3048    }
3049}
3050
3051impl ::protobuf::reflect::ProtobufValue for NodeRemovedEvent {
3052    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
3053}
3054
3055#[derive(PartialEq,Clone,Default,Debug)]
3056// @@protoc_insertion_point(message:coerce.network.LeaderChangedEvent)
3057pub struct LeaderChangedEvent {
3058    // message fields
3059    // @@protoc_insertion_point(field:coerce.network.LeaderChangedEvent.node_id)
3060    pub node_id: u64,
3061    // @@protoc_insertion_point(field:coerce.network.LeaderChangedEvent.trace_id)
3062    pub trace_id: ::std::string::String,
3063    // special fields
3064    // @@protoc_insertion_point(special_field:coerce.network.LeaderChangedEvent.special_fields)
3065    pub special_fields: ::protobuf::SpecialFields,
3066}
3067
3068impl<'a> ::std::default::Default for &'a LeaderChangedEvent {
3069    fn default() -> &'a LeaderChangedEvent {
3070        <LeaderChangedEvent as ::protobuf::Message>::default_instance()
3071    }
3072}
3073
3074impl LeaderChangedEvent {
3075    pub fn new() -> LeaderChangedEvent {
3076        ::std::default::Default::default()
3077    }
3078
3079    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
3080        let mut fields = ::std::vec::Vec::with_capacity(2);
3081        let mut oneofs = ::std::vec::Vec::with_capacity(0);
3082        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
3083            "node_id",
3084            |m: &LeaderChangedEvent| { &m.node_id },
3085            |m: &mut LeaderChangedEvent| { &mut m.node_id },
3086        ));
3087        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
3088            "trace_id",
3089            |m: &LeaderChangedEvent| { &m.trace_id },
3090            |m: &mut LeaderChangedEvent| { &mut m.trace_id },
3091        ));
3092        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<LeaderChangedEvent>(
3093            "LeaderChangedEvent",
3094            fields,
3095            oneofs,
3096        )
3097    }
3098}
3099
3100impl ::protobuf::Message for LeaderChangedEvent {
3101    const NAME: &'static str = "LeaderChangedEvent";
3102
3103    fn is_initialized(&self) -> bool {
3104        true
3105    }
3106
3107    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
3108        while let Some(tag) = is.read_raw_tag_or_eof()? {
3109            match tag {
3110                8 => {
3111                    self.node_id = is.read_uint64()?;
3112                },
3113                18 => {
3114                    self.trace_id = is.read_string()?;
3115                },
3116                tag => {
3117                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3118                },
3119            };
3120        }
3121        ::std::result::Result::Ok(())
3122    }
3123
3124    // Compute sizes of nested messages
3125    #[allow(unused_variables)]
3126    fn compute_size(&self) -> u64 {
3127        let mut my_size = 0;
3128        if self.node_id != 0 {
3129            my_size += ::protobuf::rt::uint64_size(1, self.node_id);
3130        }
3131        if !self.trace_id.is_empty() {
3132            my_size += ::protobuf::rt::string_size(2, &self.trace_id);
3133        }
3134        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3135        self.special_fields.cached_size().set(my_size as u32);
3136        my_size
3137    }
3138
3139    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
3140        if self.node_id != 0 {
3141            os.write_uint64(1, self.node_id)?;
3142        }
3143        if !self.trace_id.is_empty() {
3144            os.write_string(2, &self.trace_id)?;
3145        }
3146        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3147        ::std::result::Result::Ok(())
3148    }
3149
3150    fn special_fields(&self) -> &::protobuf::SpecialFields {
3151        &self.special_fields
3152    }
3153
3154    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
3155        &mut self.special_fields
3156    }
3157
3158    fn new() -> LeaderChangedEvent {
3159        LeaderChangedEvent::new()
3160    }
3161
3162    fn clear(&mut self) {
3163        self.node_id = 0;
3164        self.trace_id.clear();
3165        self.special_fields.clear();
3166    }
3167
3168    fn default_instance() -> &'static LeaderChangedEvent {
3169        static instance: LeaderChangedEvent = LeaderChangedEvent {
3170            node_id: 0,
3171            trace_id: ::std::string::String::new(),
3172            special_fields: ::protobuf::SpecialFields::new(),
3173        };
3174        &instance
3175    }
3176}
3177
3178impl ::protobuf::MessageFull for LeaderChangedEvent {
3179    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
3180        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
3181        descriptor.get(|| file_descriptor().message_by_package_relative_name("LeaderChangedEvent").unwrap()).clone()
3182    }
3183}
3184
3185impl ::std::fmt::Display for LeaderChangedEvent {
3186    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3187        ::protobuf::text_format::fmt(self, f)
3188    }
3189}
3190
3191impl ::protobuf::reflect::ProtobufValue for LeaderChangedEvent {
3192    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
3193}
3194
3195#[derive(PartialEq,Clone,Default,Debug)]
3196// @@protoc_insertion_point(message:coerce.network.RaftRequest)
3197pub struct RaftRequest {
3198    // message fields
3199    // @@protoc_insertion_point(field:coerce.network.RaftRequest.message_id)
3200    pub message_id: ::std::string::String,
3201    // @@protoc_insertion_point(field:coerce.network.RaftRequest.request_type)
3202    pub request_type: u32,
3203    // @@protoc_insertion_point(field:coerce.network.RaftRequest.payload)
3204    pub payload: ::std::vec::Vec<u8>,
3205    // special fields
3206    // @@protoc_insertion_point(special_field:coerce.network.RaftRequest.special_fields)
3207    pub special_fields: ::protobuf::SpecialFields,
3208}
3209
3210impl<'a> ::std::default::Default for &'a RaftRequest {
3211    fn default() -> &'a RaftRequest {
3212        <RaftRequest as ::protobuf::Message>::default_instance()
3213    }
3214}
3215
3216impl RaftRequest {
3217    pub fn new() -> RaftRequest {
3218        ::std::default::Default::default()
3219    }
3220
3221    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
3222        let mut fields = ::std::vec::Vec::with_capacity(3);
3223        let mut oneofs = ::std::vec::Vec::with_capacity(0);
3224        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
3225            "message_id",
3226            |m: &RaftRequest| { &m.message_id },
3227            |m: &mut RaftRequest| { &mut m.message_id },
3228        ));
3229        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
3230            "request_type",
3231            |m: &RaftRequest| { &m.request_type },
3232            |m: &mut RaftRequest| { &mut m.request_type },
3233        ));
3234        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
3235            "payload",
3236            |m: &RaftRequest| { &m.payload },
3237            |m: &mut RaftRequest| { &mut m.payload },
3238        ));
3239        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RaftRequest>(
3240            "RaftRequest",
3241            fields,
3242            oneofs,
3243        )
3244    }
3245}
3246
3247impl ::protobuf::Message for RaftRequest {
3248    const NAME: &'static str = "RaftRequest";
3249
3250    fn is_initialized(&self) -> bool {
3251        true
3252    }
3253
3254    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
3255        while let Some(tag) = is.read_raw_tag_or_eof()? {
3256            match tag {
3257                10 => {
3258                    self.message_id = is.read_string()?;
3259                },
3260                16 => {
3261                    self.request_type = is.read_uint32()?;
3262                },
3263                26 => {
3264                    self.payload = is.read_bytes()?;
3265                },
3266                tag => {
3267                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3268                },
3269            };
3270        }
3271        ::std::result::Result::Ok(())
3272    }
3273
3274    // Compute sizes of nested messages
3275    #[allow(unused_variables)]
3276    fn compute_size(&self) -> u64 {
3277        let mut my_size = 0;
3278        if !self.message_id.is_empty() {
3279            my_size += ::protobuf::rt::string_size(1, &self.message_id);
3280        }
3281        if self.request_type != 0 {
3282            my_size += ::protobuf::rt::uint32_size(2, self.request_type);
3283        }
3284        if !self.payload.is_empty() {
3285            my_size += ::protobuf::rt::bytes_size(3, &self.payload);
3286        }
3287        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3288        self.special_fields.cached_size().set(my_size as u32);
3289        my_size
3290    }
3291
3292    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
3293        if !self.message_id.is_empty() {
3294            os.write_string(1, &self.message_id)?;
3295        }
3296        if self.request_type != 0 {
3297            os.write_uint32(2, self.request_type)?;
3298        }
3299        if !self.payload.is_empty() {
3300            os.write_bytes(3, &self.payload)?;
3301        }
3302        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3303        ::std::result::Result::Ok(())
3304    }
3305
3306    fn special_fields(&self) -> &::protobuf::SpecialFields {
3307        &self.special_fields
3308    }
3309
3310    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
3311        &mut self.special_fields
3312    }
3313
3314    fn new() -> RaftRequest {
3315        RaftRequest::new()
3316    }
3317
3318    fn clear(&mut self) {
3319        self.message_id.clear();
3320        self.request_type = 0;
3321        self.payload.clear();
3322        self.special_fields.clear();
3323    }
3324
3325    fn default_instance() -> &'static RaftRequest {
3326        static instance: RaftRequest = RaftRequest {
3327            message_id: ::std::string::String::new(),
3328            request_type: 0,
3329            payload: ::std::vec::Vec::new(),
3330            special_fields: ::protobuf::SpecialFields::new(),
3331        };
3332        &instance
3333    }
3334}
3335
3336impl ::protobuf::MessageFull for RaftRequest {
3337    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
3338        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
3339        descriptor.get(|| file_descriptor().message_by_package_relative_name("RaftRequest").unwrap()).clone()
3340    }
3341}
3342
3343impl ::std::fmt::Display for RaftRequest {
3344    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3345        ::protobuf::text_format::fmt(self, f)
3346    }
3347}
3348
3349impl ::protobuf::reflect::ProtobufValue for RaftRequest {
3350    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
3351}
3352
3353#[derive(PartialEq,Clone,Default,Debug)]
3354// @@protoc_insertion_point(message:coerce.network.ActorRefErr)
3355pub struct ActorRefErr {
3356    // message fields
3357    // @@protoc_insertion_point(field:coerce.network.ActorRefErr.type)
3358    pub type_: ::protobuf::EnumOrUnknown<actor_ref_err::ErrorType>,
3359    // @@protoc_insertion_point(field:coerce.network.ActorRefErr.actor_id)
3360    pub actor_id: ::std::string::String,
3361    // @@protoc_insertion_point(field:coerce.network.ActorRefErr.message_type)
3362    pub message_type: ::std::string::String,
3363    // @@protoc_insertion_point(field:coerce.network.ActorRefErr.actor_type)
3364    pub actor_type: ::std::string::String,
3365    // @@protoc_insertion_point(field:coerce.network.ActorRefErr.time_taken_millis)
3366    pub time_taken_millis: u64,
3367    // @@protoc_insertion_point(field:coerce.network.ActorRefErr.serialization_error)
3368    pub serialization_error: ::protobuf::EnumOrUnknown<MessageWrapErr>,
3369    // @@protoc_insertion_point(field:coerce.network.ActorRefErr.deserialization_error)
3370    pub deserialization_error: ::protobuf::EnumOrUnknown<MessageUnwrapErr>,
3371    // special fields
3372    // @@protoc_insertion_point(special_field:coerce.network.ActorRefErr.special_fields)
3373    pub special_fields: ::protobuf::SpecialFields,
3374}
3375
3376impl<'a> ::std::default::Default for &'a ActorRefErr {
3377    fn default() -> &'a ActorRefErr {
3378        <ActorRefErr as ::protobuf::Message>::default_instance()
3379    }
3380}
3381
3382impl ActorRefErr {
3383    pub fn new() -> ActorRefErr {
3384        ::std::default::Default::default()
3385    }
3386
3387    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
3388        let mut fields = ::std::vec::Vec::with_capacity(7);
3389        let mut oneofs = ::std::vec::Vec::with_capacity(0);
3390        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
3391            "type",
3392            |m: &ActorRefErr| { &m.type_ },
3393            |m: &mut ActorRefErr| { &mut m.type_ },
3394        ));
3395        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
3396            "actor_id",
3397            |m: &ActorRefErr| { &m.actor_id },
3398            |m: &mut ActorRefErr| { &mut m.actor_id },
3399        ));
3400        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
3401            "message_type",
3402            |m: &ActorRefErr| { &m.message_type },
3403            |m: &mut ActorRefErr| { &mut m.message_type },
3404        ));
3405        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
3406            "actor_type",
3407            |m: &ActorRefErr| { &m.actor_type },
3408            |m: &mut ActorRefErr| { &mut m.actor_type },
3409        ));
3410        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
3411            "time_taken_millis",
3412            |m: &ActorRefErr| { &m.time_taken_millis },
3413            |m: &mut ActorRefErr| { &mut m.time_taken_millis },
3414        ));
3415        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
3416            "serialization_error",
3417            |m: &ActorRefErr| { &m.serialization_error },
3418            |m: &mut ActorRefErr| { &mut m.serialization_error },
3419        ));
3420        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
3421            "deserialization_error",
3422            |m: &ActorRefErr| { &m.deserialization_error },
3423            |m: &mut ActorRefErr| { &mut m.deserialization_error },
3424        ));
3425        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ActorRefErr>(
3426            "ActorRefErr",
3427            fields,
3428            oneofs,
3429        )
3430    }
3431}
3432
3433impl ::protobuf::Message for ActorRefErr {
3434    const NAME: &'static str = "ActorRefErr";
3435
3436    fn is_initialized(&self) -> bool {
3437        true
3438    }
3439
3440    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
3441        while let Some(tag) = is.read_raw_tag_or_eof()? {
3442            match tag {
3443                8 => {
3444                    self.type_ = is.read_enum_or_unknown()?;
3445                },
3446                18 => {
3447                    self.actor_id = is.read_string()?;
3448                },
3449                26 => {
3450                    self.message_type = is.read_string()?;
3451                },
3452                34 => {
3453                    self.actor_type = is.read_string()?;
3454                },
3455                40 => {
3456                    self.time_taken_millis = is.read_uint64()?;
3457                },
3458                48 => {
3459                    self.serialization_error = is.read_enum_or_unknown()?;
3460                },
3461                56 => {
3462                    self.deserialization_error = is.read_enum_or_unknown()?;
3463                },
3464                tag => {
3465                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3466                },
3467            };
3468        }
3469        ::std::result::Result::Ok(())
3470    }
3471
3472    // Compute sizes of nested messages
3473    #[allow(unused_variables)]
3474    fn compute_size(&self) -> u64 {
3475        let mut my_size = 0;
3476        if self.type_ != ::protobuf::EnumOrUnknown::new(actor_ref_err::ErrorType::ActorUnavailable) {
3477            my_size += ::protobuf::rt::int32_size(1, self.type_.value());
3478        }
3479        if !self.actor_id.is_empty() {
3480            my_size += ::protobuf::rt::string_size(2, &self.actor_id);
3481        }
3482        if !self.message_type.is_empty() {
3483            my_size += ::protobuf::rt::string_size(3, &self.message_type);
3484        }
3485        if !self.actor_type.is_empty() {
3486            my_size += ::protobuf::rt::string_size(4, &self.actor_type);
3487        }
3488        if self.time_taken_millis != 0 {
3489            my_size += ::protobuf::rt::uint64_size(5, self.time_taken_millis);
3490        }
3491        if self.serialization_error != ::protobuf::EnumOrUnknown::new(MessageWrapErr::UnknownWrapErr) {
3492            my_size += ::protobuf::rt::int32_size(6, self.serialization_error.value());
3493        }
3494        if self.deserialization_error != ::protobuf::EnumOrUnknown::new(MessageUnwrapErr::UnknownUnwrapErr) {
3495            my_size += ::protobuf::rt::int32_size(7, self.deserialization_error.value());
3496        }
3497        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3498        self.special_fields.cached_size().set(my_size as u32);
3499        my_size
3500    }
3501
3502    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
3503        if self.type_ != ::protobuf::EnumOrUnknown::new(actor_ref_err::ErrorType::ActorUnavailable) {
3504            os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.type_))?;
3505        }
3506        if !self.actor_id.is_empty() {
3507            os.write_string(2, &self.actor_id)?;
3508        }
3509        if !self.message_type.is_empty() {
3510            os.write_string(3, &self.message_type)?;
3511        }
3512        if !self.actor_type.is_empty() {
3513            os.write_string(4, &self.actor_type)?;
3514        }
3515        if self.time_taken_millis != 0 {
3516            os.write_uint64(5, self.time_taken_millis)?;
3517        }
3518        if self.serialization_error != ::protobuf::EnumOrUnknown::new(MessageWrapErr::UnknownWrapErr) {
3519            os.write_enum(6, ::protobuf::EnumOrUnknown::value(&self.serialization_error))?;
3520        }
3521        if self.deserialization_error != ::protobuf::EnumOrUnknown::new(MessageUnwrapErr::UnknownUnwrapErr) {
3522            os.write_enum(7, ::protobuf::EnumOrUnknown::value(&self.deserialization_error))?;
3523        }
3524        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3525        ::std::result::Result::Ok(())
3526    }
3527
3528    fn special_fields(&self) -> &::protobuf::SpecialFields {
3529        &self.special_fields
3530    }
3531
3532    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
3533        &mut self.special_fields
3534    }
3535
3536    fn new() -> ActorRefErr {
3537        ActorRefErr::new()
3538    }
3539
3540    fn clear(&mut self) {
3541        self.type_ = ::protobuf::EnumOrUnknown::new(actor_ref_err::ErrorType::ActorUnavailable);
3542        self.actor_id.clear();
3543        self.message_type.clear();
3544        self.actor_type.clear();
3545        self.time_taken_millis = 0;
3546        self.serialization_error = ::protobuf::EnumOrUnknown::new(MessageWrapErr::UnknownWrapErr);
3547        self.deserialization_error = ::protobuf::EnumOrUnknown::new(MessageUnwrapErr::UnknownUnwrapErr);
3548        self.special_fields.clear();
3549    }
3550
3551    fn default_instance() -> &'static ActorRefErr {
3552        static instance: ActorRefErr = ActorRefErr {
3553            type_: ::protobuf::EnumOrUnknown::from_i32(0),
3554            actor_id: ::std::string::String::new(),
3555            message_type: ::std::string::String::new(),
3556            actor_type: ::std::string::String::new(),
3557            time_taken_millis: 0,
3558            serialization_error: ::protobuf::EnumOrUnknown::from_i32(0),
3559            deserialization_error: ::protobuf::EnumOrUnknown::from_i32(0),
3560            special_fields: ::protobuf::SpecialFields::new(),
3561        };
3562        &instance
3563    }
3564}
3565
3566impl ::protobuf::MessageFull for ActorRefErr {
3567    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
3568        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
3569        descriptor.get(|| file_descriptor().message_by_package_relative_name("ActorRefErr").unwrap()).clone()
3570    }
3571}
3572
3573impl ::std::fmt::Display for ActorRefErr {
3574    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3575        ::protobuf::text_format::fmt(self, f)
3576    }
3577}
3578
3579impl ::protobuf::reflect::ProtobufValue for ActorRefErr {
3580    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
3581}
3582
3583/// Nested message and enums of message `ActorRefErr`
3584pub mod actor_ref_err {
3585    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
3586    // @@protoc_insertion_point(enum:coerce.network.ActorRefErr.ErrorType)
3587    pub enum ErrorType {
3588        // @@protoc_insertion_point(enum_value:coerce.network.ActorRefErr.ErrorType.ActorUnavailable)
3589        ActorUnavailable = 0,
3590        // @@protoc_insertion_point(enum_value:coerce.network.ActorRefErr.ErrorType.NotFound)
3591        NotFound = 1,
3592        // @@protoc_insertion_point(enum_value:coerce.network.ActorRefErr.ErrorType.AlreadyExists)
3593        AlreadyExists = 2,
3594        // @@protoc_insertion_point(enum_value:coerce.network.ActorRefErr.ErrorType.Serialisation)
3595        Serialisation = 3,
3596        // @@protoc_insertion_point(enum_value:coerce.network.ActorRefErr.ErrorType.Deserialisation)
3597        Deserialisation = 4,
3598        // @@protoc_insertion_point(enum_value:coerce.network.ActorRefErr.ErrorType.Timeout)
3599        Timeout = 5,
3600        // @@protoc_insertion_point(enum_value:coerce.network.ActorRefErr.ErrorType.ActorStartFailed)
3601        ActorStartFailed = 6,
3602        // @@protoc_insertion_point(enum_value:coerce.network.ActorRefErr.ErrorType.InvalidRef)
3603        InvalidRef = 7,
3604        // @@protoc_insertion_point(enum_value:coerce.network.ActorRefErr.ErrorType.ResultChannelClosed)
3605        ResultChannelClosed = 8,
3606        // @@protoc_insertion_point(enum_value:coerce.network.ActorRefErr.ErrorType.ResultSendFailed)
3607        ResultSendFailed = 9,
3608        // @@protoc_insertion_point(enum_value:coerce.network.ActorRefErr.ErrorType.NotSupported)
3609        NotSupported = 10,
3610        // @@protoc_insertion_point(enum_value:coerce.network.ActorRefErr.ErrorType.NotImplemented)
3611        NotImplemented = 11,
3612    }
3613
3614    impl ::protobuf::Enum for ErrorType {
3615        const NAME: &'static str = "ErrorType";
3616
3617        fn value(&self) -> i32 {
3618            *self as i32
3619        }
3620
3621        fn from_i32(value: i32) -> ::std::option::Option<ErrorType> {
3622            match value {
3623                0 => ::std::option::Option::Some(ErrorType::ActorUnavailable),
3624                1 => ::std::option::Option::Some(ErrorType::NotFound),
3625                2 => ::std::option::Option::Some(ErrorType::AlreadyExists),
3626                3 => ::std::option::Option::Some(ErrorType::Serialisation),
3627                4 => ::std::option::Option::Some(ErrorType::Deserialisation),
3628                5 => ::std::option::Option::Some(ErrorType::Timeout),
3629                6 => ::std::option::Option::Some(ErrorType::ActorStartFailed),
3630                7 => ::std::option::Option::Some(ErrorType::InvalidRef),
3631                8 => ::std::option::Option::Some(ErrorType::ResultChannelClosed),
3632                9 => ::std::option::Option::Some(ErrorType::ResultSendFailed),
3633                10 => ::std::option::Option::Some(ErrorType::NotSupported),
3634                11 => ::std::option::Option::Some(ErrorType::NotImplemented),
3635                _ => ::std::option::Option::None
3636            }
3637        }
3638
3639        const VALUES: &'static [ErrorType] = &[
3640            ErrorType::ActorUnavailable,
3641            ErrorType::NotFound,
3642            ErrorType::AlreadyExists,
3643            ErrorType::Serialisation,
3644            ErrorType::Deserialisation,
3645            ErrorType::Timeout,
3646            ErrorType::ActorStartFailed,
3647            ErrorType::InvalidRef,
3648            ErrorType::ResultChannelClosed,
3649            ErrorType::ResultSendFailed,
3650            ErrorType::NotSupported,
3651            ErrorType::NotImplemented,
3652        ];
3653    }
3654
3655    impl ::protobuf::EnumFull for ErrorType {
3656        fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
3657            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
3658            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("ActorRefErr.ErrorType").unwrap()).clone()
3659        }
3660
3661        fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
3662            let index = *self as usize;
3663            Self::enum_descriptor().value_by_index(index)
3664        }
3665    }
3666
3667    impl ::std::default::Default for ErrorType {
3668        fn default() -> Self {
3669            ErrorType::ActorUnavailable
3670        }
3671    }
3672
3673    impl ErrorType {
3674        pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
3675            ::protobuf::reflect::GeneratedEnumDescriptorData::new::<ErrorType>("ActorRefErr.ErrorType")
3676        }
3677    }
3678}
3679
3680#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
3681// @@protoc_insertion_point(enum:coerce.network.Event)
3682pub enum Event {
3683    // @@protoc_insertion_point(enum_value:coerce.network.Event.Identify)
3684    Identify = 0,
3685    // @@protoc_insertion_point(enum_value:coerce.network.Event.Handshake)
3686    Handshake = 1,
3687    // @@protoc_insertion_point(enum_value:coerce.network.Event.Result)
3688    Result = 2,
3689    // @@protoc_insertion_point(enum_value:coerce.network.Event.Err)
3690    Err = 3,
3691    // @@protoc_insertion_point(enum_value:coerce.network.Event.Ping)
3692    Ping = 4,
3693    // @@protoc_insertion_point(enum_value:coerce.network.Event.Pong)
3694    Pong = 5,
3695    // @@protoc_insertion_point(enum_value:coerce.network.Event.CreateActor)
3696    CreateActor = 6,
3697    // @@protoc_insertion_point(enum_value:coerce.network.Event.FindActor)
3698    FindActor = 7,
3699    // @@protoc_insertion_point(enum_value:coerce.network.Event.RegisterActor)
3700    RegisterActor = 8,
3701    // @@protoc_insertion_point(enum_value:coerce.network.Event.NotifyActor)
3702    NotifyActor = 9,
3703    // @@protoc_insertion_point(enum_value:coerce.network.Event.StreamPublish)
3704    StreamPublish = 10,
3705    // @@protoc_insertion_point(enum_value:coerce.network.Event.Raft)
3706    Raft = 11,
3707    // @@protoc_insertion_point(enum_value:coerce.network.Event.Identity)
3708    Identity = 12,
3709}
3710
3711impl ::protobuf::Enum for Event {
3712    const NAME: &'static str = "Event";
3713
3714    fn value(&self) -> i32 {
3715        *self as i32
3716    }
3717
3718    fn from_i32(value: i32) -> ::std::option::Option<Event> {
3719        match value {
3720            0 => ::std::option::Option::Some(Event::Identify),
3721            1 => ::std::option::Option::Some(Event::Handshake),
3722            2 => ::std::option::Option::Some(Event::Result),
3723            3 => ::std::option::Option::Some(Event::Err),
3724            4 => ::std::option::Option::Some(Event::Ping),
3725            5 => ::std::option::Option::Some(Event::Pong),
3726            6 => ::std::option::Option::Some(Event::CreateActor),
3727            7 => ::std::option::Option::Some(Event::FindActor),
3728            8 => ::std::option::Option::Some(Event::RegisterActor),
3729            9 => ::std::option::Option::Some(Event::NotifyActor),
3730            10 => ::std::option::Option::Some(Event::StreamPublish),
3731            11 => ::std::option::Option::Some(Event::Raft),
3732            12 => ::std::option::Option::Some(Event::Identity),
3733            _ => ::std::option::Option::None
3734        }
3735    }
3736
3737    const VALUES: &'static [Event] = &[
3738        Event::Identify,
3739        Event::Handshake,
3740        Event::Result,
3741        Event::Err,
3742        Event::Ping,
3743        Event::Pong,
3744        Event::CreateActor,
3745        Event::FindActor,
3746        Event::RegisterActor,
3747        Event::NotifyActor,
3748        Event::StreamPublish,
3749        Event::Raft,
3750        Event::Identity,
3751    ];
3752}
3753
3754impl ::protobuf::EnumFull for Event {
3755    fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
3756        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
3757        descriptor.get(|| file_descriptor().enum_by_package_relative_name("Event").unwrap()).clone()
3758    }
3759
3760    fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
3761        let index = *self as usize;
3762        Self::enum_descriptor().value_by_index(index)
3763    }
3764}
3765
3766impl ::std::default::Default for Event {
3767    fn default() -> Self {
3768        Event::Identify
3769    }
3770}
3771
3772impl Event {
3773    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
3774        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<Event>("Event")
3775    }
3776}
3777
3778#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
3779// @@protoc_insertion_point(enum:coerce.network.ClientType)
3780pub enum ClientType {
3781    // @@protoc_insertion_point(enum_value:coerce.network.ClientType.Client)
3782    Client = 0,
3783    // @@protoc_insertion_point(enum_value:coerce.network.ClientType.Worker)
3784    Worker = 1,
3785}
3786
3787impl ::protobuf::Enum for ClientType {
3788    const NAME: &'static str = "ClientType";
3789
3790    fn value(&self) -> i32 {
3791        *self as i32
3792    }
3793
3794    fn from_i32(value: i32) -> ::std::option::Option<ClientType> {
3795        match value {
3796            0 => ::std::option::Option::Some(ClientType::Client),
3797            1 => ::std::option::Option::Some(ClientType::Worker),
3798            _ => ::std::option::Option::None
3799        }
3800    }
3801
3802    const VALUES: &'static [ClientType] = &[
3803        ClientType::Client,
3804        ClientType::Worker,
3805    ];
3806}
3807
3808impl ::protobuf::EnumFull for ClientType {
3809    fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
3810        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
3811        descriptor.get(|| file_descriptor().enum_by_package_relative_name("ClientType").unwrap()).clone()
3812    }
3813
3814    fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
3815        let index = *self as usize;
3816        Self::enum_descriptor().value_by_index(index)
3817    }
3818}
3819
3820impl ::std::default::Default for ClientType {
3821    fn default() -> Self {
3822        ClientType::Client
3823    }
3824}
3825
3826impl ClientType {
3827    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
3828        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<ClientType>("ClientType")
3829    }
3830}
3831
3832#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
3833// @@protoc_insertion_point(enum:coerce.network.SystemEvent)
3834pub enum SystemEvent {
3835    // @@protoc_insertion_point(enum_value:coerce.network.SystemEvent.ClusterNewNode)
3836    ClusterNewNode = 0,
3837    // @@protoc_insertion_point(enum_value:coerce.network.SystemEvent.ClusterNodeRemoved)
3838    ClusterNodeRemoved = 1,
3839    // @@protoc_insertion_point(enum_value:coerce.network.SystemEvent.ClusterLeaderChanged)
3840    ClusterLeaderChanged = 2,
3841}
3842
3843impl ::protobuf::Enum for SystemEvent {
3844    const NAME: &'static str = "SystemEvent";
3845
3846    fn value(&self) -> i32 {
3847        *self as i32
3848    }
3849
3850    fn from_i32(value: i32) -> ::std::option::Option<SystemEvent> {
3851        match value {
3852            0 => ::std::option::Option::Some(SystemEvent::ClusterNewNode),
3853            1 => ::std::option::Option::Some(SystemEvent::ClusterNodeRemoved),
3854            2 => ::std::option::Option::Some(SystemEvent::ClusterLeaderChanged),
3855            _ => ::std::option::Option::None
3856        }
3857    }
3858
3859    const VALUES: &'static [SystemEvent] = &[
3860        SystemEvent::ClusterNewNode,
3861        SystemEvent::ClusterNodeRemoved,
3862        SystemEvent::ClusterLeaderChanged,
3863    ];
3864}
3865
3866impl ::protobuf::EnumFull for SystemEvent {
3867    fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
3868        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
3869        descriptor.get(|| file_descriptor().enum_by_package_relative_name("SystemEvent").unwrap()).clone()
3870    }
3871
3872    fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
3873        let index = *self as usize;
3874        Self::enum_descriptor().value_by_index(index)
3875    }
3876}
3877
3878impl ::std::default::Default for SystemEvent {
3879    fn default() -> Self {
3880        SystemEvent::ClusterNewNode
3881    }
3882}
3883
3884impl SystemEvent {
3885    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
3886        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<SystemEvent>("SystemEvent")
3887    }
3888}
3889
3890#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
3891// @@protoc_insertion_point(enum:coerce.network.MessageUnwrapErr)
3892pub enum MessageUnwrapErr {
3893    // @@protoc_insertion_point(enum_value:coerce.network.MessageUnwrapErr.UnknownUnwrapErr)
3894    UnknownUnwrapErr = 0,
3895    // @@protoc_insertion_point(enum_value:coerce.network.MessageUnwrapErr.UnwrapUnsupported)
3896    UnwrapUnsupported = 1,
3897    // @@protoc_insertion_point(enum_value:coerce.network.MessageUnwrapErr.DeserializationErr)
3898    DeserializationErr = 2,
3899}
3900
3901impl ::protobuf::Enum for MessageUnwrapErr {
3902    const NAME: &'static str = "MessageUnwrapErr";
3903
3904    fn value(&self) -> i32 {
3905        *self as i32
3906    }
3907
3908    fn from_i32(value: i32) -> ::std::option::Option<MessageUnwrapErr> {
3909        match value {
3910            0 => ::std::option::Option::Some(MessageUnwrapErr::UnknownUnwrapErr),
3911            1 => ::std::option::Option::Some(MessageUnwrapErr::UnwrapUnsupported),
3912            2 => ::std::option::Option::Some(MessageUnwrapErr::DeserializationErr),
3913            _ => ::std::option::Option::None
3914        }
3915    }
3916
3917    const VALUES: &'static [MessageUnwrapErr] = &[
3918        MessageUnwrapErr::UnknownUnwrapErr,
3919        MessageUnwrapErr::UnwrapUnsupported,
3920        MessageUnwrapErr::DeserializationErr,
3921    ];
3922}
3923
3924impl ::protobuf::EnumFull for MessageUnwrapErr {
3925    fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
3926        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
3927        descriptor.get(|| file_descriptor().enum_by_package_relative_name("MessageUnwrapErr").unwrap()).clone()
3928    }
3929
3930    fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
3931        let index = *self as usize;
3932        Self::enum_descriptor().value_by_index(index)
3933    }
3934}
3935
3936impl ::std::default::Default for MessageUnwrapErr {
3937    fn default() -> Self {
3938        MessageUnwrapErr::UnknownUnwrapErr
3939    }
3940}
3941
3942impl MessageUnwrapErr {
3943    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
3944        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<MessageUnwrapErr>("MessageUnwrapErr")
3945    }
3946}
3947
3948#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
3949// @@protoc_insertion_point(enum:coerce.network.MessageWrapErr)
3950pub enum MessageWrapErr {
3951    // @@protoc_insertion_point(enum_value:coerce.network.MessageWrapErr.UnknownWrapErr)
3952    UnknownWrapErr = 0,
3953    // @@protoc_insertion_point(enum_value:coerce.network.MessageWrapErr.WrapUnsupported)
3954    WrapUnsupported = 1,
3955    // @@protoc_insertion_point(enum_value:coerce.network.MessageWrapErr.SerializationErr)
3956    SerializationErr = 2,
3957}
3958
3959impl ::protobuf::Enum for MessageWrapErr {
3960    const NAME: &'static str = "MessageWrapErr";
3961
3962    fn value(&self) -> i32 {
3963        *self as i32
3964    }
3965
3966    fn from_i32(value: i32) -> ::std::option::Option<MessageWrapErr> {
3967        match value {
3968            0 => ::std::option::Option::Some(MessageWrapErr::UnknownWrapErr),
3969            1 => ::std::option::Option::Some(MessageWrapErr::WrapUnsupported),
3970            2 => ::std::option::Option::Some(MessageWrapErr::SerializationErr),
3971            _ => ::std::option::Option::None
3972        }
3973    }
3974
3975    const VALUES: &'static [MessageWrapErr] = &[
3976        MessageWrapErr::UnknownWrapErr,
3977        MessageWrapErr::WrapUnsupported,
3978        MessageWrapErr::SerializationErr,
3979    ];
3980}
3981
3982impl ::protobuf::EnumFull for MessageWrapErr {
3983    fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
3984        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
3985        descriptor.get(|| file_descriptor().enum_by_package_relative_name("MessageWrapErr").unwrap()).clone()
3986    }
3987
3988    fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
3989        let index = *self as usize;
3990        Self::enum_descriptor().value_by_index(index)
3991    }
3992}
3993
3994impl ::std::default::Default for MessageWrapErr {
3995    fn default() -> Self {
3996        MessageWrapErr::UnknownWrapErr
3997    }
3998}
3999
4000impl MessageWrapErr {
4001    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
4002        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<MessageWrapErr>("MessageWrapErr")
4003    }
4004}
4005
4006static file_descriptor_proto_data: &'static [u8] = b"\
4007    \n\rnetwork.proto\x12\x0ecoerce.network\x1a\x1egoogle/protobuf/wrappers.\
4008    proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\x9a\x02\n\nRemoteNode\x12\
4009    \x17\n\x07node_id\x18\x01\x20\x01(\x04R\x06nodeId\x12\x12\n\x04addr\x18\
4010    \x02\x20\x01(\tR\x04addr\x12B\n\x0fnode_started_at\x18\x03\x20\x01(\x0b2\
4011    \x1a.google.protobuf.TimestampR\rnodeStartedAt\x12\x10\n\x03tag\x18\x04\
4012    \x20\x01(\tR\x03tag\x12J\n\nattributes\x18\x05\x20\x03(\x0b2*.coerce.net\
4013    work.RemoteNode.AttributesEntryR\nattributes\x1a=\n\x0fAttributesEntry\
4014    \x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\
4015    \x20\x01(\tR\x05value:\x028\x01\"s\n\rIdentifyEvent\x12$\n\x0esource_nod\
4016    e_id\x18\x01\x20\x01(\x04R\x0csourceNodeId\x12&\n\x0fsource_node_tag\x18\
4017    \x02\x20\x01(\tR\rsourceNodeTag\x12\x14\n\x05token\x18\x03\x20\x01(\tR\
4018    \x05token\"\xfd\x03\n\x0cNodeIdentity\x12\x17\n\x07node_id\x18\x01\x20\
4019    \x01(\x04R\x06nodeId\x12\x19\n\x08node_tag\x18\x02\x20\x01(\tR\x07nodeTa\
4020    g\x12\x12\n\x04addr\x18\x03\x20\x01(\tR\x04addr\x12/\n\x13application_ve\
4021    rsion\x18\x04\x20\x01(\tR\x12applicationVersion\x12)\n\x10protocol_versi\
4022    on\x18\x05\x20\x01(\tR\x0fprotocolVersion\x12B\n\x0fnode_started_at\x18\
4023    \x06\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\rnodeStartedAt\x120\n\
4024    \x05peers\x18\x07\x20\x03(\x0b2\x1a.coerce.network.RemoteNodeR\x05peers\
4025    \x12F\n\x0ccapabilities\x18\x08\x20\x01(\x0b2\".coerce.network.SystemCap\
4026    abilitiesR\x0ccapabilities\x12L\n\nattributes\x18\t\x20\x03(\x0b2,.coerc\
4027    e.network.NodeIdentity.AttributesEntryR\nattributes\x1a=\n\x0fAttributes\
4028    Entry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\
4029    \x02\x20\x01(\tR\x05value:\x028\x01\"H\n\x12SystemCapabilities\x12\x16\n\
4030    \x06actors\x18\x01\x20\x03(\tR\x06actors\x12\x1a\n\x08messages\x18\x02\
4031    \x20\x03(\tR\x08messages\"\xd6\x01\n\x0fClientHandshake\x12\x17\n\x07nod\
4032    e_id\x18\x01\x20\x01(\x04R\x06nodeId\x120\n\x05nodes\x18\x02\x20\x03(\
4033    \x0b2\x1a.coerce.network.RemoteNodeR\x05nodes\x12\x19\n\x08node_tag\x18\
4034    \x03\x20\x01(\tR\x07nodeTag\x12\x19\n\x08trace_id\x18\x04\x20\x01(\tR\
4035    \x07traceId\x12B\n\x0fnode_started_at\x18\x05\x20\x01(\x0b2\x1a.google.p\
4036    rotobuf.TimestampR\rnodeStartedAt\"`\n\x0cClientResult\x12\x1d\n\nmessag\
4037    e_id\x18\x01\x20\x01(\tR\tmessageId\x12\x16\n\x06result\x18\x02\x20\x01(\
4038    \x0cR\x06result\x12\x19\n\x08trace_id\x18\x03\x20\x01(\tR\x07traceId\"x\
4039    \n\tClientErr\x12\x1d\n\nmessage_id\x18\x01\x20\x01(\tR\tmessageId\x121\
4040    \n\x05error\x18\x02\x20\x01(\x0b2\x1b.coerce.network.ActorRefErrR\x05err\
4041    or\x12\x19\n\x08trace_id\x18\x03\x20\x01(\tR\x07traceId\"\x8b\x01\n\tPin\
4042    gEvent\x12\x1d\n\nmessage_id\x18\x01\x20\x01(\tR\tmessageId\x12\x19\n\
4043    \x08trace_id\x18\x02\x20\x01(\tR\x07traceId\x12\x17\n\x07node_id\x18\x03\
4044    \x20\x01(\x04R\x06nodeId\x12+\n\x11system_terminated\x18\x04\x20\x01(\
4045    \x08R\x10systemTerminated\"E\n\tPongEvent\x12\x1d\n\nmessage_id\x18\x01\
4046    \x20\x01(\tR\tmessageId\x12\x19\n\x08trace_id\x18\x02\x20\x01(\tR\x07tra\
4047    ceId\"\x9e\x01\n\x10CreateActorEvent\x12\x1d\n\nmessage_id\x18\x01\x20\
4048    \x01(\tR\tmessageId\x12\x19\n\x08actor_id\x18\x02\x20\x01(\tR\x07actorId\
4049    \x12\x1d\n\nactor_type\x18\x03\x20\x01(\tR\tactorType\x12\x16\n\x06recip\
4050    e\x18\x04\x20\x01(\x0cR\x06recipe\x12\x19\n\x08trace_id\x18\x05\x20\x01(\
4051    \tR\x07traceId\"e\n\x0eFindActorEvent\x12\x1d\n\nmessage_id\x18\x01\x20\
4052    \x01(\tR\tmessageId\x12\x19\n\x08actor_id\x18\x02\x20\x01(\tR\x07actorId\
4053    \x12\x19\n\x08trace_id\x18\x03\x20\x01(\tR\x07traceId\"{\n\x0cActorAddre\
4054    ss\x12\x19\n\x08actor_id\x18\x01\x20\x01(\tR\x07actorId\x125\n\x07node_i\
4055    d\x18\x02\x20\x01(\x0b2\x1c.google.protobuf.UInt64ValueR\x06nodeId\x12\
4056    \x19\n\x08trace_id\x18\x03\x20\x01(\tR\x07traceId\"\xf5\x01\n\x0eMessage\
4057    Request\x12\x1d\n\nmessage_id\x18\x01\x20\x01(\tR\tmessageId\x12!\n\x0ch\
4058    andler_type\x18\x02\x20\x01(\tR\x0bhandlerType\x12\x19\n\x08actor_id\x18\
4059    \x03\x20\x01(\tR\x07actorId\x12\x18\n\x07message\x18\x04\x20\x01(\x0cR\
4060    \x07message\x12\x19\n\x08trace_id\x18\x05\x20\x01(\tR\x07traceId\x12+\n\
4061    \x11requires_response\x18\x06\x20\x01(\x08R\x10requiresResponse\x12$\n\
4062    \x0eorigin_node_id\x18\x07\x20\x01(\x04R\x0coriginNodeId\"\xe6\x01\n\x10\
4063    SessionHandshake\x12\x17\n\x07node_id\x18\x01\x20\x01(\x04R\x06nodeId\
4064    \x120\n\x05nodes\x18\x02\x20\x03(\x0b2\x1a.coerce.network.RemoteNodeR\
4065    \x05nodes\x12\x14\n\x05token\x18\x03\x20\x01(\x0cR\x05token\x12\x19\n\
4066    \x08node_tag\x18\x04\x20\x01(\tR\x07nodeTag\x12;\n\x0bclient_type\x18\
4067    \x05\x20\x01(\x0e2\x1a.coerce.network.ClientTypeR\nclientType\x12\x19\n\
4068    \x08trace_id\x18\x06\x20\x01(\tR\x07traceId\"q\n\x12StreamPublishEvent\
4069    \x12\x14\n\x05topic\x18\x01\x20\x01(\tR\x05topic\x12\x10\n\x03key\x18\
4070    \x02\x20\x01(\tR\x03key\x12\x18\n\x07message\x18\x03\x20\x01(\x0cR\x07me\
4071    ssage\x12\x19\n\x08trace_id\x18\x04\x20\x01(\tR\x07traceId\"Y\n\x0cNewNo\
4072    deEvent\x12.\n\x04node\x18\x01\x20\x01(\x0b2\x1a.coerce.network.RemoteNo\
4073    deR\x04node\x12\x19\n\x08trace_id\x18\x02\x20\x01(\tR\x07traceId\"]\n\
4074    \x10NodeRemovedEvent\x12.\n\x04node\x18\x01\x20\x01(\x0b2\x1a.coerce.net\
4075    work.RemoteNodeR\x04node\x12\x19\n\x08trace_id\x18\x02\x20\x01(\tR\x07tr\
4076    aceId\"H\n\x12LeaderChangedEvent\x12\x17\n\x07node_id\x18\x01\x20\x01(\
4077    \x04R\x06nodeId\x12\x19\n\x08trace_id\x18\x02\x20\x01(\tR\x07traceId\"i\
4078    \n\x0bRaftRequest\x12\x1d\n\nmessage_id\x18\x01\x20\x01(\tR\tmessageId\
4079    \x12!\n\x0crequest_type\x18\x02\x20\x01(\rR\x0brequestType\x12\x18\n\x07\
4080    payload\x18\x03\x20\x01(\x0cR\x07payload\"\xee\x04\n\x0bActorRefErr\x129\
4081    \n\x04type\x18\x01\x20\x01(\x0e2%.coerce.network.ActorRefErr.ErrorTypeR\
4082    \x04type\x12\x19\n\x08actor_id\x18\x02\x20\x01(\tR\x07actorId\x12!\n\x0c\
4083    message_type\x18\x03\x20\x01(\tR\x0bmessageType\x12\x1d\n\nactor_type\
4084    \x18\x04\x20\x01(\tR\tactorType\x12*\n\x11time_taken_millis\x18\x05\x20\
4085    \x01(\x04R\x0ftimeTakenMillis\x12O\n\x13serialization_error\x18\x06\x20\
4086    \x01(\x0e2\x1e.coerce.network.MessageWrapErrR\x12serializationError\x12U\
4087    \n\x15deserialization_error\x18\x07\x20\x01(\x0e2\x20.coerce.network.Mes\
4088    sageUnwrapErrR\x14deserializationError\"\xf2\x01\n\tErrorType\x12\x14\n\
4089    \x10ActorUnavailable\x10\0\x12\x0c\n\x08NotFound\x10\x01\x12\x11\n\rAlre\
4090    adyExists\x10\x02\x12\x11\n\rSerialisation\x10\x03\x12\x13\n\x0fDeserial\
4091    isation\x10\x04\x12\x0b\n\x07Timeout\x10\x05\x12\x14\n\x10ActorStartFail\
4092    ed\x10\x06\x12\x0e\n\nInvalidRef\x10\x07\x12\x17\n\x13ResultChannelClose\
4093    d\x10\x08\x12\x14\n\x10ResultSendFailed\x10\t\x12\x10\n\x0cNotSupported\
4094    \x10\n\x12\x12\n\x0eNotImplemented\x10\x0b*\xbc\x01\n\x05Event\x12\x0c\n\
4095    \x08Identify\x10\0\x12\r\n\tHandshake\x10\x01\x12\n\n\x06Result\x10\x02\
4096    \x12\x07\n\x03Err\x10\x03\x12\x08\n\x04Ping\x10\x04\x12\x08\n\x04Pong\
4097    \x10\x05\x12\x0f\n\x0bCreateActor\x10\x06\x12\r\n\tFindActor\x10\x07\x12\
4098    \x11\n\rRegisterActor\x10\x08\x12\x0f\n\x0bNotifyActor\x10\t\x12\x11\n\r\
4099    StreamPublish\x10\n\x12\x08\n\x04Raft\x10\x0b\x12\x0c\n\x08Identity\x10\
4100    \x0c*$\n\nClientType\x12\n\n\x06Client\x10\0\x12\n\n\x06Worker\x10\x01*S\
4101    \n\x0bSystemEvent\x12\x12\n\x0eClusterNewNode\x10\0\x12\x16\n\x12Cluster\
4102    NodeRemoved\x10\x01\x12\x18\n\x14ClusterLeaderChanged\x10\x02*W\n\x10Mes\
4103    sageUnwrapErr\x12\x14\n\x10UnknownUnwrapErr\x10\0\x12\x15\n\x11UnwrapUns\
4104    upported\x10\x01\x12\x16\n\x12DeserializationErr\x10\x02*O\n\x0eMessageW\
4105    rapErr\x12\x12\n\x0eUnknownWrapErr\x10\0\x12\x13\n\x0fWrapUnsupported\
4106    \x10\x01\x12\x14\n\x10SerializationErr\x10\x02b\x06proto3\
4107";
4108
4109/// `FileDescriptorProto` object which was a source for this generated file
4110fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
4111    static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
4112    file_descriptor_proto_lazy.get(|| {
4113        ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
4114    })
4115}
4116
4117/// `FileDescriptor` object which allows dynamic access to files
4118pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
4119    static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
4120    static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
4121    file_descriptor.get(|| {
4122        let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
4123            let mut deps = ::std::vec::Vec::with_capacity(2);
4124            deps.push(::protobuf::well_known_types::wrappers::file_descriptor().clone());
4125            deps.push(::protobuf::well_known_types::timestamp::file_descriptor().clone());
4126            let mut messages = ::std::vec::Vec::with_capacity(20);
4127            messages.push(RemoteNode::generated_message_descriptor_data());
4128            messages.push(IdentifyEvent::generated_message_descriptor_data());
4129            messages.push(NodeIdentity::generated_message_descriptor_data());
4130            messages.push(SystemCapabilities::generated_message_descriptor_data());
4131            messages.push(ClientHandshake::generated_message_descriptor_data());
4132            messages.push(ClientResult::generated_message_descriptor_data());
4133            messages.push(ClientErr::generated_message_descriptor_data());
4134            messages.push(PingEvent::generated_message_descriptor_data());
4135            messages.push(PongEvent::generated_message_descriptor_data());
4136            messages.push(CreateActorEvent::generated_message_descriptor_data());
4137            messages.push(FindActorEvent::generated_message_descriptor_data());
4138            messages.push(ActorAddress::generated_message_descriptor_data());
4139            messages.push(MessageRequest::generated_message_descriptor_data());
4140            messages.push(SessionHandshake::generated_message_descriptor_data());
4141            messages.push(StreamPublishEvent::generated_message_descriptor_data());
4142            messages.push(NewNodeEvent::generated_message_descriptor_data());
4143            messages.push(NodeRemovedEvent::generated_message_descriptor_data());
4144            messages.push(LeaderChangedEvent::generated_message_descriptor_data());
4145            messages.push(RaftRequest::generated_message_descriptor_data());
4146            messages.push(ActorRefErr::generated_message_descriptor_data());
4147            let mut enums = ::std::vec::Vec::with_capacity(6);
4148            enums.push(Event::generated_enum_descriptor_data());
4149            enums.push(ClientType::generated_enum_descriptor_data());
4150            enums.push(SystemEvent::generated_enum_descriptor_data());
4151            enums.push(MessageUnwrapErr::generated_enum_descriptor_data());
4152            enums.push(MessageWrapErr::generated_enum_descriptor_data());
4153            enums.push(actor_ref_err::ErrorType::generated_enum_descriptor_data());
4154            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
4155                file_descriptor_proto(),
4156                deps,
4157                messages,
4158                enums,
4159            )
4160        });
4161        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
4162    })
4163}
coerce/remote/net/proto/network.rs

coerce/remote/net/proto/
network.rs
