1 // This file is generated by rust-protobuf 3.2.0. Do not edit
2 // .proto file is parsed by protoc 3.21.12
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 `frontend.proto`
23
24 /// Generated files are compatible only with the same version
25 /// of protobuf runtime.
26 const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_2_0;
27
28 #[derive(PartialEq,Clone,Default,Debug)]
29 // @@protoc_insertion_point(message:netsim.frontend.VersionResponse)
30 pub struct VersionResponse {
31 // message fields
32 // @@protoc_insertion_point(field:netsim.frontend.VersionResponse.version)
33 pub version: ::std::string::String,
34 // special fields
35 // @@protoc_insertion_point(special_field:netsim.frontend.VersionResponse.special_fields)
36 pub special_fields: ::protobuf::SpecialFields,
37 }
38
39 impl<'a> ::std::default::Default for &'a VersionResponse {
default() -> &'a VersionResponse40 fn default() -> &'a VersionResponse {
41 <VersionResponse as ::protobuf::Message>::default_instance()
42 }
43 }
44
45 impl VersionResponse {
new() -> VersionResponse46 pub fn new() -> VersionResponse {
47 ::std::default::Default::default()
48 }
49
generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData50 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
51 let mut fields = ::std::vec::Vec::with_capacity(1);
52 let mut oneofs = ::std::vec::Vec::with_capacity(0);
53 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
54 "version",
55 |m: &VersionResponse| { &m.version },
56 |m: &mut VersionResponse| { &mut m.version },
57 ));
58 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<VersionResponse>(
59 "VersionResponse",
60 fields,
61 oneofs,
62 )
63 }
64 }
65
66 impl ::protobuf::Message for VersionResponse {
67 const NAME: &'static str = "VersionResponse";
68
is_initialized(&self) -> bool69 fn is_initialized(&self) -> bool {
70 true
71 }
72
merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()>73 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
74 while let Some(tag) = is.read_raw_tag_or_eof()? {
75 match tag {
76 10 => {
77 self.version = is.read_string()?;
78 },
79 tag => {
80 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
81 },
82 };
83 }
84 ::std::result::Result::Ok(())
85 }
86
87 // Compute sizes of nested messages
88 #[allow(unused_variables)]
compute_size(&self) -> u6489 fn compute_size(&self) -> u64 {
90 let mut my_size = 0;
91 if !self.version.is_empty() {
92 my_size += ::protobuf::rt::string_size(1, &self.version);
93 }
94 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
95 self.special_fields.cached_size().set(my_size as u32);
96 my_size
97 }
98
write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()>99 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
100 if !self.version.is_empty() {
101 os.write_string(1, &self.version)?;
102 }
103 os.write_unknown_fields(self.special_fields.unknown_fields())?;
104 ::std::result::Result::Ok(())
105 }
106
special_fields(&self) -> &::protobuf::SpecialFields107 fn special_fields(&self) -> &::protobuf::SpecialFields {
108 &self.special_fields
109 }
110
mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields111 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
112 &mut self.special_fields
113 }
114
new() -> VersionResponse115 fn new() -> VersionResponse {
116 VersionResponse::new()
117 }
118
clear(&mut self)119 fn clear(&mut self) {
120 self.version.clear();
121 self.special_fields.clear();
122 }
123
default_instance() -> &'static VersionResponse124 fn default_instance() -> &'static VersionResponse {
125 static instance: VersionResponse = VersionResponse {
126 version: ::std::string::String::new(),
127 special_fields: ::protobuf::SpecialFields::new(),
128 };
129 &instance
130 }
131 }
132
133 impl ::protobuf::MessageFull for VersionResponse {
descriptor() -> ::protobuf::reflect::MessageDescriptor134 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
135 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
136 descriptor.get(|| file_descriptor().message_by_package_relative_name("VersionResponse").unwrap()).clone()
137 }
138 }
139
140 impl ::std::fmt::Display for VersionResponse {
fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result141 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
142 ::protobuf::text_format::fmt(self, f)
143 }
144 }
145
146 impl ::protobuf::reflect::ProtobufValue for VersionResponse {
147 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
148 }
149
150 #[derive(PartialEq,Clone,Default,Debug)]
151 // @@protoc_insertion_point(message:netsim.frontend.SetLinkLossRequest)
152 pub struct SetLinkLossRequest {
153 // message fields
154 // @@protoc_insertion_point(field:netsim.frontend.SetLinkLossRequest.device_name)
155 pub device_name: ::std::string::String,
156 // @@protoc_insertion_point(field:netsim.frontend.SetLinkLossRequest.other_device)
157 pub other_device: ::std::string::String,
158 // @@protoc_insertion_point(field:netsim.frontend.SetLinkLossRequest.radio)
159 pub radio: ::protobuf::EnumOrUnknown<super::model::PhyKind>,
160 // @@protoc_insertion_point(field:netsim.frontend.SetLinkLossRequest.link_loss)
161 pub link_loss: f32,
162 // special fields
163 // @@protoc_insertion_point(special_field:netsim.frontend.SetLinkLossRequest.special_fields)
164 pub special_fields: ::protobuf::SpecialFields,
165 }
166
167 impl<'a> ::std::default::Default for &'a SetLinkLossRequest {
default() -> &'a SetLinkLossRequest168 fn default() -> &'a SetLinkLossRequest {
169 <SetLinkLossRequest as ::protobuf::Message>::default_instance()
170 }
171 }
172
173 impl SetLinkLossRequest {
new() -> SetLinkLossRequest174 pub fn new() -> SetLinkLossRequest {
175 ::std::default::Default::default()
176 }
177
generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData178 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
179 let mut fields = ::std::vec::Vec::with_capacity(4);
180 let mut oneofs = ::std::vec::Vec::with_capacity(0);
181 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
182 "device_name",
183 |m: &SetLinkLossRequest| { &m.device_name },
184 |m: &mut SetLinkLossRequest| { &mut m.device_name },
185 ));
186 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
187 "other_device",
188 |m: &SetLinkLossRequest| { &m.other_device },
189 |m: &mut SetLinkLossRequest| { &mut m.other_device },
190 ));
191 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
192 "radio",
193 |m: &SetLinkLossRequest| { &m.radio },
194 |m: &mut SetLinkLossRequest| { &mut m.radio },
195 ));
196 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
197 "link_loss",
198 |m: &SetLinkLossRequest| { &m.link_loss },
199 |m: &mut SetLinkLossRequest| { &mut m.link_loss },
200 ));
201 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetLinkLossRequest>(
202 "SetLinkLossRequest",
203 fields,
204 oneofs,
205 )
206 }
207 }
208
209 impl ::protobuf::Message for SetLinkLossRequest {
210 const NAME: &'static str = "SetLinkLossRequest";
211
is_initialized(&self) -> bool212 fn is_initialized(&self) -> bool {
213 true
214 }
215
merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()>216 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
217 while let Some(tag) = is.read_raw_tag_or_eof()? {
218 match tag {
219 10 => {
220 self.device_name = is.read_string()?;
221 },
222 18 => {
223 self.other_device = is.read_string()?;
224 },
225 24 => {
226 self.radio = is.read_enum_or_unknown()?;
227 },
228 37 => {
229 self.link_loss = is.read_float()?;
230 },
231 tag => {
232 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
233 },
234 };
235 }
236 ::std::result::Result::Ok(())
237 }
238
239 // Compute sizes of nested messages
240 #[allow(unused_variables)]
compute_size(&self) -> u64241 fn compute_size(&self) -> u64 {
242 let mut my_size = 0;
243 if !self.device_name.is_empty() {
244 my_size += ::protobuf::rt::string_size(1, &self.device_name);
245 }
246 if !self.other_device.is_empty() {
247 my_size += ::protobuf::rt::string_size(2, &self.other_device);
248 }
249 if self.radio != ::protobuf::EnumOrUnknown::new(super::model::PhyKind::NONE) {
250 my_size += ::protobuf::rt::int32_size(3, self.radio.value());
251 }
252 if self.link_loss != 0. {
253 my_size += 1 + 4;
254 }
255 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
256 self.special_fields.cached_size().set(my_size as u32);
257 my_size
258 }
259
write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()>260 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
261 if !self.device_name.is_empty() {
262 os.write_string(1, &self.device_name)?;
263 }
264 if !self.other_device.is_empty() {
265 os.write_string(2, &self.other_device)?;
266 }
267 if self.radio != ::protobuf::EnumOrUnknown::new(super::model::PhyKind::NONE) {
268 os.write_enum(3, ::protobuf::EnumOrUnknown::value(&self.radio))?;
269 }
270 if self.link_loss != 0. {
271 os.write_float(4, self.link_loss)?;
272 }
273 os.write_unknown_fields(self.special_fields.unknown_fields())?;
274 ::std::result::Result::Ok(())
275 }
276
special_fields(&self) -> &::protobuf::SpecialFields277 fn special_fields(&self) -> &::protobuf::SpecialFields {
278 &self.special_fields
279 }
280
mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields281 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
282 &mut self.special_fields
283 }
284
new() -> SetLinkLossRequest285 fn new() -> SetLinkLossRequest {
286 SetLinkLossRequest::new()
287 }
288
clear(&mut self)289 fn clear(&mut self) {
290 self.device_name.clear();
291 self.other_device.clear();
292 self.radio = ::protobuf::EnumOrUnknown::new(super::model::PhyKind::NONE);
293 self.link_loss = 0.;
294 self.special_fields.clear();
295 }
296
default_instance() -> &'static SetLinkLossRequest297 fn default_instance() -> &'static SetLinkLossRequest {
298 static instance: SetLinkLossRequest = SetLinkLossRequest {
299 device_name: ::std::string::String::new(),
300 other_device: ::std::string::String::new(),
301 radio: ::protobuf::EnumOrUnknown::from_i32(0),
302 link_loss: 0.,
303 special_fields: ::protobuf::SpecialFields::new(),
304 };
305 &instance
306 }
307 }
308
309 impl ::protobuf::MessageFull for SetLinkLossRequest {
descriptor() -> ::protobuf::reflect::MessageDescriptor310 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
311 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
312 descriptor.get(|| file_descriptor().message_by_package_relative_name("SetLinkLossRequest").unwrap()).clone()
313 }
314 }
315
316 impl ::std::fmt::Display for SetLinkLossRequest {
fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result317 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
318 ::protobuf::text_format::fmt(self, f)
319 }
320 }
321
322 impl ::protobuf::reflect::ProtobufValue for SetLinkLossRequest {
323 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
324 }
325
326 #[derive(PartialEq,Clone,Default,Debug)]
327 // @@protoc_insertion_point(message:netsim.frontend.PatchDeviceRequest)
328 pub struct PatchDeviceRequest {
329 // message fields
330 // @@protoc_insertion_point(field:netsim.frontend.PatchDeviceRequest.device)
331 pub device: ::protobuf::MessageField<super::model::Device>,
332 // special fields
333 // @@protoc_insertion_point(special_field:netsim.frontend.PatchDeviceRequest.special_fields)
334 pub special_fields: ::protobuf::SpecialFields,
335 }
336
337 impl<'a> ::std::default::Default for &'a PatchDeviceRequest {
default() -> &'a PatchDeviceRequest338 fn default() -> &'a PatchDeviceRequest {
339 <PatchDeviceRequest as ::protobuf::Message>::default_instance()
340 }
341 }
342
343 impl PatchDeviceRequest {
new() -> PatchDeviceRequest344 pub fn new() -> PatchDeviceRequest {
345 ::std::default::Default::default()
346 }
347
generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData348 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
349 let mut fields = ::std::vec::Vec::with_capacity(1);
350 let mut oneofs = ::std::vec::Vec::with_capacity(0);
351 fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::model::Device>(
352 "device",
353 |m: &PatchDeviceRequest| { &m.device },
354 |m: &mut PatchDeviceRequest| { &mut m.device },
355 ));
356 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PatchDeviceRequest>(
357 "PatchDeviceRequest",
358 fields,
359 oneofs,
360 )
361 }
362 }
363
364 impl ::protobuf::Message for PatchDeviceRequest {
365 const NAME: &'static str = "PatchDeviceRequest";
366
is_initialized(&self) -> bool367 fn is_initialized(&self) -> bool {
368 true
369 }
370
merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()>371 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
372 while let Some(tag) = is.read_raw_tag_or_eof()? {
373 match tag {
374 18 => {
375 ::protobuf::rt::read_singular_message_into_field(is, &mut self.device)?;
376 },
377 tag => {
378 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
379 },
380 };
381 }
382 ::std::result::Result::Ok(())
383 }
384
385 // Compute sizes of nested messages
386 #[allow(unused_variables)]
compute_size(&self) -> u64387 fn compute_size(&self) -> u64 {
388 let mut my_size = 0;
389 if let Some(v) = self.device.as_ref() {
390 let len = v.compute_size();
391 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
392 }
393 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
394 self.special_fields.cached_size().set(my_size as u32);
395 my_size
396 }
397
write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()>398 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
399 if let Some(v) = self.device.as_ref() {
400 ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
401 }
402 os.write_unknown_fields(self.special_fields.unknown_fields())?;
403 ::std::result::Result::Ok(())
404 }
405
special_fields(&self) -> &::protobuf::SpecialFields406 fn special_fields(&self) -> &::protobuf::SpecialFields {
407 &self.special_fields
408 }
409
mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields410 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
411 &mut self.special_fields
412 }
413
new() -> PatchDeviceRequest414 fn new() -> PatchDeviceRequest {
415 PatchDeviceRequest::new()
416 }
417
clear(&mut self)418 fn clear(&mut self) {
419 self.device.clear();
420 self.special_fields.clear();
421 }
422
default_instance() -> &'static PatchDeviceRequest423 fn default_instance() -> &'static PatchDeviceRequest {
424 static instance: PatchDeviceRequest = PatchDeviceRequest {
425 device: ::protobuf::MessageField::none(),
426 special_fields: ::protobuf::SpecialFields::new(),
427 };
428 &instance
429 }
430 }
431
432 impl ::protobuf::MessageFull for PatchDeviceRequest {
descriptor() -> ::protobuf::reflect::MessageDescriptor433 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
434 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
435 descriptor.get(|| file_descriptor().message_by_package_relative_name("PatchDeviceRequest").unwrap()).clone()
436 }
437 }
438
439 impl ::std::fmt::Display for PatchDeviceRequest {
fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result440 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
441 ::protobuf::text_format::fmt(self, f)
442 }
443 }
444
445 impl ::protobuf::reflect::ProtobufValue for PatchDeviceRequest {
446 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
447 }
448
449 #[derive(PartialEq,Clone,Default,Debug)]
450 // @@protoc_insertion_point(message:netsim.frontend.Event)
451 pub struct Event {
452 // message fields
453 // @@protoc_insertion_point(field:netsim.frontend.Event.devices)
454 pub devices: ::std::vec::Vec<super::model::Device>,
455 // special fields
456 // @@protoc_insertion_point(special_field:netsim.frontend.Event.special_fields)
457 pub special_fields: ::protobuf::SpecialFields,
458 }
459
460 impl<'a> ::std::default::Default for &'a Event {
default() -> &'a Event461 fn default() -> &'a Event {
462 <Event as ::protobuf::Message>::default_instance()
463 }
464 }
465
466 impl Event {
new() -> Event467 pub fn new() -> Event {
468 ::std::default::Default::default()
469 }
470
generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData471 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
472 let mut fields = ::std::vec::Vec::with_capacity(1);
473 let mut oneofs = ::std::vec::Vec::with_capacity(0);
474 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
475 "devices",
476 |m: &Event| { &m.devices },
477 |m: &mut Event| { &mut m.devices },
478 ));
479 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Event>(
480 "Event",
481 fields,
482 oneofs,
483 )
484 }
485 }
486
487 impl ::protobuf::Message for Event {
488 const NAME: &'static str = "Event";
489
is_initialized(&self) -> bool490 fn is_initialized(&self) -> bool {
491 true
492 }
493
merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()>494 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
495 while let Some(tag) = is.read_raw_tag_or_eof()? {
496 match tag {
497 10 => {
498 self.devices.push(is.read_message()?);
499 },
500 tag => {
501 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
502 },
503 };
504 }
505 ::std::result::Result::Ok(())
506 }
507
508 // Compute sizes of nested messages
509 #[allow(unused_variables)]
compute_size(&self) -> u64510 fn compute_size(&self) -> u64 {
511 let mut my_size = 0;
512 for value in &self.devices {
513 let len = value.compute_size();
514 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
515 };
516 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
517 self.special_fields.cached_size().set(my_size as u32);
518 my_size
519 }
520
write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()>521 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
522 for v in &self.devices {
523 ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
524 };
525 os.write_unknown_fields(self.special_fields.unknown_fields())?;
526 ::std::result::Result::Ok(())
527 }
528
special_fields(&self) -> &::protobuf::SpecialFields529 fn special_fields(&self) -> &::protobuf::SpecialFields {
530 &self.special_fields
531 }
532
mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields533 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
534 &mut self.special_fields
535 }
536
new() -> Event537 fn new() -> Event {
538 Event::new()
539 }
540
clear(&mut self)541 fn clear(&mut self) {
542 self.devices.clear();
543 self.special_fields.clear();
544 }
545
default_instance() -> &'static Event546 fn default_instance() -> &'static Event {
547 static instance: Event = Event {
548 devices: ::std::vec::Vec::new(),
549 special_fields: ::protobuf::SpecialFields::new(),
550 };
551 &instance
552 }
553 }
554
555 impl ::protobuf::MessageFull for Event {
descriptor() -> ::protobuf::reflect::MessageDescriptor556 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
557 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
558 descriptor.get(|| file_descriptor().message_by_package_relative_name("Event").unwrap()).clone()
559 }
560 }
561
562 impl ::std::fmt::Display for Event {
fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result563 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
564 ::protobuf::text_format::fmt(self, f)
565 }
566 }
567
568 impl ::protobuf::reflect::ProtobufValue for Event {
569 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
570 }
571
572 #[derive(PartialEq,Clone,Default,Debug)]
573 // @@protoc_insertion_point(message:netsim.frontend.GetDevicesResponse)
574 pub struct GetDevicesResponse {
575 // message fields
576 // @@protoc_insertion_point(field:netsim.frontend.GetDevicesResponse.devices)
577 pub devices: ::std::vec::Vec<super::model::Device>,
578 // special fields
579 // @@protoc_insertion_point(special_field:netsim.frontend.GetDevicesResponse.special_fields)
580 pub special_fields: ::protobuf::SpecialFields,
581 }
582
583 impl<'a> ::std::default::Default for &'a GetDevicesResponse {
default() -> &'a GetDevicesResponse584 fn default() -> &'a GetDevicesResponse {
585 <GetDevicesResponse as ::protobuf::Message>::default_instance()
586 }
587 }
588
589 impl GetDevicesResponse {
new() -> GetDevicesResponse590 pub fn new() -> GetDevicesResponse {
591 ::std::default::Default::default()
592 }
593
generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData594 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
595 let mut fields = ::std::vec::Vec::with_capacity(1);
596 let mut oneofs = ::std::vec::Vec::with_capacity(0);
597 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
598 "devices",
599 |m: &GetDevicesResponse| { &m.devices },
600 |m: &mut GetDevicesResponse| { &mut m.devices },
601 ));
602 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetDevicesResponse>(
603 "GetDevicesResponse",
604 fields,
605 oneofs,
606 )
607 }
608 }
609
610 impl ::protobuf::Message for GetDevicesResponse {
611 const NAME: &'static str = "GetDevicesResponse";
612
is_initialized(&self) -> bool613 fn is_initialized(&self) -> bool {
614 true
615 }
616
merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()>617 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
618 while let Some(tag) = is.read_raw_tag_or_eof()? {
619 match tag {
620 10 => {
621 self.devices.push(is.read_message()?);
622 },
623 tag => {
624 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
625 },
626 };
627 }
628 ::std::result::Result::Ok(())
629 }
630
631 // Compute sizes of nested messages
632 #[allow(unused_variables)]
compute_size(&self) -> u64633 fn compute_size(&self) -> u64 {
634 let mut my_size = 0;
635 for value in &self.devices {
636 let len = value.compute_size();
637 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
638 };
639 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
640 self.special_fields.cached_size().set(my_size as u32);
641 my_size
642 }
643
write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()>644 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
645 for v in &self.devices {
646 ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
647 };
648 os.write_unknown_fields(self.special_fields.unknown_fields())?;
649 ::std::result::Result::Ok(())
650 }
651
special_fields(&self) -> &::protobuf::SpecialFields652 fn special_fields(&self) -> &::protobuf::SpecialFields {
653 &self.special_fields
654 }
655
mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields656 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
657 &mut self.special_fields
658 }
659
new() -> GetDevicesResponse660 fn new() -> GetDevicesResponse {
661 GetDevicesResponse::new()
662 }
663
clear(&mut self)664 fn clear(&mut self) {
665 self.devices.clear();
666 self.special_fields.clear();
667 }
668
default_instance() -> &'static GetDevicesResponse669 fn default_instance() -> &'static GetDevicesResponse {
670 static instance: GetDevicesResponse = GetDevicesResponse {
671 devices: ::std::vec::Vec::new(),
672 special_fields: ::protobuf::SpecialFields::new(),
673 };
674 &instance
675 }
676 }
677
678 impl ::protobuf::MessageFull for GetDevicesResponse {
descriptor() -> ::protobuf::reflect::MessageDescriptor679 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
680 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
681 descriptor.get(|| file_descriptor().message_by_package_relative_name("GetDevicesResponse").unwrap()).clone()
682 }
683 }
684
685 impl ::std::fmt::Display for GetDevicesResponse {
fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result686 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
687 ::protobuf::text_format::fmt(self, f)
688 }
689 }
690
691 impl ::protobuf::reflect::ProtobufValue for GetDevicesResponse {
692 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
693 }
694
695 #[derive(PartialEq,Clone,Default,Debug)]
696 // @@protoc_insertion_point(message:netsim.frontend.NetCatStream)
697 pub struct NetCatStream {
698 // message fields
699 // @@protoc_insertion_point(field:netsim.frontend.NetCatStream.result)
700 pub result: ::std::vec::Vec<::std::string::String>,
701 // special fields
702 // @@protoc_insertion_point(special_field:netsim.frontend.NetCatStream.special_fields)
703 pub special_fields: ::protobuf::SpecialFields,
704 }
705
706 impl<'a> ::std::default::Default for &'a NetCatStream {
default() -> &'a NetCatStream707 fn default() -> &'a NetCatStream {
708 <NetCatStream as ::protobuf::Message>::default_instance()
709 }
710 }
711
712 impl NetCatStream {
new() -> NetCatStream713 pub fn new() -> NetCatStream {
714 ::std::default::Default::default()
715 }
716
generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData717 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
718 let mut fields = ::std::vec::Vec::with_capacity(1);
719 let mut oneofs = ::std::vec::Vec::with_capacity(0);
720 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
721 "result",
722 |m: &NetCatStream| { &m.result },
723 |m: &mut NetCatStream| { &mut m.result },
724 ));
725 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<NetCatStream>(
726 "NetCatStream",
727 fields,
728 oneofs,
729 )
730 }
731 }
732
733 impl ::protobuf::Message for NetCatStream {
734 const NAME: &'static str = "NetCatStream";
735
is_initialized(&self) -> bool736 fn is_initialized(&self) -> bool {
737 true
738 }
739
merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()>740 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
741 while let Some(tag) = is.read_raw_tag_or_eof()? {
742 match tag {
743 10 => {
744 self.result.push(is.read_string()?);
745 },
746 tag => {
747 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
748 },
749 };
750 }
751 ::std::result::Result::Ok(())
752 }
753
754 // Compute sizes of nested messages
755 #[allow(unused_variables)]
compute_size(&self) -> u64756 fn compute_size(&self) -> u64 {
757 let mut my_size = 0;
758 for value in &self.result {
759 my_size += ::protobuf::rt::string_size(1, &value);
760 };
761 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
762 self.special_fields.cached_size().set(my_size as u32);
763 my_size
764 }
765
write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()>766 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
767 for v in &self.result {
768 os.write_string(1, &v)?;
769 };
770 os.write_unknown_fields(self.special_fields.unknown_fields())?;
771 ::std::result::Result::Ok(())
772 }
773
special_fields(&self) -> &::protobuf::SpecialFields774 fn special_fields(&self) -> &::protobuf::SpecialFields {
775 &self.special_fields
776 }
777
mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields778 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
779 &mut self.special_fields
780 }
781
new() -> NetCatStream782 fn new() -> NetCatStream {
783 NetCatStream::new()
784 }
785
clear(&mut self)786 fn clear(&mut self) {
787 self.result.clear();
788 self.special_fields.clear();
789 }
790
default_instance() -> &'static NetCatStream791 fn default_instance() -> &'static NetCatStream {
792 static instance: NetCatStream = NetCatStream {
793 result: ::std::vec::Vec::new(),
794 special_fields: ::protobuf::SpecialFields::new(),
795 };
796 &instance
797 }
798 }
799
800 impl ::protobuf::MessageFull for NetCatStream {
descriptor() -> ::protobuf::reflect::MessageDescriptor801 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
802 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
803 descriptor.get(|| file_descriptor().message_by_package_relative_name("NetCatStream").unwrap()).clone()
804 }
805 }
806
807 impl ::std::fmt::Display for NetCatStream {
fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result808 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
809 ::protobuf::text_format::fmt(self, f)
810 }
811 }
812
813 impl ::protobuf::reflect::ProtobufValue for NetCatStream {
814 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
815 }
816
817 #[derive(PartialEq,Clone,Default,Debug)]
818 // @@protoc_insertion_point(message:netsim.frontend.SetPacketCaptureRequest)
819 pub struct SetPacketCaptureRequest {
820 // message fields
821 // @@protoc_insertion_point(field:netsim.frontend.SetPacketCaptureRequest.capture)
822 pub capture: bool,
823 // @@protoc_insertion_point(field:netsim.frontend.SetPacketCaptureRequest.device_serial)
824 pub device_serial: ::std::string::String,
825 // special fields
826 // @@protoc_insertion_point(special_field:netsim.frontend.SetPacketCaptureRequest.special_fields)
827 pub special_fields: ::protobuf::SpecialFields,
828 }
829
830 impl<'a> ::std::default::Default for &'a SetPacketCaptureRequest {
default() -> &'a SetPacketCaptureRequest831 fn default() -> &'a SetPacketCaptureRequest {
832 <SetPacketCaptureRequest as ::protobuf::Message>::default_instance()
833 }
834 }
835
836 impl SetPacketCaptureRequest {
new() -> SetPacketCaptureRequest837 pub fn new() -> SetPacketCaptureRequest {
838 ::std::default::Default::default()
839 }
840
generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData841 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
842 let mut fields = ::std::vec::Vec::with_capacity(2);
843 let mut oneofs = ::std::vec::Vec::with_capacity(0);
844 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
845 "capture",
846 |m: &SetPacketCaptureRequest| { &m.capture },
847 |m: &mut SetPacketCaptureRequest| { &mut m.capture },
848 ));
849 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
850 "device_serial",
851 |m: &SetPacketCaptureRequest| { &m.device_serial },
852 |m: &mut SetPacketCaptureRequest| { &mut m.device_serial },
853 ));
854 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetPacketCaptureRequest>(
855 "SetPacketCaptureRequest",
856 fields,
857 oneofs,
858 )
859 }
860 }
861
862 impl ::protobuf::Message for SetPacketCaptureRequest {
863 const NAME: &'static str = "SetPacketCaptureRequest";
864
is_initialized(&self) -> bool865 fn is_initialized(&self) -> bool {
866 true
867 }
868
merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()>869 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
870 while let Some(tag) = is.read_raw_tag_or_eof()? {
871 match tag {
872 8 => {
873 self.capture = is.read_bool()?;
874 },
875 18 => {
876 self.device_serial = is.read_string()?;
877 },
878 tag => {
879 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
880 },
881 };
882 }
883 ::std::result::Result::Ok(())
884 }
885
886 // Compute sizes of nested messages
887 #[allow(unused_variables)]
compute_size(&self) -> u64888 fn compute_size(&self) -> u64 {
889 let mut my_size = 0;
890 if self.capture != false {
891 my_size += 1 + 1;
892 }
893 if !self.device_serial.is_empty() {
894 my_size += ::protobuf::rt::string_size(2, &self.device_serial);
895 }
896 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
897 self.special_fields.cached_size().set(my_size as u32);
898 my_size
899 }
900
write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()>901 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
902 if self.capture != false {
903 os.write_bool(1, self.capture)?;
904 }
905 if !self.device_serial.is_empty() {
906 os.write_string(2, &self.device_serial)?;
907 }
908 os.write_unknown_fields(self.special_fields.unknown_fields())?;
909 ::std::result::Result::Ok(())
910 }
911
special_fields(&self) -> &::protobuf::SpecialFields912 fn special_fields(&self) -> &::protobuf::SpecialFields {
913 &self.special_fields
914 }
915
mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields916 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
917 &mut self.special_fields
918 }
919
new() -> SetPacketCaptureRequest920 fn new() -> SetPacketCaptureRequest {
921 SetPacketCaptureRequest::new()
922 }
923
clear(&mut self)924 fn clear(&mut self) {
925 self.capture = false;
926 self.device_serial.clear();
927 self.special_fields.clear();
928 }
929
default_instance() -> &'static SetPacketCaptureRequest930 fn default_instance() -> &'static SetPacketCaptureRequest {
931 static instance: SetPacketCaptureRequest = SetPacketCaptureRequest {
932 capture: false,
933 device_serial: ::std::string::String::new(),
934 special_fields: ::protobuf::SpecialFields::new(),
935 };
936 &instance
937 }
938 }
939
940 impl ::protobuf::MessageFull for SetPacketCaptureRequest {
descriptor() -> ::protobuf::reflect::MessageDescriptor941 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
942 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
943 descriptor.get(|| file_descriptor().message_by_package_relative_name("SetPacketCaptureRequest").unwrap()).clone()
944 }
945 }
946
947 impl ::std::fmt::Display for SetPacketCaptureRequest {
fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result948 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
949 ::protobuf::text_format::fmt(self, f)
950 }
951 }
952
953 impl ::protobuf::reflect::ProtobufValue for SetPacketCaptureRequest {
954 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
955 }
956
957 #[derive(PartialEq,Clone,Default,Debug)]
958 // @@protoc_insertion_point(message:netsim.frontend.PatchCaptureRequest)
959 pub struct PatchCaptureRequest {
960 // message fields
961 // @@protoc_insertion_point(field:netsim.frontend.PatchCaptureRequest.id)
962 pub id: i32,
963 // @@protoc_insertion_point(field:netsim.frontend.PatchCaptureRequest.patch)
964 pub patch: ::protobuf::MessageField<patch_capture_request::PatchCapture>,
965 // special fields
966 // @@protoc_insertion_point(special_field:netsim.frontend.PatchCaptureRequest.special_fields)
967 pub special_fields: ::protobuf::SpecialFields,
968 }
969
970 impl<'a> ::std::default::Default for &'a PatchCaptureRequest {
default() -> &'a PatchCaptureRequest971 fn default() -> &'a PatchCaptureRequest {
972 <PatchCaptureRequest as ::protobuf::Message>::default_instance()
973 }
974 }
975
976 impl PatchCaptureRequest {
new() -> PatchCaptureRequest977 pub fn new() -> PatchCaptureRequest {
978 ::std::default::Default::default()
979 }
980
generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData981 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
982 let mut fields = ::std::vec::Vec::with_capacity(2);
983 let mut oneofs = ::std::vec::Vec::with_capacity(0);
984 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
985 "id",
986 |m: &PatchCaptureRequest| { &m.id },
987 |m: &mut PatchCaptureRequest| { &mut m.id },
988 ));
989 fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, patch_capture_request::PatchCapture>(
990 "patch",
991 |m: &PatchCaptureRequest| { &m.patch },
992 |m: &mut PatchCaptureRequest| { &mut m.patch },
993 ));
994 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PatchCaptureRequest>(
995 "PatchCaptureRequest",
996 fields,
997 oneofs,
998 )
999 }
1000 }
1001
1002 impl ::protobuf::Message for PatchCaptureRequest {
1003 const NAME: &'static str = "PatchCaptureRequest";
1004
is_initialized(&self) -> bool1005 fn is_initialized(&self) -> bool {
1006 true
1007 }
1008
merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()>1009 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1010 while let Some(tag) = is.read_raw_tag_or_eof()? {
1011 match tag {
1012 8 => {
1013 self.id = is.read_int32()?;
1014 },
1015 18 => {
1016 ::protobuf::rt::read_singular_message_into_field(is, &mut self.patch)?;
1017 },
1018 tag => {
1019 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1020 },
1021 };
1022 }
1023 ::std::result::Result::Ok(())
1024 }
1025
1026 // Compute sizes of nested messages
1027 #[allow(unused_variables)]
compute_size(&self) -> u641028 fn compute_size(&self) -> u64 {
1029 let mut my_size = 0;
1030 if self.id != 0 {
1031 my_size += ::protobuf::rt::int32_size(1, self.id);
1032 }
1033 if let Some(v) = self.patch.as_ref() {
1034 let len = v.compute_size();
1035 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
1036 }
1037 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1038 self.special_fields.cached_size().set(my_size as u32);
1039 my_size
1040 }
1041
write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()>1042 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1043 if self.id != 0 {
1044 os.write_int32(1, self.id)?;
1045 }
1046 if let Some(v) = self.patch.as_ref() {
1047 ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
1048 }
1049 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1050 ::std::result::Result::Ok(())
1051 }
1052
special_fields(&self) -> &::protobuf::SpecialFields1053 fn special_fields(&self) -> &::protobuf::SpecialFields {
1054 &self.special_fields
1055 }
1056
mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields1057 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1058 &mut self.special_fields
1059 }
1060
new() -> PatchCaptureRequest1061 fn new() -> PatchCaptureRequest {
1062 PatchCaptureRequest::new()
1063 }
1064
clear(&mut self)1065 fn clear(&mut self) {
1066 self.id = 0;
1067 self.patch.clear();
1068 self.special_fields.clear();
1069 }
1070
default_instance() -> &'static PatchCaptureRequest1071 fn default_instance() -> &'static PatchCaptureRequest {
1072 static instance: PatchCaptureRequest = PatchCaptureRequest {
1073 id: 0,
1074 patch: ::protobuf::MessageField::none(),
1075 special_fields: ::protobuf::SpecialFields::new(),
1076 };
1077 &instance
1078 }
1079 }
1080
1081 impl ::protobuf::MessageFull for PatchCaptureRequest {
descriptor() -> ::protobuf::reflect::MessageDescriptor1082 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1083 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1084 descriptor.get(|| file_descriptor().message_by_package_relative_name("PatchCaptureRequest").unwrap()).clone()
1085 }
1086 }
1087
1088 impl ::std::fmt::Display for PatchCaptureRequest {
fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1089 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1090 ::protobuf::text_format::fmt(self, f)
1091 }
1092 }
1093
1094 impl ::protobuf::reflect::ProtobufValue for PatchCaptureRequest {
1095 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1096 }
1097
1098 /// Nested message and enums of message `PatchCaptureRequest`
1099 pub mod patch_capture_request {
1100 #[derive(PartialEq,Clone,Default,Debug)]
1101 // @@protoc_insertion_point(message:netsim.frontend.PatchCaptureRequest.PatchCapture)
1102 pub struct PatchCapture {
1103 // message fields
1104 // @@protoc_insertion_point(field:netsim.frontend.PatchCaptureRequest.PatchCapture.state)
1105 pub state: ::protobuf::EnumOrUnknown<super::super::model::State>,
1106 // special fields
1107 // @@protoc_insertion_point(special_field:netsim.frontend.PatchCaptureRequest.PatchCapture.special_fields)
1108 pub special_fields: ::protobuf::SpecialFields,
1109 }
1110
1111 impl<'a> ::std::default::Default for &'a PatchCapture {
default() -> &'a PatchCapture1112 fn default() -> &'a PatchCapture {
1113 <PatchCapture as ::protobuf::Message>::default_instance()
1114 }
1115 }
1116
1117 impl PatchCapture {
new() -> PatchCapture1118 pub fn new() -> PatchCapture {
1119 ::std::default::Default::default()
1120 }
1121
generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData1122 pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1123 let mut fields = ::std::vec::Vec::with_capacity(1);
1124 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1125 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1126 "state",
1127 |m: &PatchCapture| { &m.state },
1128 |m: &mut PatchCapture| { &mut m.state },
1129 ));
1130 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PatchCapture>(
1131 "PatchCaptureRequest.PatchCapture",
1132 fields,
1133 oneofs,
1134 )
1135 }
1136 }
1137
1138 impl ::protobuf::Message for PatchCapture {
1139 const NAME: &'static str = "PatchCapture";
1140
is_initialized(&self) -> bool1141 fn is_initialized(&self) -> bool {
1142 true
1143 }
1144
merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()>1145 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1146 while let Some(tag) = is.read_raw_tag_or_eof()? {
1147 match tag {
1148 8 => {
1149 self.state = is.read_enum_or_unknown()?;
1150 },
1151 tag => {
1152 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1153 },
1154 };
1155 }
1156 ::std::result::Result::Ok(())
1157 }
1158
1159 // Compute sizes of nested messages
1160 #[allow(unused_variables)]
compute_size(&self) -> u641161 fn compute_size(&self) -> u64 {
1162 let mut my_size = 0;
1163 if self.state != ::protobuf::EnumOrUnknown::new(super::super::model::State::UNKNOWN) {
1164 my_size += ::protobuf::rt::int32_size(1, self.state.value());
1165 }
1166 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1167 self.special_fields.cached_size().set(my_size as u32);
1168 my_size
1169 }
1170
write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()>1171 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1172 if self.state != ::protobuf::EnumOrUnknown::new(super::super::model::State::UNKNOWN) {
1173 os.write_enum(1, ::protobuf::EnumOrUnknown::value(&self.state))?;
1174 }
1175 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1176 ::std::result::Result::Ok(())
1177 }
1178
special_fields(&self) -> &::protobuf::SpecialFields1179 fn special_fields(&self) -> &::protobuf::SpecialFields {
1180 &self.special_fields
1181 }
1182
mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields1183 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1184 &mut self.special_fields
1185 }
1186
new() -> PatchCapture1187 fn new() -> PatchCapture {
1188 PatchCapture::new()
1189 }
1190
clear(&mut self)1191 fn clear(&mut self) {
1192 self.state = ::protobuf::EnumOrUnknown::new(super::super::model::State::UNKNOWN);
1193 self.special_fields.clear();
1194 }
1195
default_instance() -> &'static PatchCapture1196 fn default_instance() -> &'static PatchCapture {
1197 static instance: PatchCapture = PatchCapture {
1198 state: ::protobuf::EnumOrUnknown::from_i32(0),
1199 special_fields: ::protobuf::SpecialFields::new(),
1200 };
1201 &instance
1202 }
1203 }
1204
1205 impl ::protobuf::MessageFull for PatchCapture {
descriptor() -> ::protobuf::reflect::MessageDescriptor1206 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1207 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1208 descriptor.get(|| super::file_descriptor().message_by_package_relative_name("PatchCaptureRequest.PatchCapture").unwrap()).clone()
1209 }
1210 }
1211
1212 impl ::std::fmt::Display for PatchCapture {
fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1213 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1214 ::protobuf::text_format::fmt(self, f)
1215 }
1216 }
1217
1218 impl ::protobuf::reflect::ProtobufValue for PatchCapture {
1219 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1220 }
1221 }
1222
1223 #[derive(PartialEq,Clone,Default,Debug)]
1224 // @@protoc_insertion_point(message:netsim.frontend.ListCaptureResponse)
1225 pub struct ListCaptureResponse {
1226 // message fields
1227 // @@protoc_insertion_point(field:netsim.frontend.ListCaptureResponse.captures)
1228 pub captures: ::std::vec::Vec<super::model::Capture>,
1229 // special fields
1230 // @@protoc_insertion_point(special_field:netsim.frontend.ListCaptureResponse.special_fields)
1231 pub special_fields: ::protobuf::SpecialFields,
1232 }
1233
1234 impl<'a> ::std::default::Default for &'a ListCaptureResponse {
default() -> &'a ListCaptureResponse1235 fn default() -> &'a ListCaptureResponse {
1236 <ListCaptureResponse as ::protobuf::Message>::default_instance()
1237 }
1238 }
1239
1240 impl ListCaptureResponse {
new() -> ListCaptureResponse1241 pub fn new() -> ListCaptureResponse {
1242 ::std::default::Default::default()
1243 }
1244
generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData1245 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1246 let mut fields = ::std::vec::Vec::with_capacity(1);
1247 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1248 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
1249 "captures",
1250 |m: &ListCaptureResponse| { &m.captures },
1251 |m: &mut ListCaptureResponse| { &mut m.captures },
1252 ));
1253 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ListCaptureResponse>(
1254 "ListCaptureResponse",
1255 fields,
1256 oneofs,
1257 )
1258 }
1259 }
1260
1261 impl ::protobuf::Message for ListCaptureResponse {
1262 const NAME: &'static str = "ListCaptureResponse";
1263
is_initialized(&self) -> bool1264 fn is_initialized(&self) -> bool {
1265 true
1266 }
1267
merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()>1268 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1269 while let Some(tag) = is.read_raw_tag_or_eof()? {
1270 match tag {
1271 10 => {
1272 self.captures.push(is.read_message()?);
1273 },
1274 tag => {
1275 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1276 },
1277 };
1278 }
1279 ::std::result::Result::Ok(())
1280 }
1281
1282 // Compute sizes of nested messages
1283 #[allow(unused_variables)]
compute_size(&self) -> u641284 fn compute_size(&self) -> u64 {
1285 let mut my_size = 0;
1286 for value in &self.captures {
1287 let len = value.compute_size();
1288 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
1289 };
1290 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1291 self.special_fields.cached_size().set(my_size as u32);
1292 my_size
1293 }
1294
write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()>1295 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1296 for v in &self.captures {
1297 ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
1298 };
1299 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1300 ::std::result::Result::Ok(())
1301 }
1302
special_fields(&self) -> &::protobuf::SpecialFields1303 fn special_fields(&self) -> &::protobuf::SpecialFields {
1304 &self.special_fields
1305 }
1306
mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields1307 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1308 &mut self.special_fields
1309 }
1310
new() -> ListCaptureResponse1311 fn new() -> ListCaptureResponse {
1312 ListCaptureResponse::new()
1313 }
1314
clear(&mut self)1315 fn clear(&mut self) {
1316 self.captures.clear();
1317 self.special_fields.clear();
1318 }
1319
default_instance() -> &'static ListCaptureResponse1320 fn default_instance() -> &'static ListCaptureResponse {
1321 static instance: ListCaptureResponse = ListCaptureResponse {
1322 captures: ::std::vec::Vec::new(),
1323 special_fields: ::protobuf::SpecialFields::new(),
1324 };
1325 &instance
1326 }
1327 }
1328
1329 impl ::protobuf::MessageFull for ListCaptureResponse {
descriptor() -> ::protobuf::reflect::MessageDescriptor1330 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1331 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1332 descriptor.get(|| file_descriptor().message_by_package_relative_name("ListCaptureResponse").unwrap()).clone()
1333 }
1334 }
1335
1336 impl ::std::fmt::Display for ListCaptureResponse {
fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1337 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1338 ::protobuf::text_format::fmt(self, f)
1339 }
1340 }
1341
1342 impl ::protobuf::reflect::ProtobufValue for ListCaptureResponse {
1343 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1344 }
1345
1346 #[derive(PartialEq,Clone,Default,Debug)]
1347 // @@protoc_insertion_point(message:netsim.frontend.GetCaptureRequest)
1348 pub struct GetCaptureRequest {
1349 // message fields
1350 // @@protoc_insertion_point(field:netsim.frontend.GetCaptureRequest.id)
1351 pub id: i32,
1352 // special fields
1353 // @@protoc_insertion_point(special_field:netsim.frontend.GetCaptureRequest.special_fields)
1354 pub special_fields: ::protobuf::SpecialFields,
1355 }
1356
1357 impl<'a> ::std::default::Default for &'a GetCaptureRequest {
default() -> &'a GetCaptureRequest1358 fn default() -> &'a GetCaptureRequest {
1359 <GetCaptureRequest as ::protobuf::Message>::default_instance()
1360 }
1361 }
1362
1363 impl GetCaptureRequest {
new() -> GetCaptureRequest1364 pub fn new() -> GetCaptureRequest {
1365 ::std::default::Default::default()
1366 }
1367
generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData1368 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1369 let mut fields = ::std::vec::Vec::with_capacity(1);
1370 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1371 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1372 "id",
1373 |m: &GetCaptureRequest| { &m.id },
1374 |m: &mut GetCaptureRequest| { &mut m.id },
1375 ));
1376 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetCaptureRequest>(
1377 "GetCaptureRequest",
1378 fields,
1379 oneofs,
1380 )
1381 }
1382 }
1383
1384 impl ::protobuf::Message for GetCaptureRequest {
1385 const NAME: &'static str = "GetCaptureRequest";
1386
is_initialized(&self) -> bool1387 fn is_initialized(&self) -> bool {
1388 true
1389 }
1390
merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()>1391 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1392 while let Some(tag) = is.read_raw_tag_or_eof()? {
1393 match tag {
1394 8 => {
1395 self.id = is.read_int32()?;
1396 },
1397 tag => {
1398 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1399 },
1400 };
1401 }
1402 ::std::result::Result::Ok(())
1403 }
1404
1405 // Compute sizes of nested messages
1406 #[allow(unused_variables)]
compute_size(&self) -> u641407 fn compute_size(&self) -> u64 {
1408 let mut my_size = 0;
1409 if self.id != 0 {
1410 my_size += ::protobuf::rt::int32_size(1, self.id);
1411 }
1412 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1413 self.special_fields.cached_size().set(my_size as u32);
1414 my_size
1415 }
1416
write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()>1417 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1418 if self.id != 0 {
1419 os.write_int32(1, self.id)?;
1420 }
1421 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1422 ::std::result::Result::Ok(())
1423 }
1424
special_fields(&self) -> &::protobuf::SpecialFields1425 fn special_fields(&self) -> &::protobuf::SpecialFields {
1426 &self.special_fields
1427 }
1428
mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields1429 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1430 &mut self.special_fields
1431 }
1432
new() -> GetCaptureRequest1433 fn new() -> GetCaptureRequest {
1434 GetCaptureRequest::new()
1435 }
1436
clear(&mut self)1437 fn clear(&mut self) {
1438 self.id = 0;
1439 self.special_fields.clear();
1440 }
1441
default_instance() -> &'static GetCaptureRequest1442 fn default_instance() -> &'static GetCaptureRequest {
1443 static instance: GetCaptureRequest = GetCaptureRequest {
1444 id: 0,
1445 special_fields: ::protobuf::SpecialFields::new(),
1446 };
1447 &instance
1448 }
1449 }
1450
1451 impl ::protobuf::MessageFull for GetCaptureRequest {
descriptor() -> ::protobuf::reflect::MessageDescriptor1452 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1453 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1454 descriptor.get(|| file_descriptor().message_by_package_relative_name("GetCaptureRequest").unwrap()).clone()
1455 }
1456 }
1457
1458 impl ::std::fmt::Display for GetCaptureRequest {
fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1459 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1460 ::protobuf::text_format::fmt(self, f)
1461 }
1462 }
1463
1464 impl ::protobuf::reflect::ProtobufValue for GetCaptureRequest {
1465 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1466 }
1467
1468 #[derive(PartialEq,Clone,Default,Debug)]
1469 // @@protoc_insertion_point(message:netsim.frontend.GetCaptureResponse)
1470 pub struct GetCaptureResponse {
1471 // message fields
1472 // @@protoc_insertion_point(field:netsim.frontend.GetCaptureResponse.capture_stream)
1473 pub capture_stream: ::std::vec::Vec<u8>,
1474 // special fields
1475 // @@protoc_insertion_point(special_field:netsim.frontend.GetCaptureResponse.special_fields)
1476 pub special_fields: ::protobuf::SpecialFields,
1477 }
1478
1479 impl<'a> ::std::default::Default for &'a GetCaptureResponse {
default() -> &'a GetCaptureResponse1480 fn default() -> &'a GetCaptureResponse {
1481 <GetCaptureResponse as ::protobuf::Message>::default_instance()
1482 }
1483 }
1484
1485 impl GetCaptureResponse {
new() -> GetCaptureResponse1486 pub fn new() -> GetCaptureResponse {
1487 ::std::default::Default::default()
1488 }
1489
generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData1490 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1491 let mut fields = ::std::vec::Vec::with_capacity(1);
1492 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1493 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1494 "capture_stream",
1495 |m: &GetCaptureResponse| { &m.capture_stream },
1496 |m: &mut GetCaptureResponse| { &mut m.capture_stream },
1497 ));
1498 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetCaptureResponse>(
1499 "GetCaptureResponse",
1500 fields,
1501 oneofs,
1502 )
1503 }
1504 }
1505
1506 impl ::protobuf::Message for GetCaptureResponse {
1507 const NAME: &'static str = "GetCaptureResponse";
1508
is_initialized(&self) -> bool1509 fn is_initialized(&self) -> bool {
1510 true
1511 }
1512
merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()>1513 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1514 while let Some(tag) = is.read_raw_tag_or_eof()? {
1515 match tag {
1516 10 => {
1517 self.capture_stream = is.read_bytes()?;
1518 },
1519 tag => {
1520 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1521 },
1522 };
1523 }
1524 ::std::result::Result::Ok(())
1525 }
1526
1527 // Compute sizes of nested messages
1528 #[allow(unused_variables)]
compute_size(&self) -> u641529 fn compute_size(&self) -> u64 {
1530 let mut my_size = 0;
1531 if !self.capture_stream.is_empty() {
1532 my_size += ::protobuf::rt::bytes_size(1, &self.capture_stream);
1533 }
1534 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1535 self.special_fields.cached_size().set(my_size as u32);
1536 my_size
1537 }
1538
write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()>1539 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1540 if !self.capture_stream.is_empty() {
1541 os.write_bytes(1, &self.capture_stream)?;
1542 }
1543 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1544 ::std::result::Result::Ok(())
1545 }
1546
special_fields(&self) -> &::protobuf::SpecialFields1547 fn special_fields(&self) -> &::protobuf::SpecialFields {
1548 &self.special_fields
1549 }
1550
mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields1551 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1552 &mut self.special_fields
1553 }
1554
new() -> GetCaptureResponse1555 fn new() -> GetCaptureResponse {
1556 GetCaptureResponse::new()
1557 }
1558
clear(&mut self)1559 fn clear(&mut self) {
1560 self.capture_stream.clear();
1561 self.special_fields.clear();
1562 }
1563
default_instance() -> &'static GetCaptureResponse1564 fn default_instance() -> &'static GetCaptureResponse {
1565 static instance: GetCaptureResponse = GetCaptureResponse {
1566 capture_stream: ::std::vec::Vec::new(),
1567 special_fields: ::protobuf::SpecialFields::new(),
1568 };
1569 &instance
1570 }
1571 }
1572
1573 impl ::protobuf::MessageFull for GetCaptureResponse {
descriptor() -> ::protobuf::reflect::MessageDescriptor1574 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1575 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1576 descriptor.get(|| file_descriptor().message_by_package_relative_name("GetCaptureResponse").unwrap()).clone()
1577 }
1578 }
1579
1580 impl ::std::fmt::Display for GetCaptureResponse {
fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1581 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1582 ::protobuf::text_format::fmt(self, f)
1583 }
1584 }
1585
1586 impl ::protobuf::reflect::ProtobufValue for GetCaptureResponse {
1587 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1588 }
1589
1590 #[derive(PartialEq,Clone,Default,Debug)]
1591 // @@protoc_insertion_point(message:netsim.frontend.ErrorResponse)
1592 pub struct ErrorResponse {
1593 // message fields
1594 // @@protoc_insertion_point(field:netsim.frontend.ErrorResponse.code)
1595 pub code: i32,
1596 // @@protoc_insertion_point(field:netsim.frontend.ErrorResponse.error_message)
1597 pub error_message: ::std::string::String,
1598 // @@protoc_insertion_point(field:netsim.frontend.ErrorResponse.status)
1599 pub status: ::std::string::String,
1600 // special fields
1601 // @@protoc_insertion_point(special_field:netsim.frontend.ErrorResponse.special_fields)
1602 pub special_fields: ::protobuf::SpecialFields,
1603 }
1604
1605 impl<'a> ::std::default::Default for &'a ErrorResponse {
default() -> &'a ErrorResponse1606 fn default() -> &'a ErrorResponse {
1607 <ErrorResponse as ::protobuf::Message>::default_instance()
1608 }
1609 }
1610
1611 impl ErrorResponse {
new() -> ErrorResponse1612 pub fn new() -> ErrorResponse {
1613 ::std::default::Default::default()
1614 }
1615
generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData1616 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1617 let mut fields = ::std::vec::Vec::with_capacity(3);
1618 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1619 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1620 "code",
1621 |m: &ErrorResponse| { &m.code },
1622 |m: &mut ErrorResponse| { &mut m.code },
1623 ));
1624 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1625 "error_message",
1626 |m: &ErrorResponse| { &m.error_message },
1627 |m: &mut ErrorResponse| { &mut m.error_message },
1628 ));
1629 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1630 "status",
1631 |m: &ErrorResponse| { &m.status },
1632 |m: &mut ErrorResponse| { &mut m.status },
1633 ));
1634 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ErrorResponse>(
1635 "ErrorResponse",
1636 fields,
1637 oneofs,
1638 )
1639 }
1640 }
1641
1642 impl ::protobuf::Message for ErrorResponse {
1643 const NAME: &'static str = "ErrorResponse";
1644
is_initialized(&self) -> bool1645 fn is_initialized(&self) -> bool {
1646 true
1647 }
1648
merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()>1649 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1650 while let Some(tag) = is.read_raw_tag_or_eof()? {
1651 match tag {
1652 8 => {
1653 self.code = is.read_int32()?;
1654 },
1655 18 => {
1656 self.error_message = is.read_string()?;
1657 },
1658 26 => {
1659 self.status = is.read_string()?;
1660 },
1661 tag => {
1662 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1663 },
1664 };
1665 }
1666 ::std::result::Result::Ok(())
1667 }
1668
1669 // Compute sizes of nested messages
1670 #[allow(unused_variables)]
compute_size(&self) -> u641671 fn compute_size(&self) -> u64 {
1672 let mut my_size = 0;
1673 if self.code != 0 {
1674 my_size += ::protobuf::rt::int32_size(1, self.code);
1675 }
1676 if !self.error_message.is_empty() {
1677 my_size += ::protobuf::rt::string_size(2, &self.error_message);
1678 }
1679 if !self.status.is_empty() {
1680 my_size += ::protobuf::rt::string_size(3, &self.status);
1681 }
1682 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1683 self.special_fields.cached_size().set(my_size as u32);
1684 my_size
1685 }
1686
write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()>1687 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1688 if self.code != 0 {
1689 os.write_int32(1, self.code)?;
1690 }
1691 if !self.error_message.is_empty() {
1692 os.write_string(2, &self.error_message)?;
1693 }
1694 if !self.status.is_empty() {
1695 os.write_string(3, &self.status)?;
1696 }
1697 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1698 ::std::result::Result::Ok(())
1699 }
1700
special_fields(&self) -> &::protobuf::SpecialFields1701 fn special_fields(&self) -> &::protobuf::SpecialFields {
1702 &self.special_fields
1703 }
1704
mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields1705 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1706 &mut self.special_fields
1707 }
1708
new() -> ErrorResponse1709 fn new() -> ErrorResponse {
1710 ErrorResponse::new()
1711 }
1712
clear(&mut self)1713 fn clear(&mut self) {
1714 self.code = 0;
1715 self.error_message.clear();
1716 self.status.clear();
1717 self.special_fields.clear();
1718 }
1719
default_instance() -> &'static ErrorResponse1720 fn default_instance() -> &'static ErrorResponse {
1721 static instance: ErrorResponse = ErrorResponse {
1722 code: 0,
1723 error_message: ::std::string::String::new(),
1724 status: ::std::string::String::new(),
1725 special_fields: ::protobuf::SpecialFields::new(),
1726 };
1727 &instance
1728 }
1729 }
1730
1731 impl ::protobuf::MessageFull for ErrorResponse {
descriptor() -> ::protobuf::reflect::MessageDescriptor1732 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1733 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1734 descriptor.get(|| file_descriptor().message_by_package_relative_name("ErrorResponse").unwrap()).clone()
1735 }
1736 }
1737
1738 impl ::std::fmt::Display for ErrorResponse {
fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1739 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1740 ::protobuf::text_format::fmt(self, f)
1741 }
1742 }
1743
1744 impl ::protobuf::reflect::ProtobufValue for ErrorResponse {
1745 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1746 }
1747
1748 static file_descriptor_proto_data: &'static [u8] = b"\
1749 \n\x0efrontend.proto\x12\x0fnetsim.frontend\x1a\x1bgoogle/protobuf/empty\
1750 .proto\x1a\x0bmodel.proto\"+\n\x0fVersionResponse\x12\x18\n\x07version\
1751 \x18\x01\x20\x01(\tR\x07version\"\xa2\x01\n\x12SetLinkLossRequest\x12\
1752 \x1f\n\x0bdevice_name\x18\x01\x20\x01(\tR\ndeviceName\x12!\n\x0cother_de\
1753 vice\x18\x02\x20\x01(\tR\x0botherDevice\x12+\n\x05radio\x18\x03\x20\x01(\
1754 \x0e2\x15.netsim.model.PhyKindR\x05radio\x12\x1b\n\tlink_loss\x18\x04\
1755 \x20\x01(\x02R\x08linkLoss\"B\n\x12PatchDeviceRequest\x12,\n\x06device\
1756 \x18\x02\x20\x01(\x0b2\x14.netsim.model.DeviceR\x06device\"7\n\x05Event\
1757 \x12.\n\x07devices\x18\x01\x20\x03(\x0b2\x14.netsim.model.DeviceR\x07dev\
1758 ices\"D\n\x12GetDevicesResponse\x12.\n\x07devices\x18\x01\x20\x03(\x0b2\
1759 \x14.netsim.model.DeviceR\x07devices\"&\n\x0cNetCatStream\x12\x16\n\x06r\
1760 esult\x18\x01\x20\x03(\tR\x06result\"X\n\x17SetPacketCaptureRequest\x12\
1761 \x18\n\x07capture\x18\x01\x20\x01(\x08R\x07capture\x12#\n\rdevice_serial\
1762 \x18\x02\x20\x01(\tR\x0cdeviceSerial\"\xa9\x01\n\x13PatchCaptureRequest\
1763 \x12\x0e\n\x02id\x18\x01\x20\x01(\x05R\x02id\x12G\n\x05patch\x18\x02\x20\
1764 \x01(\x0b21.netsim.frontend.PatchCaptureRequest.PatchCaptureR\x05patch\
1765 \x1a9\n\x0cPatchCapture\x12)\n\x05state\x18\x01\x20\x01(\x0e2\x13.netsim\
1766 .model.StateR\x05state\"H\n\x13ListCaptureResponse\x121\n\x08captures\
1767 \x18\x01\x20\x03(\x0b2\x15.netsim.model.CaptureR\x08captures\"#\n\x11Get\
1768 CaptureRequest\x12\x0e\n\x02id\x18\x01\x20\x01(\x05R\x02id\";\n\x12GetCa\
1769 ptureResponse\x12%\n\x0ecapture_stream\x18\x01\x20\x01(\x0cR\rcaptureStr\
1770 eam\"`\n\rErrorResponse\x12\x12\n\x04code\x18\x01\x20\x01(\x05R\x04code\
1771 \x12#\n\rerror_message\x18\x02\x20\x01(\tR\x0cerrorMessage\x12\x16\n\x06\
1772 status\x18\x03\x20\x01(\tR\x06status2\xf0\x05\n\x0fFrontendService\x12F\
1773 \n\nGetVersion\x12\x16.google.protobuf.Empty\x1a\x20.netsim.frontend.Ver\
1774 sionResponse\x12B\n\x0eRegisterEvents\x12\x16.google.protobuf.Empty\x1a\
1775 \x16.netsim.frontend.Event0\x01\x12I\n\nGetDevices\x12\x16.google.protob\
1776 uf.Empty\x1a#.netsim.frontend.GetDevicesResponse\x12J\n\x0bPatchDevice\
1777 \x12#.netsim.frontend.PatchDeviceRequest\x1a\x16.google.protobuf.Empty\
1778 \x127\n\x05Reset\x12\x16.google.protobuf.Empty\x1a\x16.google.protobuf.E\
1779 mpty\x12J\n\x0bSetLinkLoss\x12#.netsim.frontend.SetLinkLossRequest\x1a\
1780 \x16.google.protobuf.Empty\x12A\n\x06NetCat\x12\x16.google.protobuf.Empt\
1781 y\x1a\x1d.netsim.frontend.NetCatStream0\x01\x12L\n\x0cPatchCapture\x12$.\
1782 netsim.frontend.PatchCaptureRequest\x1a\x16.google.protobuf.Empty\x12K\n\
1783 \x0bListCapture\x12\x16.google.protobuf.Empty\x1a$.netsim.frontend.ListC\
1784 aptureResponse\x12W\n\nGetCapture\x12\".netsim.frontend.GetCaptureReques\
1785 t\x1a#.netsim.frontend.GetCaptureResponse0\x01b\x06proto3\
1786 ";
1787
1788 /// `FileDescriptorProto` object which was a source for this generated file
file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto1789 fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
1790 static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
1791 file_descriptor_proto_lazy.get(|| {
1792 ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
1793 })
1794 }
1795
1796 /// `FileDescriptor` object which allows dynamic access to files
file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor1797 pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
1798 static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
1799 static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
1800 file_descriptor.get(|| {
1801 let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
1802 let mut deps = ::std::vec::Vec::with_capacity(2);
1803 deps.push(::protobuf::well_known_types::empty::file_descriptor().clone());
1804 deps.push(super::model::file_descriptor().clone());
1805 let mut messages = ::std::vec::Vec::with_capacity(13);
1806 messages.push(VersionResponse::generated_message_descriptor_data());
1807 messages.push(SetLinkLossRequest::generated_message_descriptor_data());
1808 messages.push(PatchDeviceRequest::generated_message_descriptor_data());
1809 messages.push(Event::generated_message_descriptor_data());
1810 messages.push(GetDevicesResponse::generated_message_descriptor_data());
1811 messages.push(NetCatStream::generated_message_descriptor_data());
1812 messages.push(SetPacketCaptureRequest::generated_message_descriptor_data());
1813 messages.push(PatchCaptureRequest::generated_message_descriptor_data());
1814 messages.push(ListCaptureResponse::generated_message_descriptor_data());
1815 messages.push(GetCaptureRequest::generated_message_descriptor_data());
1816 messages.push(GetCaptureResponse::generated_message_descriptor_data());
1817 messages.push(ErrorResponse::generated_message_descriptor_data());
1818 messages.push(patch_capture_request::PatchCapture::generated_message_descriptor_data());
1819 let mut enums = ::std::vec::Vec::with_capacity(0);
1820 ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
1821 file_descriptor_proto(),
1822 deps,
1823 messages,
1824 enums,
1825 )
1826 });
1827 ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
1828 })
1829 }
1830