1#![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
22const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_4_0;
27
28#[derive(PartialEq,Clone,Default,Debug)]
30pub struct GetWorldInfoOut {
31 pub mode: ::std::option::Option<::protobuf::EnumOrUnknown<get_world_info_out::Mode>>,
34 pub save_dir: ::std::option::Option<::std::string::String>,
36 pub world_name: ::protobuf::MessageField<super::Basic::NameInfo>,
38 pub civ_id: ::std::option::Option<i32>,
40 pub site_id: ::std::option::Option<i32>,
42 pub group_id: ::std::option::Option<i32>,
44 pub race_id: ::std::option::Option<i32>,
46 pub player_unit_id: ::std::option::Option<i32>,
48 pub player_histfig_id: ::std::option::Option<i32>,
50 pub companion_histfig_ids: ::std::vec::Vec<i32>,
52 pub special_fields: ::protobuf::SpecialFields,
55}
56
57impl<'a> ::std::default::Default for &'a GetWorldInfoOut {
58 fn default() -> &'a GetWorldInfoOut {
59 <GetWorldInfoOut as ::protobuf::Message>::default_instance()
60 }
61}
62
63impl GetWorldInfoOut {
64 pub fn new() -> GetWorldInfoOut {
65 ::std::default::Default::default()
66 }
67
68 pub fn mode(&self) -> get_world_info_out::Mode {
71 match self.mode {
72 Some(e) => e.enum_value_or(get_world_info_out::Mode::MODE_DWARF),
73 None => get_world_info_out::Mode::MODE_DWARF,
74 }
75 }
76
77 pub fn clear_mode(&mut self) {
78 self.mode = ::std::option::Option::None;
79 }
80
81 pub fn has_mode(&self) -> bool {
82 self.mode.is_some()
83 }
84
85 pub fn set_mode(&mut self, v: get_world_info_out::Mode) {
87 self.mode = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
88 }
89
90 pub fn save_dir(&self) -> &str {
93 match self.save_dir.as_ref() {
94 Some(v) => v,
95 None => "",
96 }
97 }
98
99 pub fn clear_save_dir(&mut self) {
100 self.save_dir = ::std::option::Option::None;
101 }
102
103 pub fn has_save_dir(&self) -> bool {
104 self.save_dir.is_some()
105 }
106
107 pub fn set_save_dir(&mut self, v: ::std::string::String) {
109 self.save_dir = ::std::option::Option::Some(v);
110 }
111
112 pub fn mut_save_dir(&mut self) -> &mut ::std::string::String {
115 if self.save_dir.is_none() {
116 self.save_dir = ::std::option::Option::Some(::std::string::String::new());
117 }
118 self.save_dir.as_mut().unwrap()
119 }
120
121 pub fn take_save_dir(&mut self) -> ::std::string::String {
123 self.save_dir.take().unwrap_or_else(|| ::std::string::String::new())
124 }
125
126 pub fn civ_id(&self) -> i32 {
129 self.civ_id.unwrap_or(0)
130 }
131
132 pub fn clear_civ_id(&mut self) {
133 self.civ_id = ::std::option::Option::None;
134 }
135
136 pub fn has_civ_id(&self) -> bool {
137 self.civ_id.is_some()
138 }
139
140 pub fn set_civ_id(&mut self, v: i32) {
142 self.civ_id = ::std::option::Option::Some(v);
143 }
144
145 pub fn site_id(&self) -> i32 {
148 self.site_id.unwrap_or(0)
149 }
150
151 pub fn clear_site_id(&mut self) {
152 self.site_id = ::std::option::Option::None;
153 }
154
155 pub fn has_site_id(&self) -> bool {
156 self.site_id.is_some()
157 }
158
159 pub fn set_site_id(&mut self, v: i32) {
161 self.site_id = ::std::option::Option::Some(v);
162 }
163
164 pub fn group_id(&self) -> i32 {
167 self.group_id.unwrap_or(0)
168 }
169
170 pub fn clear_group_id(&mut self) {
171 self.group_id = ::std::option::Option::None;
172 }
173
174 pub fn has_group_id(&self) -> bool {
175 self.group_id.is_some()
176 }
177
178 pub fn set_group_id(&mut self, v: i32) {
180 self.group_id = ::std::option::Option::Some(v);
181 }
182
183 pub fn race_id(&self) -> i32 {
186 self.race_id.unwrap_or(0)
187 }
188
189 pub fn clear_race_id(&mut self) {
190 self.race_id = ::std::option::Option::None;
191 }
192
193 pub fn has_race_id(&self) -> bool {
194 self.race_id.is_some()
195 }
196
197 pub fn set_race_id(&mut self, v: i32) {
199 self.race_id = ::std::option::Option::Some(v);
200 }
201
202 pub fn player_unit_id(&self) -> i32 {
205 self.player_unit_id.unwrap_or(0)
206 }
207
208 pub fn clear_player_unit_id(&mut self) {
209 self.player_unit_id = ::std::option::Option::None;
210 }
211
212 pub fn has_player_unit_id(&self) -> bool {
213 self.player_unit_id.is_some()
214 }
215
216 pub fn set_player_unit_id(&mut self, v: i32) {
218 self.player_unit_id = ::std::option::Option::Some(v);
219 }
220
221 pub fn player_histfig_id(&self) -> i32 {
224 self.player_histfig_id.unwrap_or(0)
225 }
226
227 pub fn clear_player_histfig_id(&mut self) {
228 self.player_histfig_id = ::std::option::Option::None;
229 }
230
231 pub fn has_player_histfig_id(&self) -> bool {
232 self.player_histfig_id.is_some()
233 }
234
235 pub fn set_player_histfig_id(&mut self, v: i32) {
237 self.player_histfig_id = ::std::option::Option::Some(v);
238 }
239
240 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
241 let mut fields = ::std::vec::Vec::with_capacity(10);
242 let mut oneofs = ::std::vec::Vec::with_capacity(0);
243 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
244 "mode",
245 |m: &GetWorldInfoOut| { &m.mode },
246 |m: &mut GetWorldInfoOut| { &mut m.mode },
247 ));
248 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
249 "save_dir",
250 |m: &GetWorldInfoOut| { &m.save_dir },
251 |m: &mut GetWorldInfoOut| { &mut m.save_dir },
252 ));
253 fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::Basic::NameInfo>(
254 "world_name",
255 |m: &GetWorldInfoOut| { &m.world_name },
256 |m: &mut GetWorldInfoOut| { &mut m.world_name },
257 ));
258 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
259 "civ_id",
260 |m: &GetWorldInfoOut| { &m.civ_id },
261 |m: &mut GetWorldInfoOut| { &mut m.civ_id },
262 ));
263 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
264 "site_id",
265 |m: &GetWorldInfoOut| { &m.site_id },
266 |m: &mut GetWorldInfoOut| { &mut m.site_id },
267 ));
268 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
269 "group_id",
270 |m: &GetWorldInfoOut| { &m.group_id },
271 |m: &mut GetWorldInfoOut| { &mut m.group_id },
272 ));
273 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
274 "race_id",
275 |m: &GetWorldInfoOut| { &m.race_id },
276 |m: &mut GetWorldInfoOut| { &mut m.race_id },
277 ));
278 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
279 "player_unit_id",
280 |m: &GetWorldInfoOut| { &m.player_unit_id },
281 |m: &mut GetWorldInfoOut| { &mut m.player_unit_id },
282 ));
283 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
284 "player_histfig_id",
285 |m: &GetWorldInfoOut| { &m.player_histfig_id },
286 |m: &mut GetWorldInfoOut| { &mut m.player_histfig_id },
287 ));
288 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
289 "companion_histfig_ids",
290 |m: &GetWorldInfoOut| { &m.companion_histfig_ids },
291 |m: &mut GetWorldInfoOut| { &mut m.companion_histfig_ids },
292 ));
293 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetWorldInfoOut>(
294 "GetWorldInfoOut",
295 fields,
296 oneofs,
297 )
298 }
299}
300
301impl ::protobuf::Message for GetWorldInfoOut {
302 const NAME: &'static str = "GetWorldInfoOut";
303
304 fn is_initialized(&self) -> bool {
305 if self.mode.is_none() {
306 return false;
307 }
308 if self.save_dir.is_none() {
309 return false;
310 }
311 for v in &self.world_name {
312 if !v.is_initialized() {
313 return false;
314 }
315 };
316 true
317 }
318
319 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
320 while let Some(tag) = is.read_raw_tag_or_eof()? {
321 match tag {
322 8 => {
323 self.mode = ::std::option::Option::Some(is.read_enum_or_unknown()?);
324 },
325 18 => {
326 self.save_dir = ::std::option::Option::Some(is.read_string()?);
327 },
328 26 => {
329 ::protobuf::rt::read_singular_message_into_field(is, &mut self.world_name)?;
330 },
331 32 => {
332 self.civ_id = ::std::option::Option::Some(is.read_int32()?);
333 },
334 40 => {
335 self.site_id = ::std::option::Option::Some(is.read_int32()?);
336 },
337 48 => {
338 self.group_id = ::std::option::Option::Some(is.read_int32()?);
339 },
340 56 => {
341 self.race_id = ::std::option::Option::Some(is.read_int32()?);
342 },
343 64 => {
344 self.player_unit_id = ::std::option::Option::Some(is.read_int32()?);
345 },
346 72 => {
347 self.player_histfig_id = ::std::option::Option::Some(is.read_int32()?);
348 },
349 82 => {
350 is.read_repeated_packed_int32_into(&mut self.companion_histfig_ids)?;
351 },
352 80 => {
353 self.companion_histfig_ids.push(is.read_int32()?);
354 },
355 tag => {
356 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
357 },
358 };
359 }
360 ::std::result::Result::Ok(())
361 }
362
363 #[allow(unused_variables)]
365 fn compute_size(&self) -> u64 {
366 let mut my_size = 0;
367 if let Some(v) = self.mode {
368 my_size += ::protobuf::rt::int32_size(1, v.value());
369 }
370 if let Some(v) = self.save_dir.as_ref() {
371 my_size += ::protobuf::rt::string_size(2, &v);
372 }
373 if let Some(v) = self.world_name.as_ref() {
374 let len = v.compute_size();
375 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
376 }
377 if let Some(v) = self.civ_id {
378 my_size += ::protobuf::rt::int32_size(4, v);
379 }
380 if let Some(v) = self.site_id {
381 my_size += ::protobuf::rt::int32_size(5, v);
382 }
383 if let Some(v) = self.group_id {
384 my_size += ::protobuf::rt::int32_size(6, v);
385 }
386 if let Some(v) = self.race_id {
387 my_size += ::protobuf::rt::int32_size(7, v);
388 }
389 if let Some(v) = self.player_unit_id {
390 my_size += ::protobuf::rt::int32_size(8, v);
391 }
392 if let Some(v) = self.player_histfig_id {
393 my_size += ::protobuf::rt::int32_size(9, v);
394 }
395 for value in &self.companion_histfig_ids {
396 my_size += ::protobuf::rt::int32_size(10, *value);
397 };
398 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
399 self.special_fields.cached_size().set(my_size as u32);
400 my_size
401 }
402
403 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
404 if let Some(v) = self.mode {
405 os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?;
406 }
407 if let Some(v) = self.save_dir.as_ref() {
408 os.write_string(2, v)?;
409 }
410 if let Some(v) = self.world_name.as_ref() {
411 ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
412 }
413 if let Some(v) = self.civ_id {
414 os.write_int32(4, v)?;
415 }
416 if let Some(v) = self.site_id {
417 os.write_int32(5, v)?;
418 }
419 if let Some(v) = self.group_id {
420 os.write_int32(6, v)?;
421 }
422 if let Some(v) = self.race_id {
423 os.write_int32(7, v)?;
424 }
425 if let Some(v) = self.player_unit_id {
426 os.write_int32(8, v)?;
427 }
428 if let Some(v) = self.player_histfig_id {
429 os.write_int32(9, v)?;
430 }
431 for v in &self.companion_histfig_ids {
432 os.write_int32(10, *v)?;
433 };
434 os.write_unknown_fields(self.special_fields.unknown_fields())?;
435 ::std::result::Result::Ok(())
436 }
437
438 fn special_fields(&self) -> &::protobuf::SpecialFields {
439 &self.special_fields
440 }
441
442 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
443 &mut self.special_fields
444 }
445
446 fn new() -> GetWorldInfoOut {
447 GetWorldInfoOut::new()
448 }
449
450 fn clear(&mut self) {
451 self.mode = ::std::option::Option::None;
452 self.save_dir = ::std::option::Option::None;
453 self.world_name.clear();
454 self.civ_id = ::std::option::Option::None;
455 self.site_id = ::std::option::Option::None;
456 self.group_id = ::std::option::Option::None;
457 self.race_id = ::std::option::Option::None;
458 self.player_unit_id = ::std::option::Option::None;
459 self.player_histfig_id = ::std::option::Option::None;
460 self.companion_histfig_ids.clear();
461 self.special_fields.clear();
462 }
463
464 fn default_instance() -> &'static GetWorldInfoOut {
465 static instance: GetWorldInfoOut = GetWorldInfoOut {
466 mode: ::std::option::Option::None,
467 save_dir: ::std::option::Option::None,
468 world_name: ::protobuf::MessageField::none(),
469 civ_id: ::std::option::Option::None,
470 site_id: ::std::option::Option::None,
471 group_id: ::std::option::Option::None,
472 race_id: ::std::option::Option::None,
473 player_unit_id: ::std::option::Option::None,
474 player_histfig_id: ::std::option::Option::None,
475 companion_histfig_ids: ::std::vec::Vec::new(),
476 special_fields: ::protobuf::SpecialFields::new(),
477 };
478 &instance
479 }
480}
481
482impl ::protobuf::MessageFull for GetWorldInfoOut {
483 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
484 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
485 descriptor.get(|| file_descriptor().message_by_package_relative_name("GetWorldInfoOut").unwrap()).clone()
486 }
487}
488
489impl ::std::fmt::Display for GetWorldInfoOut {
490 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
491 ::protobuf::text_format::fmt(self, f)
492 }
493}
494
495impl ::protobuf::reflect::ProtobufValue for GetWorldInfoOut {
496 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
497}
498
499pub mod get_world_info_out {
501 #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
502 pub enum Mode {
504 MODE_DWARF = 1,
506 MODE_ADVENTURE = 2,
508 MODE_LEGENDS = 3,
510 }
511
512 impl ::protobuf::Enum for Mode {
513 const NAME: &'static str = "Mode";
514
515 fn value(&self) -> i32 {
516 *self as i32
517 }
518
519 fn from_i32(value: i32) -> ::std::option::Option<Mode> {
520 match value {
521 1 => ::std::option::Option::Some(Mode::MODE_DWARF),
522 2 => ::std::option::Option::Some(Mode::MODE_ADVENTURE),
523 3 => ::std::option::Option::Some(Mode::MODE_LEGENDS),
524 _ => ::std::option::Option::None
525 }
526 }
527
528 fn from_str(str: &str) -> ::std::option::Option<Mode> {
529 match str {
530 "MODE_DWARF" => ::std::option::Option::Some(Mode::MODE_DWARF),
531 "MODE_ADVENTURE" => ::std::option::Option::Some(Mode::MODE_ADVENTURE),
532 "MODE_LEGENDS" => ::std::option::Option::Some(Mode::MODE_LEGENDS),
533 _ => ::std::option::Option::None
534 }
535 }
536
537 const VALUES: &'static [Mode] = &[
538 Mode::MODE_DWARF,
539 Mode::MODE_ADVENTURE,
540 Mode::MODE_LEGENDS,
541 ];
542 }
543
544 impl ::protobuf::EnumFull for Mode {
545 fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
546 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
547 descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("GetWorldInfoOut.Mode").unwrap()).clone()
548 }
549
550 fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
551 let index = match self {
552 Mode::MODE_DWARF => 0,
553 Mode::MODE_ADVENTURE => 1,
554 Mode::MODE_LEGENDS => 2,
555 };
556 Self::enum_descriptor().value_by_index(index)
557 }
558 }
559
560 impl ::std::default::Default for Mode {
562 fn default() -> Self {
563 Mode::MODE_DWARF
564 }
565 }
566
567 impl Mode {
568 pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
569 ::protobuf::reflect::GeneratedEnumDescriptorData::new::<Mode>("GetWorldInfoOut.Mode")
570 }
571 }
572}
573
574#[derive(PartialEq,Clone,Default,Debug)]
576pub struct ListEnumsOut {
577 pub material_flags: ::std::vec::Vec<super::Basic::EnumItemName>,
580 pub inorganic_flags: ::std::vec::Vec<super::Basic::EnumItemName>,
582 pub unit_flags1: ::std::vec::Vec<super::Basic::EnumItemName>,
584 pub unit_flags2: ::std::vec::Vec<super::Basic::EnumItemName>,
586 pub unit_flags3: ::std::vec::Vec<super::Basic::EnumItemName>,
588 pub unit_labor: ::std::vec::Vec<super::Basic::EnumItemName>,
590 pub job_skill: ::std::vec::Vec<super::Basic::EnumItemName>,
592 pub cie_add_tag_mask1: ::std::vec::Vec<super::Basic::EnumItemName>,
594 pub cie_add_tag_mask2: ::std::vec::Vec<super::Basic::EnumItemName>,
596 pub death_info_flags: ::std::vec::Vec<super::Basic::EnumItemName>,
598 pub profession: ::std::vec::Vec<super::Basic::EnumItemName>,
600 pub special_fields: ::protobuf::SpecialFields,
603}
604
605impl<'a> ::std::default::Default for &'a ListEnumsOut {
606 fn default() -> &'a ListEnumsOut {
607 <ListEnumsOut as ::protobuf::Message>::default_instance()
608 }
609}
610
611impl ListEnumsOut {
612 pub fn new() -> ListEnumsOut {
613 ::std::default::Default::default()
614 }
615
616 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
617 let mut fields = ::std::vec::Vec::with_capacity(11);
618 let mut oneofs = ::std::vec::Vec::with_capacity(0);
619 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
620 "material_flags",
621 |m: &ListEnumsOut| { &m.material_flags },
622 |m: &mut ListEnumsOut| { &mut m.material_flags },
623 ));
624 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
625 "inorganic_flags",
626 |m: &ListEnumsOut| { &m.inorganic_flags },
627 |m: &mut ListEnumsOut| { &mut m.inorganic_flags },
628 ));
629 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
630 "unit_flags1",
631 |m: &ListEnumsOut| { &m.unit_flags1 },
632 |m: &mut ListEnumsOut| { &mut m.unit_flags1 },
633 ));
634 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
635 "unit_flags2",
636 |m: &ListEnumsOut| { &m.unit_flags2 },
637 |m: &mut ListEnumsOut| { &mut m.unit_flags2 },
638 ));
639 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
640 "unit_flags3",
641 |m: &ListEnumsOut| { &m.unit_flags3 },
642 |m: &mut ListEnumsOut| { &mut m.unit_flags3 },
643 ));
644 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
645 "unit_labor",
646 |m: &ListEnumsOut| { &m.unit_labor },
647 |m: &mut ListEnumsOut| { &mut m.unit_labor },
648 ));
649 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
650 "job_skill",
651 |m: &ListEnumsOut| { &m.job_skill },
652 |m: &mut ListEnumsOut| { &mut m.job_skill },
653 ));
654 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
655 "cie_add_tag_mask1",
656 |m: &ListEnumsOut| { &m.cie_add_tag_mask1 },
657 |m: &mut ListEnumsOut| { &mut m.cie_add_tag_mask1 },
658 ));
659 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
660 "cie_add_tag_mask2",
661 |m: &ListEnumsOut| { &m.cie_add_tag_mask2 },
662 |m: &mut ListEnumsOut| { &mut m.cie_add_tag_mask2 },
663 ));
664 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
665 "death_info_flags",
666 |m: &ListEnumsOut| { &m.death_info_flags },
667 |m: &mut ListEnumsOut| { &mut m.death_info_flags },
668 ));
669 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
670 "profession",
671 |m: &ListEnumsOut| { &m.profession },
672 |m: &mut ListEnumsOut| { &mut m.profession },
673 ));
674 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ListEnumsOut>(
675 "ListEnumsOut",
676 fields,
677 oneofs,
678 )
679 }
680}
681
682impl ::protobuf::Message for ListEnumsOut {
683 const NAME: &'static str = "ListEnumsOut";
684
685 fn is_initialized(&self) -> bool {
686 for v in &self.material_flags {
687 if !v.is_initialized() {
688 return false;
689 }
690 };
691 for v in &self.inorganic_flags {
692 if !v.is_initialized() {
693 return false;
694 }
695 };
696 for v in &self.unit_flags1 {
697 if !v.is_initialized() {
698 return false;
699 }
700 };
701 for v in &self.unit_flags2 {
702 if !v.is_initialized() {
703 return false;
704 }
705 };
706 for v in &self.unit_flags3 {
707 if !v.is_initialized() {
708 return false;
709 }
710 };
711 for v in &self.unit_labor {
712 if !v.is_initialized() {
713 return false;
714 }
715 };
716 for v in &self.job_skill {
717 if !v.is_initialized() {
718 return false;
719 }
720 };
721 for v in &self.cie_add_tag_mask1 {
722 if !v.is_initialized() {
723 return false;
724 }
725 };
726 for v in &self.cie_add_tag_mask2 {
727 if !v.is_initialized() {
728 return false;
729 }
730 };
731 for v in &self.death_info_flags {
732 if !v.is_initialized() {
733 return false;
734 }
735 };
736 for v in &self.profession {
737 if !v.is_initialized() {
738 return false;
739 }
740 };
741 true
742 }
743
744 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
745 while let Some(tag) = is.read_raw_tag_or_eof()? {
746 match tag {
747 10 => {
748 self.material_flags.push(is.read_message()?);
749 },
750 18 => {
751 self.inorganic_flags.push(is.read_message()?);
752 },
753 26 => {
754 self.unit_flags1.push(is.read_message()?);
755 },
756 34 => {
757 self.unit_flags2.push(is.read_message()?);
758 },
759 42 => {
760 self.unit_flags3.push(is.read_message()?);
761 },
762 50 => {
763 self.unit_labor.push(is.read_message()?);
764 },
765 58 => {
766 self.job_skill.push(is.read_message()?);
767 },
768 66 => {
769 self.cie_add_tag_mask1.push(is.read_message()?);
770 },
771 74 => {
772 self.cie_add_tag_mask2.push(is.read_message()?);
773 },
774 82 => {
775 self.death_info_flags.push(is.read_message()?);
776 },
777 90 => {
778 self.profession.push(is.read_message()?);
779 },
780 tag => {
781 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
782 },
783 };
784 }
785 ::std::result::Result::Ok(())
786 }
787
788 #[allow(unused_variables)]
790 fn compute_size(&self) -> u64 {
791 let mut my_size = 0;
792 for value in &self.material_flags {
793 let len = value.compute_size();
794 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
795 };
796 for value in &self.inorganic_flags {
797 let len = value.compute_size();
798 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
799 };
800 for value in &self.unit_flags1 {
801 let len = value.compute_size();
802 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
803 };
804 for value in &self.unit_flags2 {
805 let len = value.compute_size();
806 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
807 };
808 for value in &self.unit_flags3 {
809 let len = value.compute_size();
810 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
811 };
812 for value in &self.unit_labor {
813 let len = value.compute_size();
814 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
815 };
816 for value in &self.job_skill {
817 let len = value.compute_size();
818 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
819 };
820 for value in &self.cie_add_tag_mask1 {
821 let len = value.compute_size();
822 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
823 };
824 for value in &self.cie_add_tag_mask2 {
825 let len = value.compute_size();
826 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
827 };
828 for value in &self.death_info_flags {
829 let len = value.compute_size();
830 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
831 };
832 for value in &self.profession {
833 let len = value.compute_size();
834 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
835 };
836 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
837 self.special_fields.cached_size().set(my_size as u32);
838 my_size
839 }
840
841 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
842 for v in &self.material_flags {
843 ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
844 };
845 for v in &self.inorganic_flags {
846 ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
847 };
848 for v in &self.unit_flags1 {
849 ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
850 };
851 for v in &self.unit_flags2 {
852 ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
853 };
854 for v in &self.unit_flags3 {
855 ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
856 };
857 for v in &self.unit_labor {
858 ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
859 };
860 for v in &self.job_skill {
861 ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
862 };
863 for v in &self.cie_add_tag_mask1 {
864 ::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
865 };
866 for v in &self.cie_add_tag_mask2 {
867 ::protobuf::rt::write_message_field_with_cached_size(9, v, os)?;
868 };
869 for v in &self.death_info_flags {
870 ::protobuf::rt::write_message_field_with_cached_size(10, v, os)?;
871 };
872 for v in &self.profession {
873 ::protobuf::rt::write_message_field_with_cached_size(11, v, os)?;
874 };
875 os.write_unknown_fields(self.special_fields.unknown_fields())?;
876 ::std::result::Result::Ok(())
877 }
878
879 fn special_fields(&self) -> &::protobuf::SpecialFields {
880 &self.special_fields
881 }
882
883 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
884 &mut self.special_fields
885 }
886
887 fn new() -> ListEnumsOut {
888 ListEnumsOut::new()
889 }
890
891 fn clear(&mut self) {
892 self.material_flags.clear();
893 self.inorganic_flags.clear();
894 self.unit_flags1.clear();
895 self.unit_flags2.clear();
896 self.unit_flags3.clear();
897 self.unit_labor.clear();
898 self.job_skill.clear();
899 self.cie_add_tag_mask1.clear();
900 self.cie_add_tag_mask2.clear();
901 self.death_info_flags.clear();
902 self.profession.clear();
903 self.special_fields.clear();
904 }
905
906 fn default_instance() -> &'static ListEnumsOut {
907 static instance: ListEnumsOut = ListEnumsOut {
908 material_flags: ::std::vec::Vec::new(),
909 inorganic_flags: ::std::vec::Vec::new(),
910 unit_flags1: ::std::vec::Vec::new(),
911 unit_flags2: ::std::vec::Vec::new(),
912 unit_flags3: ::std::vec::Vec::new(),
913 unit_labor: ::std::vec::Vec::new(),
914 job_skill: ::std::vec::Vec::new(),
915 cie_add_tag_mask1: ::std::vec::Vec::new(),
916 cie_add_tag_mask2: ::std::vec::Vec::new(),
917 death_info_flags: ::std::vec::Vec::new(),
918 profession: ::std::vec::Vec::new(),
919 special_fields: ::protobuf::SpecialFields::new(),
920 };
921 &instance
922 }
923}
924
925impl ::protobuf::MessageFull for ListEnumsOut {
926 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
927 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
928 descriptor.get(|| file_descriptor().message_by_package_relative_name("ListEnumsOut").unwrap()).clone()
929 }
930}
931
932impl ::std::fmt::Display for ListEnumsOut {
933 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
934 ::protobuf::text_format::fmt(self, f)
935 }
936}
937
938impl ::protobuf::reflect::ProtobufValue for ListEnumsOut {
939 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
940}
941
942#[derive(PartialEq,Clone,Default,Debug)]
944pub struct ListJobSkillsOut {
945 pub skill: ::std::vec::Vec<super::Basic::JobSkillAttr>,
948 pub profession: ::std::vec::Vec<super::Basic::ProfessionAttr>,
950 pub labor: ::std::vec::Vec<super::Basic::UnitLaborAttr>,
952 pub special_fields: ::protobuf::SpecialFields,
955}
956
957impl<'a> ::std::default::Default for &'a ListJobSkillsOut {
958 fn default() -> &'a ListJobSkillsOut {
959 <ListJobSkillsOut as ::protobuf::Message>::default_instance()
960 }
961}
962
963impl ListJobSkillsOut {
964 pub fn new() -> ListJobSkillsOut {
965 ::std::default::Default::default()
966 }
967
968 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
969 let mut fields = ::std::vec::Vec::with_capacity(3);
970 let mut oneofs = ::std::vec::Vec::with_capacity(0);
971 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
972 "skill",
973 |m: &ListJobSkillsOut| { &m.skill },
974 |m: &mut ListJobSkillsOut| { &mut m.skill },
975 ));
976 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
977 "profession",
978 |m: &ListJobSkillsOut| { &m.profession },
979 |m: &mut ListJobSkillsOut| { &mut m.profession },
980 ));
981 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
982 "labor",
983 |m: &ListJobSkillsOut| { &m.labor },
984 |m: &mut ListJobSkillsOut| { &mut m.labor },
985 ));
986 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ListJobSkillsOut>(
987 "ListJobSkillsOut",
988 fields,
989 oneofs,
990 )
991 }
992}
993
994impl ::protobuf::Message for ListJobSkillsOut {
995 const NAME: &'static str = "ListJobSkillsOut";
996
997 fn is_initialized(&self) -> bool {
998 for v in &self.skill {
999 if !v.is_initialized() {
1000 return false;
1001 }
1002 };
1003 for v in &self.profession {
1004 if !v.is_initialized() {
1005 return false;
1006 }
1007 };
1008 for v in &self.labor {
1009 if !v.is_initialized() {
1010 return false;
1011 }
1012 };
1013 true
1014 }
1015
1016 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1017 while let Some(tag) = is.read_raw_tag_or_eof()? {
1018 match tag {
1019 10 => {
1020 self.skill.push(is.read_message()?);
1021 },
1022 18 => {
1023 self.profession.push(is.read_message()?);
1024 },
1025 26 => {
1026 self.labor.push(is.read_message()?);
1027 },
1028 tag => {
1029 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1030 },
1031 };
1032 }
1033 ::std::result::Result::Ok(())
1034 }
1035
1036 #[allow(unused_variables)]
1038 fn compute_size(&self) -> u64 {
1039 let mut my_size = 0;
1040 for value in &self.skill {
1041 let len = value.compute_size();
1042 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
1043 };
1044 for value in &self.profession {
1045 let len = value.compute_size();
1046 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
1047 };
1048 for value in &self.labor {
1049 let len = value.compute_size();
1050 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
1051 };
1052 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1053 self.special_fields.cached_size().set(my_size as u32);
1054 my_size
1055 }
1056
1057 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1058 for v in &self.skill {
1059 ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
1060 };
1061 for v in &self.profession {
1062 ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
1063 };
1064 for v in &self.labor {
1065 ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
1066 };
1067 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1068 ::std::result::Result::Ok(())
1069 }
1070
1071 fn special_fields(&self) -> &::protobuf::SpecialFields {
1072 &self.special_fields
1073 }
1074
1075 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1076 &mut self.special_fields
1077 }
1078
1079 fn new() -> ListJobSkillsOut {
1080 ListJobSkillsOut::new()
1081 }
1082
1083 fn clear(&mut self) {
1084 self.skill.clear();
1085 self.profession.clear();
1086 self.labor.clear();
1087 self.special_fields.clear();
1088 }
1089
1090 fn default_instance() -> &'static ListJobSkillsOut {
1091 static instance: ListJobSkillsOut = ListJobSkillsOut {
1092 skill: ::std::vec::Vec::new(),
1093 profession: ::std::vec::Vec::new(),
1094 labor: ::std::vec::Vec::new(),
1095 special_fields: ::protobuf::SpecialFields::new(),
1096 };
1097 &instance
1098 }
1099}
1100
1101impl ::protobuf::MessageFull for ListJobSkillsOut {
1102 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1103 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1104 descriptor.get(|| file_descriptor().message_by_package_relative_name("ListJobSkillsOut").unwrap()).clone()
1105 }
1106}
1107
1108impl ::std::fmt::Display for ListJobSkillsOut {
1109 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1110 ::protobuf::text_format::fmt(self, f)
1111 }
1112}
1113
1114impl ::protobuf::reflect::ProtobufValue for ListJobSkillsOut {
1115 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1116}
1117
1118#[derive(PartialEq,Clone,Default,Debug)]
1120pub struct ListMaterialsIn {
1121 pub mask: ::protobuf::MessageField<super::Basic::BasicMaterialInfoMask>,
1124 pub id_list: ::std::vec::Vec<super::Basic::BasicMaterialId>,
1126 pub builtin: ::std::option::Option<bool>,
1128 pub inorganic: ::std::option::Option<bool>,
1130 pub creatures: ::std::option::Option<bool>,
1132 pub plants: ::std::option::Option<bool>,
1134 pub special_fields: ::protobuf::SpecialFields,
1137}
1138
1139impl<'a> ::std::default::Default for &'a ListMaterialsIn {
1140 fn default() -> &'a ListMaterialsIn {
1141 <ListMaterialsIn as ::protobuf::Message>::default_instance()
1142 }
1143}
1144
1145impl ListMaterialsIn {
1146 pub fn new() -> ListMaterialsIn {
1147 ::std::default::Default::default()
1148 }
1149
1150 pub fn builtin(&self) -> bool {
1153 self.builtin.unwrap_or(false)
1154 }
1155
1156 pub fn clear_builtin(&mut self) {
1157 self.builtin = ::std::option::Option::None;
1158 }
1159
1160 pub fn has_builtin(&self) -> bool {
1161 self.builtin.is_some()
1162 }
1163
1164 pub fn set_builtin(&mut self, v: bool) {
1166 self.builtin = ::std::option::Option::Some(v);
1167 }
1168
1169 pub fn inorganic(&self) -> bool {
1172 self.inorganic.unwrap_or(false)
1173 }
1174
1175 pub fn clear_inorganic(&mut self) {
1176 self.inorganic = ::std::option::Option::None;
1177 }
1178
1179 pub fn has_inorganic(&self) -> bool {
1180 self.inorganic.is_some()
1181 }
1182
1183 pub fn set_inorganic(&mut self, v: bool) {
1185 self.inorganic = ::std::option::Option::Some(v);
1186 }
1187
1188 pub fn creatures(&self) -> bool {
1191 self.creatures.unwrap_or(false)
1192 }
1193
1194 pub fn clear_creatures(&mut self) {
1195 self.creatures = ::std::option::Option::None;
1196 }
1197
1198 pub fn has_creatures(&self) -> bool {
1199 self.creatures.is_some()
1200 }
1201
1202 pub fn set_creatures(&mut self, v: bool) {
1204 self.creatures = ::std::option::Option::Some(v);
1205 }
1206
1207 pub fn plants(&self) -> bool {
1210 self.plants.unwrap_or(false)
1211 }
1212
1213 pub fn clear_plants(&mut self) {
1214 self.plants = ::std::option::Option::None;
1215 }
1216
1217 pub fn has_plants(&self) -> bool {
1218 self.plants.is_some()
1219 }
1220
1221 pub fn set_plants(&mut self, v: bool) {
1223 self.plants = ::std::option::Option::Some(v);
1224 }
1225
1226 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1227 let mut fields = ::std::vec::Vec::with_capacity(6);
1228 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1229 fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::Basic::BasicMaterialInfoMask>(
1230 "mask",
1231 |m: &ListMaterialsIn| { &m.mask },
1232 |m: &mut ListMaterialsIn| { &mut m.mask },
1233 ));
1234 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
1235 "id_list",
1236 |m: &ListMaterialsIn| { &m.id_list },
1237 |m: &mut ListMaterialsIn| { &mut m.id_list },
1238 ));
1239 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1240 "builtin",
1241 |m: &ListMaterialsIn| { &m.builtin },
1242 |m: &mut ListMaterialsIn| { &mut m.builtin },
1243 ));
1244 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1245 "inorganic",
1246 |m: &ListMaterialsIn| { &m.inorganic },
1247 |m: &mut ListMaterialsIn| { &mut m.inorganic },
1248 ));
1249 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1250 "creatures",
1251 |m: &ListMaterialsIn| { &m.creatures },
1252 |m: &mut ListMaterialsIn| { &mut m.creatures },
1253 ));
1254 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1255 "plants",
1256 |m: &ListMaterialsIn| { &m.plants },
1257 |m: &mut ListMaterialsIn| { &mut m.plants },
1258 ));
1259 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ListMaterialsIn>(
1260 "ListMaterialsIn",
1261 fields,
1262 oneofs,
1263 )
1264 }
1265}
1266
1267impl ::protobuf::Message for ListMaterialsIn {
1268 const NAME: &'static str = "ListMaterialsIn";
1269
1270 fn is_initialized(&self) -> bool {
1271 for v in &self.mask {
1272 if !v.is_initialized() {
1273 return false;
1274 }
1275 };
1276 for v in &self.id_list {
1277 if !v.is_initialized() {
1278 return false;
1279 }
1280 };
1281 true
1282 }
1283
1284 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1285 while let Some(tag) = is.read_raw_tag_or_eof()? {
1286 match tag {
1287 10 => {
1288 ::protobuf::rt::read_singular_message_into_field(is, &mut self.mask)?;
1289 },
1290 18 => {
1291 self.id_list.push(is.read_message()?);
1292 },
1293 24 => {
1294 self.builtin = ::std::option::Option::Some(is.read_bool()?);
1295 },
1296 32 => {
1297 self.inorganic = ::std::option::Option::Some(is.read_bool()?);
1298 },
1299 40 => {
1300 self.creatures = ::std::option::Option::Some(is.read_bool()?);
1301 },
1302 48 => {
1303 self.plants = ::std::option::Option::Some(is.read_bool()?);
1304 },
1305 tag => {
1306 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1307 },
1308 };
1309 }
1310 ::std::result::Result::Ok(())
1311 }
1312
1313 #[allow(unused_variables)]
1315 fn compute_size(&self) -> u64 {
1316 let mut my_size = 0;
1317 if let Some(v) = self.mask.as_ref() {
1318 let len = v.compute_size();
1319 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
1320 }
1321 for value in &self.id_list {
1322 let len = value.compute_size();
1323 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
1324 };
1325 if let Some(v) = self.builtin {
1326 my_size += 1 + 1;
1327 }
1328 if let Some(v) = self.inorganic {
1329 my_size += 1 + 1;
1330 }
1331 if let Some(v) = self.creatures {
1332 my_size += 1 + 1;
1333 }
1334 if let Some(v) = self.plants {
1335 my_size += 1 + 1;
1336 }
1337 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1338 self.special_fields.cached_size().set(my_size as u32);
1339 my_size
1340 }
1341
1342 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1343 if let Some(v) = self.mask.as_ref() {
1344 ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
1345 }
1346 for v in &self.id_list {
1347 ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
1348 };
1349 if let Some(v) = self.builtin {
1350 os.write_bool(3, v)?;
1351 }
1352 if let Some(v) = self.inorganic {
1353 os.write_bool(4, v)?;
1354 }
1355 if let Some(v) = self.creatures {
1356 os.write_bool(5, v)?;
1357 }
1358 if let Some(v) = self.plants {
1359 os.write_bool(6, v)?;
1360 }
1361 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1362 ::std::result::Result::Ok(())
1363 }
1364
1365 fn special_fields(&self) -> &::protobuf::SpecialFields {
1366 &self.special_fields
1367 }
1368
1369 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1370 &mut self.special_fields
1371 }
1372
1373 fn new() -> ListMaterialsIn {
1374 ListMaterialsIn::new()
1375 }
1376
1377 fn clear(&mut self) {
1378 self.mask.clear();
1379 self.id_list.clear();
1380 self.builtin = ::std::option::Option::None;
1381 self.inorganic = ::std::option::Option::None;
1382 self.creatures = ::std::option::Option::None;
1383 self.plants = ::std::option::Option::None;
1384 self.special_fields.clear();
1385 }
1386
1387 fn default_instance() -> &'static ListMaterialsIn {
1388 static instance: ListMaterialsIn = ListMaterialsIn {
1389 mask: ::protobuf::MessageField::none(),
1390 id_list: ::std::vec::Vec::new(),
1391 builtin: ::std::option::Option::None,
1392 inorganic: ::std::option::Option::None,
1393 creatures: ::std::option::Option::None,
1394 plants: ::std::option::Option::None,
1395 special_fields: ::protobuf::SpecialFields::new(),
1396 };
1397 &instance
1398 }
1399}
1400
1401impl ::protobuf::MessageFull for ListMaterialsIn {
1402 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1403 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1404 descriptor.get(|| file_descriptor().message_by_package_relative_name("ListMaterialsIn").unwrap()).clone()
1405 }
1406}
1407
1408impl ::std::fmt::Display for ListMaterialsIn {
1409 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1410 ::protobuf::text_format::fmt(self, f)
1411 }
1412}
1413
1414impl ::protobuf::reflect::ProtobufValue for ListMaterialsIn {
1415 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1416}
1417
1418#[derive(PartialEq,Clone,Default,Debug)]
1420pub struct ListMaterialsOut {
1421 pub value: ::std::vec::Vec<super::Basic::BasicMaterialInfo>,
1424 pub special_fields: ::protobuf::SpecialFields,
1427}
1428
1429impl<'a> ::std::default::Default for &'a ListMaterialsOut {
1430 fn default() -> &'a ListMaterialsOut {
1431 <ListMaterialsOut as ::protobuf::Message>::default_instance()
1432 }
1433}
1434
1435impl ListMaterialsOut {
1436 pub fn new() -> ListMaterialsOut {
1437 ::std::default::Default::default()
1438 }
1439
1440 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1441 let mut fields = ::std::vec::Vec::with_capacity(1);
1442 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1443 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
1444 "value",
1445 |m: &ListMaterialsOut| { &m.value },
1446 |m: &mut ListMaterialsOut| { &mut m.value },
1447 ));
1448 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ListMaterialsOut>(
1449 "ListMaterialsOut",
1450 fields,
1451 oneofs,
1452 )
1453 }
1454}
1455
1456impl ::protobuf::Message for ListMaterialsOut {
1457 const NAME: &'static str = "ListMaterialsOut";
1458
1459 fn is_initialized(&self) -> bool {
1460 for v in &self.value {
1461 if !v.is_initialized() {
1462 return false;
1463 }
1464 };
1465 true
1466 }
1467
1468 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1469 while let Some(tag) = is.read_raw_tag_or_eof()? {
1470 match tag {
1471 10 => {
1472 self.value.push(is.read_message()?);
1473 },
1474 tag => {
1475 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1476 },
1477 };
1478 }
1479 ::std::result::Result::Ok(())
1480 }
1481
1482 #[allow(unused_variables)]
1484 fn compute_size(&self) -> u64 {
1485 let mut my_size = 0;
1486 for value in &self.value {
1487 let len = value.compute_size();
1488 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
1489 };
1490 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1491 self.special_fields.cached_size().set(my_size as u32);
1492 my_size
1493 }
1494
1495 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1496 for v in &self.value {
1497 ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
1498 };
1499 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1500 ::std::result::Result::Ok(())
1501 }
1502
1503 fn special_fields(&self) -> &::protobuf::SpecialFields {
1504 &self.special_fields
1505 }
1506
1507 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1508 &mut self.special_fields
1509 }
1510
1511 fn new() -> ListMaterialsOut {
1512 ListMaterialsOut::new()
1513 }
1514
1515 fn clear(&mut self) {
1516 self.value.clear();
1517 self.special_fields.clear();
1518 }
1519
1520 fn default_instance() -> &'static ListMaterialsOut {
1521 static instance: ListMaterialsOut = ListMaterialsOut {
1522 value: ::std::vec::Vec::new(),
1523 special_fields: ::protobuf::SpecialFields::new(),
1524 };
1525 &instance
1526 }
1527}
1528
1529impl ::protobuf::MessageFull for ListMaterialsOut {
1530 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1531 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1532 descriptor.get(|| file_descriptor().message_by_package_relative_name("ListMaterialsOut").unwrap()).clone()
1533 }
1534}
1535
1536impl ::std::fmt::Display for ListMaterialsOut {
1537 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1538 ::protobuf::text_format::fmt(self, f)
1539 }
1540}
1541
1542impl ::protobuf::reflect::ProtobufValue for ListMaterialsOut {
1543 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1544}
1545
1546#[derive(PartialEq,Clone,Default,Debug)]
1548pub struct ListUnitsIn {
1549 pub mask: ::protobuf::MessageField<super::Basic::BasicUnitInfoMask>,
1552 pub id_list: ::std::vec::Vec<i32>,
1554 pub scan_all: ::std::option::Option<bool>,
1556 pub race: ::std::option::Option<i32>,
1558 pub civ_id: ::std::option::Option<i32>,
1560 pub dead: ::std::option::Option<bool>,
1562 pub alive: ::std::option::Option<bool>,
1564 pub sane: ::std::option::Option<bool>,
1566 pub special_fields: ::protobuf::SpecialFields,
1569}
1570
1571impl<'a> ::std::default::Default for &'a ListUnitsIn {
1572 fn default() -> &'a ListUnitsIn {
1573 <ListUnitsIn as ::protobuf::Message>::default_instance()
1574 }
1575}
1576
1577impl ListUnitsIn {
1578 pub fn new() -> ListUnitsIn {
1579 ::std::default::Default::default()
1580 }
1581
1582 pub fn scan_all(&self) -> bool {
1585 self.scan_all.unwrap_or(false)
1586 }
1587
1588 pub fn clear_scan_all(&mut self) {
1589 self.scan_all = ::std::option::Option::None;
1590 }
1591
1592 pub fn has_scan_all(&self) -> bool {
1593 self.scan_all.is_some()
1594 }
1595
1596 pub fn set_scan_all(&mut self, v: bool) {
1598 self.scan_all = ::std::option::Option::Some(v);
1599 }
1600
1601 pub fn race(&self) -> i32 {
1604 self.race.unwrap_or(0)
1605 }
1606
1607 pub fn clear_race(&mut self) {
1608 self.race = ::std::option::Option::None;
1609 }
1610
1611 pub fn has_race(&self) -> bool {
1612 self.race.is_some()
1613 }
1614
1615 pub fn set_race(&mut self, v: i32) {
1617 self.race = ::std::option::Option::Some(v);
1618 }
1619
1620 pub fn civ_id(&self) -> i32 {
1623 self.civ_id.unwrap_or(0)
1624 }
1625
1626 pub fn clear_civ_id(&mut self) {
1627 self.civ_id = ::std::option::Option::None;
1628 }
1629
1630 pub fn has_civ_id(&self) -> bool {
1631 self.civ_id.is_some()
1632 }
1633
1634 pub fn set_civ_id(&mut self, v: i32) {
1636 self.civ_id = ::std::option::Option::Some(v);
1637 }
1638
1639 pub fn dead(&self) -> bool {
1642 self.dead.unwrap_or(false)
1643 }
1644
1645 pub fn clear_dead(&mut self) {
1646 self.dead = ::std::option::Option::None;
1647 }
1648
1649 pub fn has_dead(&self) -> bool {
1650 self.dead.is_some()
1651 }
1652
1653 pub fn set_dead(&mut self, v: bool) {
1655 self.dead = ::std::option::Option::Some(v);
1656 }
1657
1658 pub fn alive(&self) -> bool {
1661 self.alive.unwrap_or(false)
1662 }
1663
1664 pub fn clear_alive(&mut self) {
1665 self.alive = ::std::option::Option::None;
1666 }
1667
1668 pub fn has_alive(&self) -> bool {
1669 self.alive.is_some()
1670 }
1671
1672 pub fn set_alive(&mut self, v: bool) {
1674 self.alive = ::std::option::Option::Some(v);
1675 }
1676
1677 pub fn sane(&self) -> bool {
1680 self.sane.unwrap_or(false)
1681 }
1682
1683 pub fn clear_sane(&mut self) {
1684 self.sane = ::std::option::Option::None;
1685 }
1686
1687 pub fn has_sane(&self) -> bool {
1688 self.sane.is_some()
1689 }
1690
1691 pub fn set_sane(&mut self, v: bool) {
1693 self.sane = ::std::option::Option::Some(v);
1694 }
1695
1696 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1697 let mut fields = ::std::vec::Vec::with_capacity(8);
1698 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1699 fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::Basic::BasicUnitInfoMask>(
1700 "mask",
1701 |m: &ListUnitsIn| { &m.mask },
1702 |m: &mut ListUnitsIn| { &mut m.mask },
1703 ));
1704 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
1705 "id_list",
1706 |m: &ListUnitsIn| { &m.id_list },
1707 |m: &mut ListUnitsIn| { &mut m.id_list },
1708 ));
1709 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1710 "scan_all",
1711 |m: &ListUnitsIn| { &m.scan_all },
1712 |m: &mut ListUnitsIn| { &mut m.scan_all },
1713 ));
1714 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1715 "race",
1716 |m: &ListUnitsIn| { &m.race },
1717 |m: &mut ListUnitsIn| { &mut m.race },
1718 ));
1719 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1720 "civ_id",
1721 |m: &ListUnitsIn| { &m.civ_id },
1722 |m: &mut ListUnitsIn| { &mut m.civ_id },
1723 ));
1724 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1725 "dead",
1726 |m: &ListUnitsIn| { &m.dead },
1727 |m: &mut ListUnitsIn| { &mut m.dead },
1728 ));
1729 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1730 "alive",
1731 |m: &ListUnitsIn| { &m.alive },
1732 |m: &mut ListUnitsIn| { &mut m.alive },
1733 ));
1734 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1735 "sane",
1736 |m: &ListUnitsIn| { &m.sane },
1737 |m: &mut ListUnitsIn| { &mut m.sane },
1738 ));
1739 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ListUnitsIn>(
1740 "ListUnitsIn",
1741 fields,
1742 oneofs,
1743 )
1744 }
1745}
1746
1747impl ::protobuf::Message for ListUnitsIn {
1748 const NAME: &'static str = "ListUnitsIn";
1749
1750 fn is_initialized(&self) -> bool {
1751 true
1752 }
1753
1754 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1755 while let Some(tag) = is.read_raw_tag_or_eof()? {
1756 match tag {
1757 10 => {
1758 ::protobuf::rt::read_singular_message_into_field(is, &mut self.mask)?;
1759 },
1760 18 => {
1761 is.read_repeated_packed_int32_into(&mut self.id_list)?;
1762 },
1763 16 => {
1764 self.id_list.push(is.read_int32()?);
1765 },
1766 40 => {
1767 self.scan_all = ::std::option::Option::Some(is.read_bool()?);
1768 },
1769 24 => {
1770 self.race = ::std::option::Option::Some(is.read_int32()?);
1771 },
1772 32 => {
1773 self.civ_id = ::std::option::Option::Some(is.read_int32()?);
1774 },
1775 48 => {
1776 self.dead = ::std::option::Option::Some(is.read_bool()?);
1777 },
1778 56 => {
1779 self.alive = ::std::option::Option::Some(is.read_bool()?);
1780 },
1781 64 => {
1782 self.sane = ::std::option::Option::Some(is.read_bool()?);
1783 },
1784 tag => {
1785 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1786 },
1787 };
1788 }
1789 ::std::result::Result::Ok(())
1790 }
1791
1792 #[allow(unused_variables)]
1794 fn compute_size(&self) -> u64 {
1795 let mut my_size = 0;
1796 if let Some(v) = self.mask.as_ref() {
1797 let len = v.compute_size();
1798 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
1799 }
1800 for value in &self.id_list {
1801 my_size += ::protobuf::rt::int32_size(2, *value);
1802 };
1803 if let Some(v) = self.scan_all {
1804 my_size += 1 + 1;
1805 }
1806 if let Some(v) = self.race {
1807 my_size += ::protobuf::rt::int32_size(3, v);
1808 }
1809 if let Some(v) = self.civ_id {
1810 my_size += ::protobuf::rt::int32_size(4, v);
1811 }
1812 if let Some(v) = self.dead {
1813 my_size += 1 + 1;
1814 }
1815 if let Some(v) = self.alive {
1816 my_size += 1 + 1;
1817 }
1818 if let Some(v) = self.sane {
1819 my_size += 1 + 1;
1820 }
1821 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1822 self.special_fields.cached_size().set(my_size as u32);
1823 my_size
1824 }
1825
1826 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1827 if let Some(v) = self.mask.as_ref() {
1828 ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
1829 }
1830 for v in &self.id_list {
1831 os.write_int32(2, *v)?;
1832 };
1833 if let Some(v) = self.scan_all {
1834 os.write_bool(5, v)?;
1835 }
1836 if let Some(v) = self.race {
1837 os.write_int32(3, v)?;
1838 }
1839 if let Some(v) = self.civ_id {
1840 os.write_int32(4, v)?;
1841 }
1842 if let Some(v) = self.dead {
1843 os.write_bool(6, v)?;
1844 }
1845 if let Some(v) = self.alive {
1846 os.write_bool(7, v)?;
1847 }
1848 if let Some(v) = self.sane {
1849 os.write_bool(8, v)?;
1850 }
1851 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1852 ::std::result::Result::Ok(())
1853 }
1854
1855 fn special_fields(&self) -> &::protobuf::SpecialFields {
1856 &self.special_fields
1857 }
1858
1859 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1860 &mut self.special_fields
1861 }
1862
1863 fn new() -> ListUnitsIn {
1864 ListUnitsIn::new()
1865 }
1866
1867 fn clear(&mut self) {
1868 self.mask.clear();
1869 self.id_list.clear();
1870 self.scan_all = ::std::option::Option::None;
1871 self.race = ::std::option::Option::None;
1872 self.civ_id = ::std::option::Option::None;
1873 self.dead = ::std::option::Option::None;
1874 self.alive = ::std::option::Option::None;
1875 self.sane = ::std::option::Option::None;
1876 self.special_fields.clear();
1877 }
1878
1879 fn default_instance() -> &'static ListUnitsIn {
1880 static instance: ListUnitsIn = ListUnitsIn {
1881 mask: ::protobuf::MessageField::none(),
1882 id_list: ::std::vec::Vec::new(),
1883 scan_all: ::std::option::Option::None,
1884 race: ::std::option::Option::None,
1885 civ_id: ::std::option::Option::None,
1886 dead: ::std::option::Option::None,
1887 alive: ::std::option::Option::None,
1888 sane: ::std::option::Option::None,
1889 special_fields: ::protobuf::SpecialFields::new(),
1890 };
1891 &instance
1892 }
1893}
1894
1895impl ::protobuf::MessageFull for ListUnitsIn {
1896 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1897 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1898 descriptor.get(|| file_descriptor().message_by_package_relative_name("ListUnitsIn").unwrap()).clone()
1899 }
1900}
1901
1902impl ::std::fmt::Display for ListUnitsIn {
1903 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1904 ::protobuf::text_format::fmt(self, f)
1905 }
1906}
1907
1908impl ::protobuf::reflect::ProtobufValue for ListUnitsIn {
1909 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1910}
1911
1912#[derive(PartialEq,Clone,Default,Debug)]
1914pub struct ListUnitsOut {
1915 pub value: ::std::vec::Vec<super::Basic::BasicUnitInfo>,
1918 pub special_fields: ::protobuf::SpecialFields,
1921}
1922
1923impl<'a> ::std::default::Default for &'a ListUnitsOut {
1924 fn default() -> &'a ListUnitsOut {
1925 <ListUnitsOut as ::protobuf::Message>::default_instance()
1926 }
1927}
1928
1929impl ListUnitsOut {
1930 pub fn new() -> ListUnitsOut {
1931 ::std::default::Default::default()
1932 }
1933
1934 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1935 let mut fields = ::std::vec::Vec::with_capacity(1);
1936 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1937 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
1938 "value",
1939 |m: &ListUnitsOut| { &m.value },
1940 |m: &mut ListUnitsOut| { &mut m.value },
1941 ));
1942 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ListUnitsOut>(
1943 "ListUnitsOut",
1944 fields,
1945 oneofs,
1946 )
1947 }
1948}
1949
1950impl ::protobuf::Message for ListUnitsOut {
1951 const NAME: &'static str = "ListUnitsOut";
1952
1953 fn is_initialized(&self) -> bool {
1954 for v in &self.value {
1955 if !v.is_initialized() {
1956 return false;
1957 }
1958 };
1959 true
1960 }
1961
1962 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1963 while let Some(tag) = is.read_raw_tag_or_eof()? {
1964 match tag {
1965 10 => {
1966 self.value.push(is.read_message()?);
1967 },
1968 tag => {
1969 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1970 },
1971 };
1972 }
1973 ::std::result::Result::Ok(())
1974 }
1975
1976 #[allow(unused_variables)]
1978 fn compute_size(&self) -> u64 {
1979 let mut my_size = 0;
1980 for value in &self.value {
1981 let len = value.compute_size();
1982 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
1983 };
1984 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1985 self.special_fields.cached_size().set(my_size as u32);
1986 my_size
1987 }
1988
1989 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1990 for v in &self.value {
1991 ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
1992 };
1993 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1994 ::std::result::Result::Ok(())
1995 }
1996
1997 fn special_fields(&self) -> &::protobuf::SpecialFields {
1998 &self.special_fields
1999 }
2000
2001 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2002 &mut self.special_fields
2003 }
2004
2005 fn new() -> ListUnitsOut {
2006 ListUnitsOut::new()
2007 }
2008
2009 fn clear(&mut self) {
2010 self.value.clear();
2011 self.special_fields.clear();
2012 }
2013
2014 fn default_instance() -> &'static ListUnitsOut {
2015 static instance: ListUnitsOut = ListUnitsOut {
2016 value: ::std::vec::Vec::new(),
2017 special_fields: ::protobuf::SpecialFields::new(),
2018 };
2019 &instance
2020 }
2021}
2022
2023impl ::protobuf::MessageFull for ListUnitsOut {
2024 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2025 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2026 descriptor.get(|| file_descriptor().message_by_package_relative_name("ListUnitsOut").unwrap()).clone()
2027 }
2028}
2029
2030impl ::std::fmt::Display for ListUnitsOut {
2031 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2032 ::protobuf::text_format::fmt(self, f)
2033 }
2034}
2035
2036impl ::protobuf::reflect::ProtobufValue for ListUnitsOut {
2037 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2038}
2039
2040#[derive(PartialEq,Clone,Default,Debug)]
2042pub struct ListSquadsIn {
2043 pub special_fields: ::protobuf::SpecialFields,
2046}
2047
2048impl<'a> ::std::default::Default for &'a ListSquadsIn {
2049 fn default() -> &'a ListSquadsIn {
2050 <ListSquadsIn as ::protobuf::Message>::default_instance()
2051 }
2052}
2053
2054impl ListSquadsIn {
2055 pub fn new() -> ListSquadsIn {
2056 ::std::default::Default::default()
2057 }
2058
2059 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
2060 let mut fields = ::std::vec::Vec::with_capacity(0);
2061 let mut oneofs = ::std::vec::Vec::with_capacity(0);
2062 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ListSquadsIn>(
2063 "ListSquadsIn",
2064 fields,
2065 oneofs,
2066 )
2067 }
2068}
2069
2070impl ::protobuf::Message for ListSquadsIn {
2071 const NAME: &'static str = "ListSquadsIn";
2072
2073 fn is_initialized(&self) -> bool {
2074 true
2075 }
2076
2077 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
2078 while let Some(tag) = is.read_raw_tag_or_eof()? {
2079 match tag {
2080 tag => {
2081 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2082 },
2083 };
2084 }
2085 ::std::result::Result::Ok(())
2086 }
2087
2088 #[allow(unused_variables)]
2090 fn compute_size(&self) -> u64 {
2091 let mut my_size = 0;
2092 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2093 self.special_fields.cached_size().set(my_size as u32);
2094 my_size
2095 }
2096
2097 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
2098 os.write_unknown_fields(self.special_fields.unknown_fields())?;
2099 ::std::result::Result::Ok(())
2100 }
2101
2102 fn special_fields(&self) -> &::protobuf::SpecialFields {
2103 &self.special_fields
2104 }
2105
2106 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2107 &mut self.special_fields
2108 }
2109
2110 fn new() -> ListSquadsIn {
2111 ListSquadsIn::new()
2112 }
2113
2114 fn clear(&mut self) {
2115 self.special_fields.clear();
2116 }
2117
2118 fn default_instance() -> &'static ListSquadsIn {
2119 static instance: ListSquadsIn = ListSquadsIn {
2120 special_fields: ::protobuf::SpecialFields::new(),
2121 };
2122 &instance
2123 }
2124}
2125
2126impl ::protobuf::MessageFull for ListSquadsIn {
2127 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2128 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2129 descriptor.get(|| file_descriptor().message_by_package_relative_name("ListSquadsIn").unwrap()).clone()
2130 }
2131}
2132
2133impl ::std::fmt::Display for ListSquadsIn {
2134 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2135 ::protobuf::text_format::fmt(self, f)
2136 }
2137}
2138
2139impl ::protobuf::reflect::ProtobufValue for ListSquadsIn {
2140 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2141}
2142
2143#[derive(PartialEq,Clone,Default,Debug)]
2145pub struct ListSquadsOut {
2146 pub value: ::std::vec::Vec<super::Basic::BasicSquadInfo>,
2149 pub special_fields: ::protobuf::SpecialFields,
2152}
2153
2154impl<'a> ::std::default::Default for &'a ListSquadsOut {
2155 fn default() -> &'a ListSquadsOut {
2156 <ListSquadsOut as ::protobuf::Message>::default_instance()
2157 }
2158}
2159
2160impl ListSquadsOut {
2161 pub fn new() -> ListSquadsOut {
2162 ::std::default::Default::default()
2163 }
2164
2165 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
2166 let mut fields = ::std::vec::Vec::with_capacity(1);
2167 let mut oneofs = ::std::vec::Vec::with_capacity(0);
2168 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
2169 "value",
2170 |m: &ListSquadsOut| { &m.value },
2171 |m: &mut ListSquadsOut| { &mut m.value },
2172 ));
2173 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ListSquadsOut>(
2174 "ListSquadsOut",
2175 fields,
2176 oneofs,
2177 )
2178 }
2179}
2180
2181impl ::protobuf::Message for ListSquadsOut {
2182 const NAME: &'static str = "ListSquadsOut";
2183
2184 fn is_initialized(&self) -> bool {
2185 for v in &self.value {
2186 if !v.is_initialized() {
2187 return false;
2188 }
2189 };
2190 true
2191 }
2192
2193 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
2194 while let Some(tag) = is.read_raw_tag_or_eof()? {
2195 match tag {
2196 10 => {
2197 self.value.push(is.read_message()?);
2198 },
2199 tag => {
2200 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2201 },
2202 };
2203 }
2204 ::std::result::Result::Ok(())
2205 }
2206
2207 #[allow(unused_variables)]
2209 fn compute_size(&self) -> u64 {
2210 let mut my_size = 0;
2211 for value in &self.value {
2212 let len = value.compute_size();
2213 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
2214 };
2215 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2216 self.special_fields.cached_size().set(my_size as u32);
2217 my_size
2218 }
2219
2220 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
2221 for v in &self.value {
2222 ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
2223 };
2224 os.write_unknown_fields(self.special_fields.unknown_fields())?;
2225 ::std::result::Result::Ok(())
2226 }
2227
2228 fn special_fields(&self) -> &::protobuf::SpecialFields {
2229 &self.special_fields
2230 }
2231
2232 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2233 &mut self.special_fields
2234 }
2235
2236 fn new() -> ListSquadsOut {
2237 ListSquadsOut::new()
2238 }
2239
2240 fn clear(&mut self) {
2241 self.value.clear();
2242 self.special_fields.clear();
2243 }
2244
2245 fn default_instance() -> &'static ListSquadsOut {
2246 static instance: ListSquadsOut = ListSquadsOut {
2247 value: ::std::vec::Vec::new(),
2248 special_fields: ::protobuf::SpecialFields::new(),
2249 };
2250 &instance
2251 }
2252}
2253
2254impl ::protobuf::MessageFull for ListSquadsOut {
2255 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2256 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2257 descriptor.get(|| file_descriptor().message_by_package_relative_name("ListSquadsOut").unwrap()).clone()
2258 }
2259}
2260
2261impl ::std::fmt::Display for ListSquadsOut {
2262 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2263 ::protobuf::text_format::fmt(self, f)
2264 }
2265}
2266
2267impl ::protobuf::reflect::ProtobufValue for ListSquadsOut {
2268 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2269}
2270
2271#[derive(PartialEq,Clone,Default,Debug)]
2273pub struct SetUnitLaborsIn {
2274 pub change: ::std::vec::Vec<super::Basic::UnitLaborState>,
2277 pub special_fields: ::protobuf::SpecialFields,
2280}
2281
2282impl<'a> ::std::default::Default for &'a SetUnitLaborsIn {
2283 fn default() -> &'a SetUnitLaborsIn {
2284 <SetUnitLaborsIn as ::protobuf::Message>::default_instance()
2285 }
2286}
2287
2288impl SetUnitLaborsIn {
2289 pub fn new() -> SetUnitLaborsIn {
2290 ::std::default::Default::default()
2291 }
2292
2293 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
2294 let mut fields = ::std::vec::Vec::with_capacity(1);
2295 let mut oneofs = ::std::vec::Vec::with_capacity(0);
2296 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
2297 "change",
2298 |m: &SetUnitLaborsIn| { &m.change },
2299 |m: &mut SetUnitLaborsIn| { &mut m.change },
2300 ));
2301 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetUnitLaborsIn>(
2302 "SetUnitLaborsIn",
2303 fields,
2304 oneofs,
2305 )
2306 }
2307}
2308
2309impl ::protobuf::Message for SetUnitLaborsIn {
2310 const NAME: &'static str = "SetUnitLaborsIn";
2311
2312 fn is_initialized(&self) -> bool {
2313 for v in &self.change {
2314 if !v.is_initialized() {
2315 return false;
2316 }
2317 };
2318 true
2319 }
2320
2321 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
2322 while let Some(tag) = is.read_raw_tag_or_eof()? {
2323 match tag {
2324 10 => {
2325 self.change.push(is.read_message()?);
2326 },
2327 tag => {
2328 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2329 },
2330 };
2331 }
2332 ::std::result::Result::Ok(())
2333 }
2334
2335 #[allow(unused_variables)]
2337 fn compute_size(&self) -> u64 {
2338 let mut my_size = 0;
2339 for value in &self.change {
2340 let len = value.compute_size();
2341 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
2342 };
2343 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2344 self.special_fields.cached_size().set(my_size as u32);
2345 my_size
2346 }
2347
2348 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
2349 for v in &self.change {
2350 ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
2351 };
2352 os.write_unknown_fields(self.special_fields.unknown_fields())?;
2353 ::std::result::Result::Ok(())
2354 }
2355
2356 fn special_fields(&self) -> &::protobuf::SpecialFields {
2357 &self.special_fields
2358 }
2359
2360 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2361 &mut self.special_fields
2362 }
2363
2364 fn new() -> SetUnitLaborsIn {
2365 SetUnitLaborsIn::new()
2366 }
2367
2368 fn clear(&mut self) {
2369 self.change.clear();
2370 self.special_fields.clear();
2371 }
2372
2373 fn default_instance() -> &'static SetUnitLaborsIn {
2374 static instance: SetUnitLaborsIn = SetUnitLaborsIn {
2375 change: ::std::vec::Vec::new(),
2376 special_fields: ::protobuf::SpecialFields::new(),
2377 };
2378 &instance
2379 }
2380}
2381
2382impl ::protobuf::MessageFull for SetUnitLaborsIn {
2383 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2384 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2385 descriptor.get(|| file_descriptor().message_by_package_relative_name("SetUnitLaborsIn").unwrap()).clone()
2386 }
2387}
2388
2389impl ::std::fmt::Display for SetUnitLaborsIn {
2390 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2391 ::protobuf::text_format::fmt(self, f)
2392 }
2393}
2394
2395impl ::protobuf::reflect::ProtobufValue for SetUnitLaborsIn {
2396 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2397}
2398
2399static file_descriptor_proto_data: &'static [u8] = b"\
2400 \n\x0eBasicApi.proto\x12\x07dfproto\x1a\x0bBasic.proto\"\xb9\x03\n\x0fGe\
2401 tWorldInfoOut\x121\n\x04mode\x18\x01\x20\x02(\x0e2\x1d.dfproto.GetWorldI\
2402 nfoOut.ModeR\x04mode\x12\x19\n\x08save_dir\x18\x02\x20\x02(\tR\x07saveDi\
2403 r\x120\n\nworld_name\x18\x03\x20\x01(\x0b2\x11.dfproto.NameInfoR\tworldN\
2404 ame\x12\x15\n\x06civ_id\x18\x04\x20\x01(\x05R\x05civId\x12\x17\n\x07site\
2405 _id\x18\x05\x20\x01(\x05R\x06siteId\x12\x19\n\x08group_id\x18\x06\x20\
2406 \x01(\x05R\x07groupId\x12\x17\n\x07race_id\x18\x07\x20\x01(\x05R\x06race\
2407 Id\x12$\n\x0eplayer_unit_id\x18\x08\x20\x01(\x05R\x0cplayerUnitId\x12*\n\
2408 \x11player_histfig_id\x18\t\x20\x01(\x05R\x0fplayerHistfigId\x122\n\x15c\
2409 ompanion_histfig_ids\x18\n\x20\x03(\x05R\x13companionHistfigIds\"<\n\x04\
2410 Mode\x12\x0e\n\nMODE_DWARF\x10\x01\x12\x12\n\x0eMODE_ADVENTURE\x10\x02\
2411 \x12\x10\n\x0cMODE_LEGENDS\x10\x03\"\x9a\x05\n\x0cListEnumsOut\x12<\n\
2412 \x0ematerial_flags\x18\x01\x20\x03(\x0b2\x15.dfproto.EnumItemNameR\rmate\
2413 rialFlags\x12>\n\x0finorganic_flags\x18\x02\x20\x03(\x0b2\x15.dfproto.En\
2414 umItemNameR\x0einorganicFlags\x126\n\x0bunit_flags1\x18\x03\x20\x03(\x0b\
2415 2\x15.dfproto.EnumItemNameR\nunitFlags1\x126\n\x0bunit_flags2\x18\x04\
2416 \x20\x03(\x0b2\x15.dfproto.EnumItemNameR\nunitFlags2\x126\n\x0bunit_flag\
2417 s3\x18\x05\x20\x03(\x0b2\x15.dfproto.EnumItemNameR\nunitFlags3\x124\n\nu\
2418 nit_labor\x18\x06\x20\x03(\x0b2\x15.dfproto.EnumItemNameR\tunitLabor\x12\
2419 2\n\tjob_skill\x18\x07\x20\x03(\x0b2\x15.dfproto.EnumItemNameR\x08jobSki\
2420 ll\x12@\n\x11cie_add_tag_mask1\x18\x08\x20\x03(\x0b2\x15.dfproto.EnumIte\
2421 mNameR\x0ecieAddTagMask1\x12@\n\x11cie_add_tag_mask2\x18\t\x20\x03(\x0b2\
2422 \x15.dfproto.EnumItemNameR\x0ecieAddTagMask2\x12?\n\x10death_info_flags\
2423 \x18\n\x20\x03(\x0b2\x15.dfproto.EnumItemNameR\x0edeathInfoFlags\x125\n\
2424 \nprofession\x18\x0b\x20\x03(\x0b2\x15.dfproto.EnumItemNameR\nprofession\
2425 \"\xa6\x01\n\x10ListJobSkillsOut\x12+\n\x05skill\x18\x01\x20\x03(\x0b2\
2426 \x15.dfproto.JobSkillAttrR\x05skill\x127\n\nprofession\x18\x02\x20\x03(\
2427 \x0b2\x17.dfproto.ProfessionAttrR\nprofession\x12,\n\x05labor\x18\x03\
2428 \x20\x03(\x0b2\x16.dfproto.UnitLaborAttrR\x05labor\"\xe6\x01\n\x0fListMa\
2429 terialsIn\x122\n\x04mask\x18\x01\x20\x01(\x0b2\x1e.dfproto.BasicMaterial\
2430 InfoMaskR\x04mask\x121\n\x07id_list\x18\x02\x20\x03(\x0b2\x18.dfproto.Ba\
2431 sicMaterialIdR\x06idList\x12\x18\n\x07builtin\x18\x03\x20\x01(\x08R\x07b\
2432 uiltin\x12\x1c\n\tinorganic\x18\x04\x20\x01(\x08R\tinorganic\x12\x1c\n\t\
2433 creatures\x18\x05\x20\x01(\x08R\tcreatures\x12\x16\n\x06plants\x18\x06\
2434 \x20\x01(\x08R\x06plants\"D\n\x10ListMaterialsOut\x120\n\x05value\x18\
2435 \x01\x20\x03(\x0b2\x1a.dfproto.BasicMaterialInfoR\x05value\"\xda\x01\n\
2436 \x0bListUnitsIn\x12.\n\x04mask\x18\x01\x20\x01(\x0b2\x1a.dfproto.BasicUn\
2437 itInfoMaskR\x04mask\x12\x17\n\x07id_list\x18\x02\x20\x03(\x05R\x06idList\
2438 \x12\x19\n\x08scan_all\x18\x05\x20\x01(\x08R\x07scanAll\x12\x12\n\x04rac\
2439 e\x18\x03\x20\x01(\x05R\x04race\x12\x15\n\x06civ_id\x18\x04\x20\x01(\x05\
2440 R\x05civId\x12\x12\n\x04dead\x18\x06\x20\x01(\x08R\x04dead\x12\x14\n\x05\
2441 alive\x18\x07\x20\x01(\x08R\x05alive\x12\x12\n\x04sane\x18\x08\x20\x01(\
2442 \x08R\x04sane\"<\n\x0cListUnitsOut\x12,\n\x05value\x18\x01\x20\x03(\x0b2\
2443 \x16.dfproto.BasicUnitInfoR\x05value\"\x0e\n\x0cListSquadsIn\">\n\rListS\
2444 quadsOut\x12-\n\x05value\x18\x01\x20\x03(\x0b2\x17.dfproto.BasicSquadInf\
2445 oR\x05value\"B\n\x0fSetUnitLaborsIn\x12/\n\x06change\x18\x01\x20\x03(\
2446 \x0b2\x17.dfproto.UnitLaborStateR\x06changeB\x02H\x03b\x06proto2\
2447";
2448
2449fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
2451 static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
2452 file_descriptor_proto_lazy.get(|| {
2453 ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
2454 })
2455}
2456
2457pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
2459 static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
2460 static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
2461 file_descriptor.get(|| {
2462 let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
2463 let mut deps = ::std::vec::Vec::with_capacity(1);
2464 deps.push(super::Basic::file_descriptor().clone());
2465 let mut messages = ::std::vec::Vec::with_capacity(10);
2466 messages.push(GetWorldInfoOut::generated_message_descriptor_data());
2467 messages.push(ListEnumsOut::generated_message_descriptor_data());
2468 messages.push(ListJobSkillsOut::generated_message_descriptor_data());
2469 messages.push(ListMaterialsIn::generated_message_descriptor_data());
2470 messages.push(ListMaterialsOut::generated_message_descriptor_data());
2471 messages.push(ListUnitsIn::generated_message_descriptor_data());
2472 messages.push(ListUnitsOut::generated_message_descriptor_data());
2473 messages.push(ListSquadsIn::generated_message_descriptor_data());
2474 messages.push(ListSquadsOut::generated_message_descriptor_data());
2475 messages.push(SetUnitLaborsIn::generated_message_descriptor_data());
2476 let mut enums = ::std::vec::Vec::with_capacity(1);
2477 enums.push(get_world_info_out::Mode::generated_enum_descriptor_data());
2478 ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
2479 file_descriptor_proto(),
2480 deps,
2481 messages,
2482 enums,
2483 )
2484 });
2485 ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
2486 })
2487}