maxwell_protocol/protocol/
maxwell_protocol_ext.rs

1use super::maxwell_protocol::*;
2use actix::Message as ActixMessage;
3use bytes::{BufMut, Bytes, BytesMut};
4pub use prost::DecodeError;
5use thiserror::Error as ThisError;
6use prost::Message as ProstMessage;
7use std::fmt::{Debug, Formatter, Result as FmtResult};
8use std::result::Result as StdResult;
9
10pub enum ProtocolMsg {
11  None,
12  PingReq(PingReq),
13  PingRep(PingRep),
14  OkRep(OkRep),
15  ErrorRep(ErrorRep),
16  Ok2Rep(Ok2Rep),
17  Error2Rep(Error2Rep),
18  PushReq(PushReq),
19  PushRep(PushRep),
20  PullReq(PullReq),
21  PullRep(PullRep),
22  ReqReq(ReqReq),
23  ReqRep(ReqRep),
24  AuthReq(AuthReq),
25  AuthRep(AuthRep),
26  RegisterFrontendReq(RegisterFrontendReq),
27  RegisterFrontendRep(RegisterFrontendRep),
28  RegisterBackendReq(RegisterBackendReq),
29  RegisterBackendRep(RegisterBackendRep),
30  RegisterServiceReq(RegisterServiceReq),
31  RegisterServiceRep(RegisterServiceRep),
32  SetRoutesReq(SetRoutesReq),
33  SetRoutesRep(SetRoutesRep),
34  GetRoutesReq(GetRoutesReq),
35  GetRoutesRep(GetRoutesRep),
36  GetTopicDistChecksumReq(GetTopicDistChecksumReq),
37  GetTopicDistChecksumRep(GetTopicDistChecksumRep),
38  GetRouteDistChecksumReq(GetRouteDistChecksumReq),
39  GetRouteDistChecksumRep(GetRouteDistChecksumRep),
40  PickFrontendReq(PickFrontendReq),
41  PickFrontendRep(PickFrontendRep),
42  PickFrontendsReq(PickFrontendsReq),
43  PickFrontendsRep(PickFrontendsRep),
44  LocateTopicReq(LocateTopicReq),
45  LocateTopicRep(LocateTopicRep),
46  ResolveIpReq(ResolveIpReq),
47  ResolveIpRep(ResolveIpRep),
48}
49
50impl Debug for ProtocolMsg {
51  fn fmt(&self, f: &mut Formatter) -> FmtResult {
52    match self {
53      ProtocolMsg::None => write!(f, "None"),
54      ProtocolMsg::PingReq(msg) => write!(f, "{:?}", msg),
55      ProtocolMsg::PingRep(msg) => write!(f, "{:?}", msg),
56      ProtocolMsg::OkRep(msg) => write!(f, "{:?}", msg),
57      ProtocolMsg::ErrorRep(msg) => write!(f, "{:?}", msg),
58      ProtocolMsg::Ok2Rep(msg) => write!(f, "{:?}", msg),
59      ProtocolMsg::Error2Rep(msg) => write!(f, "{:?}", msg),
60      ProtocolMsg::PushReq(msg) => write!(f, "{:?}", msg),
61      ProtocolMsg::PushRep(msg) => write!(f, "{:?}", msg),
62      ProtocolMsg::PullReq(msg) => write!(f, "{:?}", msg),
63      ProtocolMsg::PullRep(msg) => write!(f, "{:?}", msg),
64      ProtocolMsg::ReqReq(msg) => write!(f, "{:?}", msg),
65      ProtocolMsg::ReqRep(msg) => write!(f, "{:?}", msg),
66      ProtocolMsg::AuthReq(msg) => write!(f, "{:?}", msg),
67      ProtocolMsg::AuthRep(msg) => write!(f, "{:?}", msg),
68      ProtocolMsg::RegisterFrontendReq(msg) => write!(f, "{:?}", msg),
69      ProtocolMsg::RegisterFrontendRep(msg) => write!(f, "{:?}", msg),
70      ProtocolMsg::RegisterBackendReq(msg) => write!(f, "{:?}", msg),
71      ProtocolMsg::RegisterBackendRep(msg) => write!(f, "{:?}", msg),
72      ProtocolMsg::RegisterServiceReq(msg) => write!(f, "{:?}", msg),
73      ProtocolMsg::RegisterServiceRep(msg) => write!(f, "{:?}", msg),
74      ProtocolMsg::SetRoutesReq(msg) => write!(f, "{:?}", msg),
75      ProtocolMsg::SetRoutesRep(msg) => write!(f, "{:?}", msg),
76      ProtocolMsg::GetRoutesReq(msg) => write!(f, "{:?}", msg),
77      ProtocolMsg::GetRoutesRep(msg) => write!(f, "{:?}", msg),
78      ProtocolMsg::GetTopicDistChecksumReq(msg) => write!(f, "{:?}", msg),
79      ProtocolMsg::GetTopicDistChecksumRep(msg) => write!(f, "{:?}", msg),
80      ProtocolMsg::GetRouteDistChecksumReq(msg) => write!(f, "{:?}", msg),
81      ProtocolMsg::GetRouteDistChecksumRep(msg) => write!(f, "{:?}", msg),
82      ProtocolMsg::PickFrontendReq(msg) => write!(f, "{:?}", msg),
83      ProtocolMsg::PickFrontendRep(msg) => write!(f, "{:?}", msg),
84      ProtocolMsg::PickFrontendsReq(msg) => write!(f, "{:?}", msg),
85      ProtocolMsg::PickFrontendsRep(msg) => write!(f, "{:?}", msg),
86      ProtocolMsg::LocateTopicReq(msg) => write!(f, "{:?}", msg),
87      ProtocolMsg::LocateTopicRep(msg) => write!(f, "{:?}", msg),
88      ProtocolMsg::ResolveIpReq(msg) => write!(f, "{:?}", msg),
89      ProtocolMsg::ResolveIpRep(msg) => write!(f, "{:?}", msg),
90    }
91  }
92}
93
94impl ProtocolMsg {
95  #[inline]
96  pub fn is_none(&self) -> bool {
97    match self {
98      Self::None => true,
99      _ => false,
100    }
101  }
102
103  #[inline]
104  pub fn is_some(&self) -> bool {
105    match self {
106      Self::None => false,
107      _ => true,
108    }
109  }
110}
111
112#[derive(Debug, ThisError)]
113pub enum HandleError<M> {
114  #[error("The mailbox was full")]
115  MailboxFull,
116  #[error("The mailbox has closed")]
117  MailboxClosed,
118  #[error("Message delivery timed out")]
119  Timeout,
120  #[error("Error occured: code: {code}, desc: {desc}")]
121  Any { code: i32, desc: String, msg: M },
122}
123
124impl ActixMessage for ProtocolMsg {
125  type Result = StdResult<ProtocolMsg, HandleError<ProtocolMsg>>;
126}
127
128impl ActixMessage for PingReq {
129  type Result = StdResult<PingRep, HandleError<PingReq>>;
130}
131
132impl ActixMessage for PushReq {
133  type Result = StdResult<PushRep, HandleError<PushReq>>;
134}
135
136impl ActixMessage for PullReq {
137  type Result = StdResult<PullRep, HandleError<PullReq>>;
138}
139
140impl ActixMessage for ReqReq {
141  type Result = StdResult<ReqRep, HandleError<ReqReq>>;
142}
143
144impl ActixMessage for AuthReq {
145  type Result = StdResult<AuthRep, HandleError<AuthReq>>;
146}
147
148impl ActixMessage for RegisterFrontendReq {
149  type Result = StdResult<RegisterFrontendRep, HandleError<RegisterFrontendReq>>;
150}
151
152impl ActixMessage for RegisterBackendReq {
153  type Result = StdResult<RegisterBackendRep, HandleError<RegisterBackendReq>>;
154}
155
156impl ActixMessage for RegisterServiceReq {
157  type Result = StdResult<RegisterServiceRep, HandleError<RegisterServiceReq>>;
158}
159
160impl ActixMessage for SetRoutesReq {
161  type Result = StdResult<SetRoutesRep, HandleError<SetRoutesReq>>;
162}
163
164impl ActixMessage for GetRoutesReq {
165  type Result = StdResult<GetRoutesRep, HandleError<GetRoutesReq>>;
166}
167
168impl ActixMessage for GetTopicDistChecksumReq {
169  type Result = StdResult<GetTopicDistChecksumRep, HandleError<GetTopicDistChecksumReq>>;
170}
171
172impl ActixMessage for GetRouteDistChecksumReq {
173  type Result = StdResult<GetRouteDistChecksumRep, HandleError<GetRouteDistChecksumReq>>;
174}
175
176impl ActixMessage for PickFrontendReq {
177  type Result = StdResult<PickFrontendRep, HandleError<PickFrontendReq>>;
178}
179
180impl ActixMessage for PickFrontendsReq {
181  type Result = StdResult<PickFrontendsRep, HandleError<PickFrontendsReq>>;
182}
183
184impl ActixMessage for LocateTopicReq {
185  type Result = StdResult<LocateTopicRep, HandleError<LocateTopicReq>>;
186}
187
188impl ActixMessage for ResolveIpReq {
189  type Result = StdResult<ResolveIpRep, HandleError<ResolveIpReq>>;
190}
191
192pub trait IntoEnum {
193  fn into_enum(self) -> ProtocolMsg;
194}
195
196impl IntoEnum for PingReq {
197  #[inline]
198  fn into_enum(self) -> ProtocolMsg {
199    ProtocolMsg::PingReq(self)
200  }
201}
202
203impl IntoEnum for PingRep {
204  #[inline]
205  fn into_enum(self) -> ProtocolMsg {
206    ProtocolMsg::PingRep(self)
207  }
208}
209
210impl IntoEnum for OkRep {
211  #[inline]
212  fn into_enum(self) -> ProtocolMsg {
213    ProtocolMsg::OkRep(self)
214  }
215}
216
217impl IntoEnum for ErrorRep {
218  #[inline]
219  fn into_enum(self) -> ProtocolMsg {
220    ProtocolMsg::ErrorRep(self)
221  }
222}
223
224impl IntoEnum for Ok2Rep {
225  #[inline]
226  fn into_enum(self) -> ProtocolMsg {
227    ProtocolMsg::Ok2Rep(self)
228  }
229}
230
231impl IntoEnum for Error2Rep {
232  #[inline]
233  fn into_enum(self) -> ProtocolMsg {
234    ProtocolMsg::Error2Rep(self)
235  }
236}
237
238impl IntoEnum for PushReq {
239  #[inline]
240  fn into_enum(self) -> ProtocolMsg {
241    ProtocolMsg::PushReq(self)
242  }
243}
244
245impl IntoEnum for PushRep {
246  #[inline]
247  fn into_enum(self) -> ProtocolMsg {
248    ProtocolMsg::PushRep(self)
249  }
250}
251
252impl IntoEnum for PullReq {
253  #[inline]
254  fn into_enum(self) -> ProtocolMsg {
255    ProtocolMsg::PullReq(self)
256  }
257}
258
259impl IntoEnum for PullRep {
260  #[inline]
261  fn into_enum(self) -> ProtocolMsg {
262    ProtocolMsg::PullRep(self)
263  }
264}
265
266impl IntoEnum for ReqReq {
267  #[inline]
268  fn into_enum(self) -> ProtocolMsg {
269    ProtocolMsg::ReqReq(self)
270  }
271}
272
273impl IntoEnum for ReqRep {
274  #[inline]
275  fn into_enum(self) -> ProtocolMsg {
276    ProtocolMsg::ReqRep(self)
277  }
278}
279
280impl IntoEnum for AuthReq {
281  #[inline]
282  fn into_enum(self) -> ProtocolMsg {
283    ProtocolMsg::AuthReq(self)
284  }
285}
286
287impl IntoEnum for AuthRep {
288  #[inline]
289  fn into_enum(self) -> ProtocolMsg {
290    ProtocolMsg::AuthRep(self)
291  }
292}
293
294impl IntoEnum for RegisterFrontendReq {
295  #[inline]
296  fn into_enum(self) -> ProtocolMsg {
297    ProtocolMsg::RegisterFrontendReq(self)
298  }
299}
300
301impl IntoEnum for RegisterFrontendRep {
302  #[inline]
303  fn into_enum(self) -> ProtocolMsg {
304    ProtocolMsg::RegisterFrontendRep(self)
305  }
306}
307
308impl IntoEnum for RegisterBackendReq {
309  #[inline]
310  fn into_enum(self) -> ProtocolMsg {
311    ProtocolMsg::RegisterBackendReq(self)
312  }
313}
314
315impl IntoEnum for RegisterBackendRep {
316  #[inline]
317  fn into_enum(self) -> ProtocolMsg {
318    ProtocolMsg::RegisterBackendRep(self)
319  }
320}
321
322impl IntoEnum for RegisterServiceReq {
323  #[inline]
324  fn into_enum(self) -> ProtocolMsg {
325    ProtocolMsg::RegisterServiceReq(self)
326  }
327}
328
329impl IntoEnum for RegisterServiceRep {
330  #[inline]
331  fn into_enum(self) -> ProtocolMsg {
332    ProtocolMsg::RegisterServiceRep(self)
333  }
334}
335
336impl IntoEnum for SetRoutesReq {
337  #[inline]
338  fn into_enum(self) -> ProtocolMsg {
339    ProtocolMsg::SetRoutesReq(self)
340  }
341}
342
343impl IntoEnum for SetRoutesRep {
344  #[inline]
345  fn into_enum(self) -> ProtocolMsg {
346    ProtocolMsg::SetRoutesRep(self)
347  }
348}
349
350impl IntoEnum for GetRoutesReq {
351  #[inline]
352  fn into_enum(self) -> ProtocolMsg {
353    ProtocolMsg::GetRoutesReq(self)
354  }
355}
356
357impl IntoEnum for GetRoutesRep {
358  #[inline]
359  fn into_enum(self) -> ProtocolMsg {
360    ProtocolMsg::GetRoutesRep(self)
361  }
362}
363
364impl IntoEnum for GetTopicDistChecksumReq {
365  #[inline]
366  fn into_enum(self) -> ProtocolMsg {
367    ProtocolMsg::GetTopicDistChecksumReq(self)
368  }
369}
370
371impl IntoEnum for GetTopicDistChecksumRep {
372  #[inline]
373  fn into_enum(self) -> ProtocolMsg {
374    ProtocolMsg::GetTopicDistChecksumRep(self)
375  }
376}
377
378impl IntoEnum for GetRouteDistChecksumReq {
379  #[inline]
380  fn into_enum(self) -> ProtocolMsg {
381    ProtocolMsg::GetRouteDistChecksumReq(self)
382  }
383}
384
385impl IntoEnum for GetRouteDistChecksumRep {
386  #[inline]
387  fn into_enum(self) -> ProtocolMsg {
388    ProtocolMsg::GetRouteDistChecksumRep(self)
389  }
390}
391
392impl IntoEnum for PickFrontendReq {
393  #[inline]
394  fn into_enum(self) -> ProtocolMsg {
395    ProtocolMsg::PickFrontendReq(self)
396  }
397}
398
399impl IntoEnum for PickFrontendRep {
400  #[inline]
401  fn into_enum(self) -> ProtocolMsg {
402    ProtocolMsg::PickFrontendRep(self)
403  }
404}
405
406impl IntoEnum for PickFrontendsReq {
407  #[inline]
408  fn into_enum(self) -> ProtocolMsg {
409    ProtocolMsg::PickFrontendsReq(self)
410  }
411}
412
413impl IntoEnum for PickFrontendsRep {
414  #[inline]
415  fn into_enum(self) -> ProtocolMsg {
416    ProtocolMsg::PickFrontendsRep(self)
417  }
418}
419
420impl IntoEnum for LocateTopicReq {
421  #[inline]
422  fn into_enum(self) -> ProtocolMsg {
423    ProtocolMsg::LocateTopicReq(self)
424  }
425}
426
427impl IntoEnum for LocateTopicRep {
428  #[inline]
429  fn into_enum(self) -> ProtocolMsg {
430    ProtocolMsg::LocateTopicRep(self)
431  }
432}
433
434impl IntoEnum for ResolveIpReq {
435  #[inline]
436  fn into_enum(self) -> ProtocolMsg {
437    ProtocolMsg::ResolveIpReq(self)
438  }
439}
440
441impl IntoEnum for ResolveIpRep {
442  #[inline]
443  fn into_enum(self) -> ProtocolMsg {
444    ProtocolMsg::ResolveIpRep(self)
445  }
446}
447
448impl From<ProtocolMsg> for PingReq {
449  #[inline]
450  fn from(item: ProtocolMsg) -> PingReq {
451    match item {
452      ProtocolMsg::PingReq(msg) => msg,
453      _ => panic!("Unable to convert to PingReq"),
454    }
455  }
456}
457
458impl From<ProtocolMsg> for PingRep {
459  #[inline]
460  fn from(item: ProtocolMsg) -> PingRep {
461    match item {
462      ProtocolMsg::PingRep(msg) => msg,
463      _ => panic!("Unable to convert to PingRep"),
464    }
465  }
466}
467
468impl From<ProtocolMsg> for OkRep {
469  #[inline]
470  fn from(item: ProtocolMsg) -> OkRep {
471    match item {
472      ProtocolMsg::OkRep(msg) => msg,
473      _ => panic!("Unable to convert to OkRep"),
474    }
475  }
476}
477
478impl From<ProtocolMsg> for ErrorRep {
479  #[inline]
480  fn from(item: ProtocolMsg) -> ErrorRep {
481    match item {
482      ProtocolMsg::ErrorRep(msg) => msg,
483      _ => panic!("Unable to convert to ErrorRep"),
484    }
485  }
486}
487
488impl From<ProtocolMsg> for Ok2Rep {
489  #[inline]
490  fn from(item: ProtocolMsg) -> Ok2Rep {
491    match item {
492      ProtocolMsg::Ok2Rep(msg) => msg,
493      _ => panic!("Unable to convert to Ok2Rep"),
494    }
495  }
496}
497
498impl From<ProtocolMsg> for Error2Rep {
499  #[inline]
500  fn from(item: ProtocolMsg) -> Error2Rep {
501    match item {
502      ProtocolMsg::Error2Rep(msg) => msg,
503      _ => panic!("Unable to convert to Error2Rep"),
504    }
505  }
506}
507
508impl From<ProtocolMsg> for PushReq {
509  #[inline]
510  fn from(item: ProtocolMsg) -> PushReq {
511    match item {
512      ProtocolMsg::PushReq(msg) => msg,
513      _ => panic!("Unable to convert to PushReq"),
514    }
515  }
516}
517
518impl From<ProtocolMsg> for PushRep {
519  #[inline]
520  fn from(item: ProtocolMsg) -> PushRep {
521    match item {
522      ProtocolMsg::PushRep(msg) => msg,
523      _ => panic!("Unable to convert to PushRep"),
524    }
525  }
526}
527
528impl From<ProtocolMsg> for PullReq {
529  #[inline]
530  fn from(item: ProtocolMsg) -> PullReq {
531    match item {
532      ProtocolMsg::PullReq(msg) => msg,
533      _ => panic!("Unable to convert to PullReq"),
534    }
535  }
536}
537
538impl From<ProtocolMsg> for PullRep {
539  #[inline]
540  fn from(item: ProtocolMsg) -> PullRep {
541    match item {
542      ProtocolMsg::PullRep(msg) => msg,
543      _ => panic!("Unable to convert to PullRep"),
544    }
545  }
546}
547
548impl From<ProtocolMsg> for ReqReq {
549  #[inline]
550  fn from(item: ProtocolMsg) -> ReqReq {
551    match item {
552      ProtocolMsg::ReqReq(msg) => msg,
553      _ => panic!("Unable to convert to ReqReq"),
554    }
555  }
556}
557
558impl From<ProtocolMsg> for ReqRep {
559  #[inline]
560  fn from(item: ProtocolMsg) -> ReqRep {
561    match item {
562      ProtocolMsg::ReqRep(msg) => msg,
563      _ => panic!("Unable to convert to ReqRep"),
564    }
565  }
566}
567
568impl From<ProtocolMsg> for AuthReq {
569  #[inline]
570  fn from(item: ProtocolMsg) -> AuthReq {
571    match item {
572      ProtocolMsg::AuthReq(msg) => msg,
573      _ => panic!("Unable to convert to AuthReq"),
574    }
575  }
576}
577
578impl From<ProtocolMsg> for AuthRep {
579  #[inline]
580  fn from(item: ProtocolMsg) -> AuthRep {
581    match item {
582      ProtocolMsg::AuthRep(msg) => msg,
583      _ => panic!("Unable to convert to AuthRep"),
584    }
585  }
586}
587
588impl From<ProtocolMsg> for RegisterFrontendReq {
589  #[inline]
590  fn from(item: ProtocolMsg) -> RegisterFrontendReq {
591    match item {
592      ProtocolMsg::RegisterFrontendReq(msg) => msg,
593      _ => panic!("Unable to convert to RegisterFrontendReq"),
594    }
595  }
596}
597
598impl From<ProtocolMsg> for RegisterFrontendRep {
599  #[inline]
600  fn from(item: ProtocolMsg) -> RegisterFrontendRep {
601    match item {
602      ProtocolMsg::RegisterFrontendRep(msg) => msg,
603      _ => panic!("Unable to convert to RegisterFrontendRep"),
604    }
605  }
606}
607
608impl From<ProtocolMsg> for RegisterBackendReq {
609  #[inline]
610  fn from(item: ProtocolMsg) -> RegisterBackendReq {
611    match item {
612      ProtocolMsg::RegisterBackendReq(msg) => msg,
613      _ => panic!("Unable to convert to RegisterBackendReq"),
614    }
615  }
616}
617
618impl From<ProtocolMsg> for RegisterBackendRep {
619  #[inline]
620  fn from(item: ProtocolMsg) -> RegisterBackendRep {
621    match item {
622      ProtocolMsg::RegisterBackendRep(msg) => msg,
623      _ => panic!("Unable to convert to RegisterBackendRep"),
624    }
625  }
626}
627
628impl From<ProtocolMsg> for RegisterServiceReq {
629  #[inline]
630  fn from(item: ProtocolMsg) -> RegisterServiceReq {
631    match item {
632      ProtocolMsg::RegisterServiceReq(msg) => msg,
633      _ => panic!("Unable to convert to RegisterServiceReq"),
634    }
635  }
636}
637
638impl From<ProtocolMsg> for RegisterServiceRep {
639  #[inline]
640  fn from(item: ProtocolMsg) -> RegisterServiceRep {
641    match item {
642      ProtocolMsg::RegisterServiceRep(msg) => msg,
643      _ => panic!("Unable to convert to RegisterServiceRep"),
644    }
645  }
646}
647
648impl From<ProtocolMsg> for SetRoutesReq {
649  #[inline]
650  fn from(item: ProtocolMsg) -> SetRoutesReq {
651    match item {
652      ProtocolMsg::SetRoutesReq(msg) => msg,
653      _ => panic!("Unable to convert to SetRoutesReq"),
654    }
655  }
656}
657
658impl From<ProtocolMsg> for SetRoutesRep {
659  #[inline]
660  fn from(item: ProtocolMsg) -> SetRoutesRep {
661    match item {
662      ProtocolMsg::SetRoutesRep(msg) => msg,
663      _ => panic!("Unable to convert to SetRoutesRep"),
664    }
665  }
666}
667
668impl From<ProtocolMsg> for GetRoutesReq {
669  #[inline]
670  fn from(item: ProtocolMsg) -> GetRoutesReq {
671    match item {
672      ProtocolMsg::GetRoutesReq(msg) => msg,
673      _ => panic!("Unable to convert to GetRoutesReq"),
674    }
675  }
676}
677
678impl From<ProtocolMsg> for GetRoutesRep {
679  #[inline]
680  fn from(item: ProtocolMsg) -> GetRoutesRep {
681    match item {
682      ProtocolMsg::GetRoutesRep(msg) => msg,
683      _ => panic!("Unable to convert to GetRoutesRep"),
684    }
685  }
686}
687
688impl From<ProtocolMsg> for GetTopicDistChecksumReq {
689  #[inline]
690  fn from(item: ProtocolMsg) -> GetTopicDistChecksumReq {
691    match item {
692      ProtocolMsg::GetTopicDistChecksumReq(msg) => msg,
693      _ => panic!("Unable to convert to GetTopicDistChecksumReq"),
694    }
695  }
696}
697
698impl From<ProtocolMsg> for GetTopicDistChecksumRep {
699  #[inline]
700  fn from(item: ProtocolMsg) -> GetTopicDistChecksumRep {
701    match item {
702      ProtocolMsg::GetTopicDistChecksumRep(msg) => msg,
703      _ => panic!("Unable to convert to GetTopicDistChecksumRep"),
704    }
705  }
706}
707
708impl From<ProtocolMsg> for GetRouteDistChecksumReq {
709  #[inline]
710  fn from(item: ProtocolMsg) -> GetRouteDistChecksumReq {
711    match item {
712      ProtocolMsg::GetRouteDistChecksumReq(msg) => msg,
713      _ => panic!("Unable to convert to GetRouteDistChecksumReq"),
714    }
715  }
716}
717
718impl From<ProtocolMsg> for GetRouteDistChecksumRep {
719  #[inline]
720  fn from(item: ProtocolMsg) -> GetRouteDistChecksumRep {
721    match item {
722      ProtocolMsg::GetRouteDistChecksumRep(msg) => msg,
723      _ => panic!("Unable to convert to GetRouteDistChecksumRep"),
724    }
725  }
726}
727
728impl From<ProtocolMsg> for PickFrontendReq {
729  #[inline]
730  fn from(item: ProtocolMsg) -> PickFrontendReq {
731    match item {
732      ProtocolMsg::PickFrontendReq(msg) => msg,
733      _ => panic!("Unable to convert to PickFrontendReq"),
734    }
735  }
736}
737
738impl From<ProtocolMsg> for PickFrontendRep {
739  #[inline]
740  fn from(item: ProtocolMsg) -> PickFrontendRep {
741    match item {
742      ProtocolMsg::PickFrontendRep(msg) => msg,
743      _ => panic!("Unable to convert to PickFrontendRep"),
744    }
745  }
746}
747
748impl From<ProtocolMsg> for PickFrontendsReq {
749  #[inline]
750  fn from(item: ProtocolMsg) -> PickFrontendsReq {
751    match item {
752      ProtocolMsg::PickFrontendsReq(msg) => msg,
753      _ => panic!("Unable to convert to PickFrontendsReq"),
754    }
755  }
756}
757
758impl From<ProtocolMsg> for PickFrontendsRep {
759  #[inline]
760  fn from(item: ProtocolMsg) -> PickFrontendsRep {
761    match item {
762      ProtocolMsg::PickFrontendsRep(msg) => msg,
763      _ => panic!("Unable to convert to PickFrontendsRep"),
764    }
765  }
766}
767
768impl From<ProtocolMsg> for LocateTopicReq {
769  #[inline]
770  fn from(item: ProtocolMsg) -> LocateTopicReq {
771    match item {
772      ProtocolMsg::LocateTopicReq(msg) => msg,
773      _ => panic!("Unable to convert to LocateTopicReq"),
774    }
775  }
776}
777
778impl From<ProtocolMsg> for LocateTopicRep {
779  #[inline]
780  fn from(item: ProtocolMsg) -> LocateTopicRep {
781    match item {
782      ProtocolMsg::LocateTopicRep(msg) => msg,
783      _ => panic!("Unable to convert to LocateTopicRep"),
784    }
785  }
786}
787
788impl From<ProtocolMsg> for ResolveIpReq {
789  #[inline]
790  fn from(item: ProtocolMsg) -> ResolveIpReq {
791    match item {
792      ProtocolMsg::ResolveIpReq(msg) => msg,
793      _ => panic!("Unable to convert to ResolveIpReq"),
794    }
795  }
796}
797
798impl From<ProtocolMsg> for ResolveIpRep {
799  #[inline]
800  fn from(item: ProtocolMsg) -> ResolveIpRep {
801    match item {
802      ProtocolMsg::ResolveIpRep(msg) => msg,
803      _ => panic!("Unable to convert to ResolveIpRep"),
804    }
805  }
806}
807
808pub trait Encode: ProstMessage + Sized {
809  fn encode_type(bytes: &mut BytesMut);
810
811  #[inline]
812  fn encode_body(&self, bytes: &mut BytesMut) {
813    if let Err(err) = self.encode(bytes) {
814      panic!("Failed to encode msg: {:?}", err);
815    }
816  }
817
818  fn encode_msg(&self) -> Bytes {
819    let size = self.encoded_len() as usize;
820    let mut bytes = BytesMut::with_capacity(size + 1);
821    Self::encode_type(&mut bytes);
822    self.encode_body(&mut bytes);
823    return bytes.freeze();
824  }
825}
826
827impl Encode for PingReq {
828  #[inline]
829  fn encode_type(bytes: &mut BytesMut) {
830    bytes.put_u8(1);
831  }
832}
833
834impl Encode for PingRep {
835  #[inline]
836  fn encode_type(bytes: &mut BytesMut) {
837    bytes.put_u8(2);
838  }
839}
840
841impl Encode for OkRep {
842  #[inline]
843  fn encode_type(bytes: &mut BytesMut) {
844    bytes.put_u8(29);
845  }
846}
847
848impl Encode for ErrorRep {
849  #[inline]
850  fn encode_type(bytes: &mut BytesMut) {
851    bytes.put_u8(30);
852  }
853}
854
855impl Encode for Ok2Rep {
856  #[inline]
857  fn encode_type(bytes: &mut BytesMut) {
858    bytes.put_u8(31);
859  }
860}
861
862impl Encode for Error2Rep {
863  #[inline]
864  fn encode_type(bytes: &mut BytesMut) {
865    bytes.put_u8(32);
866  }
867}
868
869impl Encode for PushReq {
870  #[inline]
871  fn encode_type(bytes: &mut BytesMut) {
872    bytes.put_u8(33);
873  }
874}
875
876impl Encode for PushRep {
877  #[inline]
878  fn encode_type(bytes: &mut BytesMut) {
879    bytes.put_u8(34);
880  }
881}
882
883impl Encode for PullReq {
884  #[inline]
885  fn encode_type(bytes: &mut BytesMut) {
886    bytes.put_u8(35);
887  }
888}
889
890impl Encode for PullRep {
891  #[inline]
892  fn encode_type(bytes: &mut BytesMut) {
893    bytes.put_u8(36);
894  }
895}
896
897impl Encode for ReqReq {
898  #[inline]
899  fn encode_type(bytes: &mut BytesMut) {
900    bytes.put_u8(39);
901  }
902}
903
904impl Encode for ReqRep {
905  #[inline]
906  fn encode_type(bytes: &mut BytesMut) {
907    bytes.put_u8(40);
908  }
909}
910
911impl Encode for AuthReq {
912  #[inline]
913  fn encode_type(bytes: &mut BytesMut) {
914    bytes.put_u8(41);
915  }
916}
917
918impl Encode for AuthRep {
919  #[inline]
920  fn encode_type(bytes: &mut BytesMut) {
921    bytes.put_u8(42);
922  }
923}
924
925impl Encode for RegisterFrontendReq {
926  #[inline]
927  fn encode_type(bytes: &mut BytesMut) {
928    bytes.put_u8(65);
929  }
930}
931
932impl Encode for RegisterFrontendRep {
933  #[inline]
934  fn encode_type(bytes: &mut BytesMut) {
935    bytes.put_u8(66);
936  }
937}
938
939impl Encode for RegisterBackendReq {
940  #[inline]
941  fn encode_type(bytes: &mut BytesMut) {
942    bytes.put_u8(67);
943  }
944}
945
946impl Encode for RegisterBackendRep {
947  #[inline]
948  fn encode_type(bytes: &mut BytesMut) {
949    bytes.put_u8(68);
950  }
951}
952
953impl Encode for RegisterServiceReq {
954  #[inline]
955  fn encode_type(bytes: &mut BytesMut) {
956    bytes.put_u8(69);
957  }
958}
959
960impl Encode for RegisterServiceRep {
961  #[inline]
962  fn encode_type(bytes: &mut BytesMut) {
963    bytes.put_u8(70);
964  }
965}
966
967impl Encode for SetRoutesReq {
968  #[inline]
969  fn encode_type(bytes: &mut BytesMut) {
970    bytes.put_u8(71);
971  }
972}
973
974impl Encode for SetRoutesRep {
975  #[inline]
976  fn encode_type(bytes: &mut BytesMut) {
977    bytes.put_u8(72);
978  }
979}
980
981impl Encode for GetRoutesReq {
982  #[inline]
983  fn encode_type(bytes: &mut BytesMut) {
984    bytes.put_u8(75);
985  }
986}
987
988impl Encode for GetRoutesRep {
989  #[inline]
990  fn encode_type(bytes: &mut BytesMut) {
991    bytes.put_u8(76);
992  }
993}
994
995impl Encode for GetTopicDistChecksumReq {
996  #[inline]
997  fn encode_type(bytes: &mut BytesMut) {
998    bytes.put_u8(77);
999  }
1000}
1001
1002impl Encode for GetTopicDistChecksumRep {
1003  #[inline]
1004  fn encode_type(bytes: &mut BytesMut) {
1005    bytes.put_u8(78);
1006  }
1007}
1008
1009impl Encode for GetRouteDistChecksumReq {
1010  #[inline]
1011  fn encode_type(bytes: &mut BytesMut) {
1012    bytes.put_u8(79);
1013  }
1014}
1015
1016impl Encode for GetRouteDistChecksumRep {
1017  #[inline]
1018  fn encode_type(bytes: &mut BytesMut) {
1019    bytes.put_u8(80);
1020  }
1021}
1022
1023impl Encode for PickFrontendReq {
1024  #[inline]
1025  fn encode_type(bytes: &mut BytesMut) {
1026    bytes.put_u8(81);
1027  }
1028}
1029
1030impl Encode for PickFrontendRep {
1031  #[inline]
1032  fn encode_type(bytes: &mut BytesMut) {
1033    bytes.put_u8(82);
1034  }
1035}
1036
1037impl Encode for PickFrontendsReq {
1038  #[inline]
1039  fn encode_type(bytes: &mut BytesMut) {
1040    bytes.put_u8(83);
1041  }
1042}
1043
1044impl Encode for PickFrontendsRep {
1045  #[inline]
1046  fn encode_type(bytes: &mut BytesMut) {
1047    bytes.put_u8(84);
1048  }
1049}
1050
1051impl Encode for LocateTopicReq {
1052  #[inline]
1053  fn encode_type(bytes: &mut BytesMut) {
1054    bytes.put_u8(85);
1055  }
1056}
1057
1058impl Encode for LocateTopicRep {
1059  #[inline]
1060  fn encode_type(bytes: &mut BytesMut) {
1061    bytes.put_u8(86);
1062  }
1063}
1064
1065impl Encode for ResolveIpReq {
1066  #[inline]
1067  fn encode_type(bytes: &mut BytesMut) {
1068    bytes.put_u8(121);
1069  }
1070}
1071
1072impl Encode for ResolveIpRep {
1073  #[inline]
1074  fn encode_type(bytes: &mut BytesMut) {
1075    bytes.put_u8(122);
1076  }
1077}
1078
1079pub fn encode(protocol_msg: &ProtocolMsg) -> Bytes {
1080  match protocol_msg {
1081    ProtocolMsg::None => panic!("Failed to encode ProtocolMsg::None"),
1082    ProtocolMsg::PingReq(msg) => msg.encode_msg(),
1083    ProtocolMsg::PingRep(msg) => msg.encode_msg(),
1084    ProtocolMsg::OkRep(msg) => msg.encode_msg(),
1085    ProtocolMsg::ErrorRep(msg) => msg.encode_msg(),
1086    ProtocolMsg::Ok2Rep(msg) => msg.encode_msg(),
1087    ProtocolMsg::Error2Rep(msg) => msg.encode_msg(),
1088    ProtocolMsg::PushReq(msg) => msg.encode_msg(),
1089    ProtocolMsg::PushRep(msg) => msg.encode_msg(),
1090    ProtocolMsg::PullReq(msg) => msg.encode_msg(),
1091    ProtocolMsg::PullRep(msg) => msg.encode_msg(),
1092    ProtocolMsg::ReqReq(msg) => msg.encode_msg(),
1093    ProtocolMsg::ReqRep(msg) => msg.encode_msg(),
1094    ProtocolMsg::AuthReq(msg) => msg.encode_msg(),
1095    ProtocolMsg::AuthRep(msg) => msg.encode_msg(),
1096    ProtocolMsg::RegisterFrontendReq(msg) => msg.encode_msg(),
1097    ProtocolMsg::RegisterFrontendRep(msg) => msg.encode_msg(),
1098    ProtocolMsg::RegisterBackendReq(msg) => msg.encode_msg(),
1099    ProtocolMsg::RegisterBackendRep(msg) => msg.encode_msg(),
1100    ProtocolMsg::RegisterServiceReq(msg) => msg.encode_msg(),
1101    ProtocolMsg::RegisterServiceRep(msg) => msg.encode_msg(),
1102    ProtocolMsg::SetRoutesReq(msg) => msg.encode_msg(),
1103    ProtocolMsg::SetRoutesRep(msg) => msg.encode_msg(),
1104    ProtocolMsg::GetRoutesReq(msg) => msg.encode_msg(),
1105    ProtocolMsg::GetRoutesRep(msg) => msg.encode_msg(),
1106    ProtocolMsg::GetTopicDistChecksumReq(msg) => msg.encode_msg(),
1107    ProtocolMsg::GetTopicDistChecksumRep(msg) => msg.encode_msg(),
1108    ProtocolMsg::GetRouteDistChecksumReq(msg) => msg.encode_msg(),
1109    ProtocolMsg::GetRouteDistChecksumRep(msg) => msg.encode_msg(),
1110    ProtocolMsg::PickFrontendReq(msg) => msg.encode_msg(),
1111    ProtocolMsg::PickFrontendRep(msg) => msg.encode_msg(),
1112    ProtocolMsg::PickFrontendsReq(msg) => msg.encode_msg(),
1113    ProtocolMsg::PickFrontendsRep(msg) => msg.encode_msg(),
1114    ProtocolMsg::LocateTopicReq(msg) => msg.encode_msg(),
1115    ProtocolMsg::LocateTopicRep(msg) => msg.encode_msg(),
1116    ProtocolMsg::ResolveIpReq(msg) => msg.encode_msg(),
1117    ProtocolMsg::ResolveIpRep(msg) => msg.encode_msg(),
1118  }
1119}
1120
1121pub fn decode(bytes: &Bytes) -> Result<ProtocolMsg, DecodeError> {
1122  decode_bytes(bytes.as_ref())
1123}
1124
1125pub fn decode_bytes(bytes: &[u8]) -> Result<ProtocolMsg, DecodeError> {
1126  let msg_type = bytes[0] as i8;
1127  let msg_body = &bytes[1..];
1128  if msg_type == 1 {
1129    let res: Result<PingReq, DecodeError> = ProstMessage::decode(msg_body);
1130    match res {
1131      Ok(msg) => Ok(ProtocolMsg::PingReq(msg)),
1132      Err(err) => Err(err),
1133    }
1134  } else if msg_type == 2 {
1135    let res: Result<PingRep, DecodeError> = ProstMessage::decode(msg_body);
1136    match res {
1137      Ok(msg) => Ok(ProtocolMsg::PingRep(msg)),
1138      Err(err) => Err(err),
1139    }
1140  } else if msg_type == 29 {
1141    let res: Result<OkRep, DecodeError> = ProstMessage::decode(msg_body);
1142    match res {
1143      Ok(msg) => Ok(ProtocolMsg::OkRep(msg)),
1144      Err(err) => Err(err),
1145    }
1146  } else if msg_type == 30 {
1147    let res: Result<ErrorRep, DecodeError> = ProstMessage::decode(msg_body);
1148    match res {
1149      Ok(msg) => Ok(ProtocolMsg::ErrorRep(msg)),
1150      Err(err) => Err(err),
1151    }
1152  } else if msg_type == 31 {
1153    let res: Result<Ok2Rep, DecodeError> = ProstMessage::decode(msg_body);
1154    match res {
1155      Ok(msg) => Ok(ProtocolMsg::Ok2Rep(msg)),
1156      Err(err) => Err(err),
1157    }
1158  } else if msg_type == 32 {
1159    let res: Result<Error2Rep, DecodeError> = ProstMessage::decode(msg_body);
1160    match res {
1161      Ok(msg) => Ok(ProtocolMsg::Error2Rep(msg)),
1162      Err(err) => Err(err),
1163    }
1164  } else if msg_type == 33 {
1165    let res: Result<PushReq, DecodeError> = ProstMessage::decode(msg_body);
1166    match res {
1167      Ok(msg) => Ok(ProtocolMsg::PushReq(msg)),
1168      Err(err) => Err(err),
1169    }
1170  } else if msg_type == 34 {
1171    let res: Result<PushRep, DecodeError> = ProstMessage::decode(msg_body);
1172    match res {
1173      Ok(msg) => Ok(ProtocolMsg::PushRep(msg)),
1174      Err(err) => Err(err),
1175    }
1176  } else if msg_type == 35 {
1177    let res: Result<PullReq, DecodeError> = ProstMessage::decode(msg_body);
1178    match res {
1179      Ok(msg) => Ok(ProtocolMsg::PullReq(msg)),
1180      Err(err) => Err(err),
1181    }
1182  } else if msg_type == 36 {
1183    let res: Result<PullRep, DecodeError> = ProstMessage::decode(msg_body);
1184    match res {
1185      Ok(msg) => Ok(ProtocolMsg::PullRep(msg)),
1186      Err(err) => Err(err),
1187    }
1188  } else if msg_type == 39 {
1189    let res: Result<ReqReq, DecodeError> = ProstMessage::decode(msg_body);
1190    match res {
1191      Ok(msg) => Ok(ProtocolMsg::ReqReq(msg)),
1192      Err(err) => Err(err),
1193    }
1194  } else if msg_type == 40 {
1195    let res: Result<ReqRep, DecodeError> = ProstMessage::decode(msg_body);
1196    match res {
1197      Ok(msg) => Ok(ProtocolMsg::ReqRep(msg)),
1198      Err(err) => Err(err),
1199    }
1200  } else if msg_type == 41 {
1201    let res: Result<AuthReq, DecodeError> = ProstMessage::decode(msg_body);
1202    match res {
1203      Ok(msg) => Ok(ProtocolMsg::AuthReq(msg)),
1204      Err(err) => Err(err),
1205    }
1206  } else if msg_type == 42 {
1207    let res: Result<AuthRep, DecodeError> = ProstMessage::decode(msg_body);
1208    match res {
1209      Ok(msg) => Ok(ProtocolMsg::AuthRep(msg)),
1210      Err(err) => Err(err),
1211    }
1212  } else if msg_type == 65 {
1213    let res: Result<RegisterFrontendReq, DecodeError> = ProstMessage::decode(msg_body);
1214    match res {
1215      Ok(msg) => Ok(ProtocolMsg::RegisterFrontendReq(msg)),
1216      Err(err) => Err(err),
1217    }
1218  } else if msg_type == 66 {
1219    let res: Result<RegisterFrontendRep, DecodeError> = ProstMessage::decode(msg_body);
1220    match res {
1221      Ok(msg) => Ok(ProtocolMsg::RegisterFrontendRep(msg)),
1222      Err(err) => Err(err),
1223    }
1224  } else if msg_type == 67 {
1225    let res: Result<RegisterBackendReq, DecodeError> = ProstMessage::decode(msg_body);
1226    match res {
1227      Ok(msg) => Ok(ProtocolMsg::RegisterBackendReq(msg)),
1228      Err(err) => Err(err),
1229    }
1230  } else if msg_type == 68 {
1231    let res: Result<RegisterBackendRep, DecodeError> = ProstMessage::decode(msg_body);
1232    match res {
1233      Ok(msg) => Ok(ProtocolMsg::RegisterBackendRep(msg)),
1234      Err(err) => Err(err),
1235    }
1236  } else if msg_type == 69 {
1237    let res: Result<RegisterServiceReq, DecodeError> = ProstMessage::decode(msg_body);
1238    match res {
1239      Ok(msg) => Ok(ProtocolMsg::RegisterServiceReq(msg)),
1240      Err(err) => Err(err),
1241    }
1242  } else if msg_type == 70 {
1243    let res: Result<RegisterServiceRep, DecodeError> = ProstMessage::decode(msg_body);
1244    match res {
1245      Ok(msg) => Ok(ProtocolMsg::RegisterServiceRep(msg)),
1246      Err(err) => Err(err),
1247    }
1248  } else if msg_type == 71 {
1249    let res: Result<SetRoutesReq, DecodeError> = ProstMessage::decode(msg_body);
1250    match res {
1251      Ok(msg) => Ok(ProtocolMsg::SetRoutesReq(msg)),
1252      Err(err) => Err(err),
1253    }
1254  } else if msg_type == 72 {
1255    let res: Result<SetRoutesRep, DecodeError> = ProstMessage::decode(msg_body);
1256    match res {
1257      Ok(msg) => Ok(ProtocolMsg::SetRoutesRep(msg)),
1258      Err(err) => Err(err),
1259    }
1260  } else if msg_type == 75 {
1261    let res: Result<GetRoutesReq, DecodeError> = ProstMessage::decode(msg_body);
1262    match res {
1263      Ok(msg) => Ok(ProtocolMsg::GetRoutesReq(msg)),
1264      Err(err) => Err(err),
1265    }
1266  } else if msg_type == 76 {
1267    let res: Result<GetRoutesRep, DecodeError> = ProstMessage::decode(msg_body);
1268    match res {
1269      Ok(msg) => Ok(ProtocolMsg::GetRoutesRep(msg)),
1270      Err(err) => Err(err),
1271    }
1272  } else if msg_type == 77 {
1273    let res: Result<GetTopicDistChecksumReq, DecodeError> = ProstMessage::decode(msg_body);
1274    match res {
1275      Ok(msg) => Ok(ProtocolMsg::GetTopicDistChecksumReq(msg)),
1276      Err(err) => Err(err),
1277    }
1278  } else if msg_type == 78 {
1279    let res: Result<GetTopicDistChecksumRep, DecodeError> = ProstMessage::decode(msg_body);
1280    match res {
1281      Ok(msg) => Ok(ProtocolMsg::GetTopicDistChecksumRep(msg)),
1282      Err(err) => Err(err),
1283    }
1284  } else if msg_type == 79 {
1285    let res: Result<GetRouteDistChecksumReq, DecodeError> = ProstMessage::decode(msg_body);
1286    match res {
1287      Ok(msg) => Ok(ProtocolMsg::GetRouteDistChecksumReq(msg)),
1288      Err(err) => Err(err),
1289    }
1290  } else if msg_type == 80 {
1291    let res: Result<GetRouteDistChecksumRep, DecodeError> = ProstMessage::decode(msg_body);
1292    match res {
1293      Ok(msg) => Ok(ProtocolMsg::GetRouteDistChecksumRep(msg)),
1294      Err(err) => Err(err),
1295    }
1296  } else if msg_type == 81 {
1297    let res: Result<PickFrontendReq, DecodeError> = ProstMessage::decode(msg_body);
1298    match res {
1299      Ok(msg) => Ok(ProtocolMsg::PickFrontendReq(msg)),
1300      Err(err) => Err(err),
1301    }
1302  } else if msg_type == 82 {
1303    let res: Result<PickFrontendRep, DecodeError> = ProstMessage::decode(msg_body);
1304    match res {
1305      Ok(msg) => Ok(ProtocolMsg::PickFrontendRep(msg)),
1306      Err(err) => Err(err),
1307    }
1308  } else if msg_type == 83 {
1309    let res: Result<PickFrontendsReq, DecodeError> = ProstMessage::decode(msg_body);
1310    match res {
1311      Ok(msg) => Ok(ProtocolMsg::PickFrontendsReq(msg)),
1312      Err(err) => Err(err),
1313    }
1314  } else if msg_type == 84 {
1315    let res: Result<PickFrontendsRep, DecodeError> = ProstMessage::decode(msg_body);
1316    match res {
1317      Ok(msg) => Ok(ProtocolMsg::PickFrontendsRep(msg)),
1318      Err(err) => Err(err),
1319    }
1320  } else if msg_type == 85 {
1321    let res: Result<LocateTopicReq, DecodeError> = ProstMessage::decode(msg_body);
1322    match res {
1323      Ok(msg) => Ok(ProtocolMsg::LocateTopicReq(msg)),
1324      Err(err) => Err(err),
1325    }
1326  } else if msg_type == 86 {
1327    let res: Result<LocateTopicRep, DecodeError> = ProstMessage::decode(msg_body);
1328    match res {
1329      Ok(msg) => Ok(ProtocolMsg::LocateTopicRep(msg)),
1330      Err(err) => Err(err),
1331    }
1332  } else if msg_type == 121 {
1333    let res: Result<ResolveIpReq, DecodeError> = ProstMessage::decode(msg_body);
1334    match res {
1335      Ok(msg) => Ok(ProtocolMsg::ResolveIpReq(msg)),
1336      Err(err) => Err(err),
1337    }
1338  } else if msg_type == 122 {
1339    let res: Result<ResolveIpRep, DecodeError> = ProstMessage::decode(msg_body);
1340    match res {
1341      Ok(msg) => Ok(ProtocolMsg::ResolveIpRep(msg)),
1342      Err(err) => Err(err),
1343    }
1344  } else {
1345    Err(DecodeError::new(format!("Invalid msg type: {}", msg_type)))
1346  }
1347}
1348
1349pub fn set_ref(protocol_msg: &mut ProtocolMsg, r#ref: u32) -> &ProtocolMsg {
1350  match protocol_msg {
1351    ProtocolMsg::None => panic!("Failed to set ref for ProtocolMsg::None"),
1352    ProtocolMsg::PingReq(msg) => msg.r#ref = r#ref,
1353    ProtocolMsg::PingRep(msg) => msg.r#ref = r#ref,
1354    ProtocolMsg::OkRep(msg) => msg.r#ref = r#ref,
1355    ProtocolMsg::ErrorRep(msg) => msg.r#ref = r#ref,
1356    ProtocolMsg::Ok2Rep(msg) => msg.r#ref = r#ref,
1357    ProtocolMsg::Error2Rep(msg) => msg.r#ref = r#ref,
1358    ProtocolMsg::PushReq(msg) => msg.r#ref = r#ref,
1359    ProtocolMsg::PushRep(msg) => msg.r#ref = r#ref,
1360    ProtocolMsg::PullReq(msg) => msg.r#ref = r#ref,
1361    ProtocolMsg::PullRep(msg) => msg.r#ref = r#ref,
1362    ProtocolMsg::ReqReq(msg) => msg.r#ref = r#ref,
1363    ProtocolMsg::ReqRep(msg) => msg.r#ref = r#ref,
1364    ProtocolMsg::AuthReq(msg) => msg.r#ref = r#ref,
1365    ProtocolMsg::AuthRep(msg) => msg.r#ref = r#ref,
1366    ProtocolMsg::RegisterFrontendReq(msg) => msg.r#ref = r#ref,
1367    ProtocolMsg::RegisterFrontendRep(msg) => msg.r#ref = r#ref,
1368    ProtocolMsg::RegisterBackendReq(msg) => msg.r#ref = r#ref,
1369    ProtocolMsg::RegisterBackendRep(msg) => msg.r#ref = r#ref,
1370    ProtocolMsg::RegisterServiceReq(msg) => msg.r#ref = r#ref,
1371    ProtocolMsg::RegisterServiceRep(msg) => msg.r#ref = r#ref,
1372    ProtocolMsg::SetRoutesReq(msg) => msg.r#ref = r#ref,
1373    ProtocolMsg::SetRoutesRep(msg) => msg.r#ref = r#ref,
1374    ProtocolMsg::GetRoutesReq(msg) => msg.r#ref = r#ref,
1375    ProtocolMsg::GetRoutesRep(msg) => msg.r#ref = r#ref,
1376    ProtocolMsg::GetTopicDistChecksumReq(msg) => msg.r#ref = r#ref,
1377    ProtocolMsg::GetTopicDistChecksumRep(msg) => msg.r#ref = r#ref,
1378    ProtocolMsg::GetRouteDistChecksumReq(msg) => msg.r#ref = r#ref,
1379    ProtocolMsg::GetRouteDistChecksumRep(msg) => msg.r#ref = r#ref,
1380    ProtocolMsg::PickFrontendReq(msg) => msg.r#ref = r#ref,
1381    ProtocolMsg::PickFrontendRep(msg) => msg.r#ref = r#ref,
1382    ProtocolMsg::PickFrontendsReq(msg) => msg.r#ref = r#ref,
1383    ProtocolMsg::PickFrontendsRep(msg) => msg.r#ref = r#ref,
1384    ProtocolMsg::LocateTopicReq(msg) => msg.r#ref = r#ref,
1385    ProtocolMsg::LocateTopicRep(msg) => msg.r#ref = r#ref,
1386    ProtocolMsg::ResolveIpReq(msg) => msg.r#ref = r#ref,
1387    ProtocolMsg::ResolveIpRep(msg) => msg.r#ref = r#ref,
1388  }
1389  protocol_msg
1390}
1391
1392pub fn get_ref(protocol_msg: &ProtocolMsg) -> u32 {
1393  match protocol_msg {
1394    ProtocolMsg::None => panic!("Failed to get ref from ProtocolMsg::None"),
1395    ProtocolMsg::PingReq(msg) => msg.r#ref,
1396    ProtocolMsg::PingRep(msg) => msg.r#ref,
1397    ProtocolMsg::OkRep(msg) => msg.r#ref,
1398    ProtocolMsg::ErrorRep(msg) => msg.r#ref,
1399    ProtocolMsg::Ok2Rep(msg) => msg.r#ref,
1400    ProtocolMsg::Error2Rep(msg) => msg.r#ref,
1401    ProtocolMsg::PushReq(msg) => msg.r#ref,
1402    ProtocolMsg::PushRep(msg) => msg.r#ref,
1403    ProtocolMsg::PullReq(msg) => msg.r#ref,
1404    ProtocolMsg::PullRep(msg) => msg.r#ref,
1405    ProtocolMsg::ReqReq(msg) => msg.r#ref,
1406    ProtocolMsg::ReqRep(msg) => msg.r#ref,
1407    ProtocolMsg::AuthReq(msg) => msg.r#ref,
1408    ProtocolMsg::AuthRep(msg) => msg.r#ref,
1409    ProtocolMsg::RegisterFrontendReq(msg) => msg.r#ref,
1410    ProtocolMsg::RegisterFrontendRep(msg) => msg.r#ref,
1411    ProtocolMsg::RegisterBackendReq(msg) => msg.r#ref,
1412    ProtocolMsg::RegisterBackendRep(msg) => msg.r#ref,
1413    ProtocolMsg::RegisterServiceReq(msg) => msg.r#ref,
1414    ProtocolMsg::RegisterServiceRep(msg) => msg.r#ref,
1415    ProtocolMsg::SetRoutesReq(msg) => msg.r#ref,
1416    ProtocolMsg::SetRoutesRep(msg) => msg.r#ref,
1417    ProtocolMsg::GetRoutesReq(msg) => msg.r#ref,
1418    ProtocolMsg::GetRoutesRep(msg) => msg.r#ref,
1419    ProtocolMsg::GetTopicDistChecksumReq(msg) => msg.r#ref,
1420    ProtocolMsg::GetTopicDistChecksumRep(msg) => msg.r#ref,
1421    ProtocolMsg::GetRouteDistChecksumReq(msg) => msg.r#ref,
1422    ProtocolMsg::GetRouteDistChecksumRep(msg) => msg.r#ref,
1423    ProtocolMsg::PickFrontendReq(msg) => msg.r#ref,
1424    ProtocolMsg::PickFrontendRep(msg) => msg.r#ref,
1425    ProtocolMsg::PickFrontendsReq(msg) => msg.r#ref,
1426    ProtocolMsg::PickFrontendsRep(msg) => msg.r#ref,
1427    ProtocolMsg::LocateTopicReq(msg) => msg.r#ref,
1428    ProtocolMsg::LocateTopicRep(msg) => msg.r#ref,
1429    ProtocolMsg::ResolveIpReq(msg) => msg.r#ref,
1430    ProtocolMsg::ResolveIpRep(msg) => msg.r#ref,
1431  }
1432}
maxwell_protocol/protocol/maxwell_protocol_ext.rs

maxwell_protocol/protocol/
maxwell_protocol_ext.rs
