dfhack_proto/generated/messages/
Basic.rs

1// This file is generated by rust-protobuf 3.4.0. Do not edit
2// .proto file is parsed by pure
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 `Basic.proto`
23
24/// Generated files are compatible only with the same version
25/// of protobuf runtime.
26const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_4_0;
27
28// @@protoc_insertion_point(message:dfproto.EnumItemName)
29#[derive(PartialEq,Clone,Default,Debug)]
30pub struct EnumItemName {
31    // message fields
32    // @@protoc_insertion_point(field:dfproto.EnumItemName.value)
33    pub value: ::std::option::Option<i32>,
34    // @@protoc_insertion_point(field:dfproto.EnumItemName.name)
35    pub name: ::std::option::Option<::std::string::String>,
36    // @@protoc_insertion_point(field:dfproto.EnumItemName.bit_size)
37    pub bit_size: ::std::option::Option<i32>,
38    // special fields
39    // @@protoc_insertion_point(special_field:dfproto.EnumItemName.special_fields)
40    pub special_fields: ::protobuf::SpecialFields,
41}
42
43impl<'a> ::std::default::Default for &'a EnumItemName {
44    fn default() -> &'a EnumItemName {
45        <EnumItemName as ::protobuf::Message>::default_instance()
46    }
47}
48
49impl EnumItemName {
50    pub fn new() -> EnumItemName {
51        ::std::default::Default::default()
52    }
53
54    // required int32 value = 1;
55
56    pub fn value(&self) -> i32 {
57        self.value.unwrap_or(0)
58    }
59
60    pub fn clear_value(&mut self) {
61        self.value = ::std::option::Option::None;
62    }
63
64    pub fn has_value(&self) -> bool {
65        self.value.is_some()
66    }
67
68    // Param is passed by value, moved
69    pub fn set_value(&mut self, v: i32) {
70        self.value = ::std::option::Option::Some(v);
71    }
72
73    // optional string name = 2;
74
75    pub fn name(&self) -> &str {
76        match self.name.as_ref() {
77            Some(v) => v,
78            None => "",
79        }
80    }
81
82    pub fn clear_name(&mut self) {
83        self.name = ::std::option::Option::None;
84    }
85
86    pub fn has_name(&self) -> bool {
87        self.name.is_some()
88    }
89
90    // Param is passed by value, moved
91    pub fn set_name(&mut self, v: ::std::string::String) {
92        self.name = ::std::option::Option::Some(v);
93    }
94
95    // Mutable pointer to the field.
96    // If field is not initialized, it is initialized with default value first.
97    pub fn mut_name(&mut self) -> &mut ::std::string::String {
98        if self.name.is_none() {
99            self.name = ::std::option::Option::Some(::std::string::String::new());
100        }
101        self.name.as_mut().unwrap()
102    }
103
104    // Take field
105    pub fn take_name(&mut self) -> ::std::string::String {
106        self.name.take().unwrap_or_else(|| ::std::string::String::new())
107    }
108
109    // optional int32 bit_size = 3;
110
111    pub fn bit_size(&self) -> i32 {
112        self.bit_size.unwrap_or(1i32)
113    }
114
115    pub fn clear_bit_size(&mut self) {
116        self.bit_size = ::std::option::Option::None;
117    }
118
119    pub fn has_bit_size(&self) -> bool {
120        self.bit_size.is_some()
121    }
122
123    // Param is passed by value, moved
124    pub fn set_bit_size(&mut self, v: i32) {
125        self.bit_size = ::std::option::Option::Some(v);
126    }
127
128    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
129        let mut fields = ::std::vec::Vec::with_capacity(3);
130        let mut oneofs = ::std::vec::Vec::with_capacity(0);
131        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
132            "value",
133            |m: &EnumItemName| { &m.value },
134            |m: &mut EnumItemName| { &mut m.value },
135        ));
136        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
137            "name",
138            |m: &EnumItemName| { &m.name },
139            |m: &mut EnumItemName| { &mut m.name },
140        ));
141        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
142            "bit_size",
143            |m: &EnumItemName| { &m.bit_size },
144            |m: &mut EnumItemName| { &mut m.bit_size },
145        ));
146        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<EnumItemName>(
147            "EnumItemName",
148            fields,
149            oneofs,
150        )
151    }
152}
153
154impl ::protobuf::Message for EnumItemName {
155    const NAME: &'static str = "EnumItemName";
156
157    fn is_initialized(&self) -> bool {
158        if self.value.is_none() {
159            return false;
160        }
161        true
162    }
163
164    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
165        while let Some(tag) = is.read_raw_tag_or_eof()? {
166            match tag {
167                8 => {
168                    self.value = ::std::option::Option::Some(is.read_int32()?);
169                },
170                18 => {
171                    self.name = ::std::option::Option::Some(is.read_string()?);
172                },
173                24 => {
174                    self.bit_size = ::std::option::Option::Some(is.read_int32()?);
175                },
176                tag => {
177                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
178                },
179            };
180        }
181        ::std::result::Result::Ok(())
182    }
183
184    // Compute sizes of nested messages
185    #[allow(unused_variables)]
186    fn compute_size(&self) -> u64 {
187        let mut my_size = 0;
188        if let Some(v) = self.value {
189            my_size += ::protobuf::rt::int32_size(1, v);
190        }
191        if let Some(v) = self.name.as_ref() {
192            my_size += ::protobuf::rt::string_size(2, &v);
193        }
194        if let Some(v) = self.bit_size {
195            my_size += ::protobuf::rt::int32_size(3, v);
196        }
197        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
198        self.special_fields.cached_size().set(my_size as u32);
199        my_size
200    }
201
202    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
203        if let Some(v) = self.value {
204            os.write_int32(1, v)?;
205        }
206        if let Some(v) = self.name.as_ref() {
207            os.write_string(2, v)?;
208        }
209        if let Some(v) = self.bit_size {
210            os.write_int32(3, v)?;
211        }
212        os.write_unknown_fields(self.special_fields.unknown_fields())?;
213        ::std::result::Result::Ok(())
214    }
215
216    fn special_fields(&self) -> &::protobuf::SpecialFields {
217        &self.special_fields
218    }
219
220    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
221        &mut self.special_fields
222    }
223
224    fn new() -> EnumItemName {
225        EnumItemName::new()
226    }
227
228    fn clear(&mut self) {
229        self.value = ::std::option::Option::None;
230        self.name = ::std::option::Option::None;
231        self.bit_size = ::std::option::Option::None;
232        self.special_fields.clear();
233    }
234
235    fn default_instance() -> &'static EnumItemName {
236        static instance: EnumItemName = EnumItemName {
237            value: ::std::option::Option::None,
238            name: ::std::option::Option::None,
239            bit_size: ::std::option::Option::None,
240            special_fields: ::protobuf::SpecialFields::new(),
241        };
242        &instance
243    }
244}
245
246impl ::protobuf::MessageFull for EnumItemName {
247    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
248        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
249        descriptor.get(|| file_descriptor().message_by_package_relative_name("EnumItemName").unwrap()).clone()
250    }
251}
252
253impl ::std::fmt::Display for EnumItemName {
254    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
255        ::protobuf::text_format::fmt(self, f)
256    }
257}
258
259impl ::protobuf::reflect::ProtobufValue for EnumItemName {
260    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
261}
262
263// @@protoc_insertion_point(message:dfproto.BasicMaterialId)
264#[derive(PartialEq,Clone,Default,Debug)]
265pub struct BasicMaterialId {
266    // message fields
267    // @@protoc_insertion_point(field:dfproto.BasicMaterialId.type)
268    pub type_: ::std::option::Option<i32>,
269    // @@protoc_insertion_point(field:dfproto.BasicMaterialId.index)
270    pub index: ::std::option::Option<i32>,
271    // special fields
272    // @@protoc_insertion_point(special_field:dfproto.BasicMaterialId.special_fields)
273    pub special_fields: ::protobuf::SpecialFields,
274}
275
276impl<'a> ::std::default::Default for &'a BasicMaterialId {
277    fn default() -> &'a BasicMaterialId {
278        <BasicMaterialId as ::protobuf::Message>::default_instance()
279    }
280}
281
282impl BasicMaterialId {
283    pub fn new() -> BasicMaterialId {
284        ::std::default::Default::default()
285    }
286
287    // required int32 type = 1;
288
289    pub fn type_(&self) -> i32 {
290        self.type_.unwrap_or(0)
291    }
292
293    pub fn clear_type_(&mut self) {
294        self.type_ = ::std::option::Option::None;
295    }
296
297    pub fn has_type(&self) -> bool {
298        self.type_.is_some()
299    }
300
301    // Param is passed by value, moved
302    pub fn set_type(&mut self, v: i32) {
303        self.type_ = ::std::option::Option::Some(v);
304    }
305
306    // required sint32 index = 2;
307
308    pub fn index(&self) -> i32 {
309        self.index.unwrap_or(0)
310    }
311
312    pub fn clear_index(&mut self) {
313        self.index = ::std::option::Option::None;
314    }
315
316    pub fn has_index(&self) -> bool {
317        self.index.is_some()
318    }
319
320    // Param is passed by value, moved
321    pub fn set_index(&mut self, v: i32) {
322        self.index = ::std::option::Option::Some(v);
323    }
324
325    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
326        let mut fields = ::std::vec::Vec::with_capacity(2);
327        let mut oneofs = ::std::vec::Vec::with_capacity(0);
328        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
329            "type",
330            |m: &BasicMaterialId| { &m.type_ },
331            |m: &mut BasicMaterialId| { &mut m.type_ },
332        ));
333        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
334            "index",
335            |m: &BasicMaterialId| { &m.index },
336            |m: &mut BasicMaterialId| { &mut m.index },
337        ));
338        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<BasicMaterialId>(
339            "BasicMaterialId",
340            fields,
341            oneofs,
342        )
343    }
344}
345
346impl ::protobuf::Message for BasicMaterialId {
347    const NAME: &'static str = "BasicMaterialId";
348
349    fn is_initialized(&self) -> bool {
350        if self.type_.is_none() {
351            return false;
352        }
353        if self.index.is_none() {
354            return false;
355        }
356        true
357    }
358
359    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
360        while let Some(tag) = is.read_raw_tag_or_eof()? {
361            match tag {
362                8 => {
363                    self.type_ = ::std::option::Option::Some(is.read_int32()?);
364                },
365                16 => {
366                    self.index = ::std::option::Option::Some(is.read_sint32()?);
367                },
368                tag => {
369                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
370                },
371            };
372        }
373        ::std::result::Result::Ok(())
374    }
375
376    // Compute sizes of nested messages
377    #[allow(unused_variables)]
378    fn compute_size(&self) -> u64 {
379        let mut my_size = 0;
380        if let Some(v) = self.type_ {
381            my_size += ::protobuf::rt::int32_size(1, v);
382        }
383        if let Some(v) = self.index {
384            my_size += ::protobuf::rt::sint32_size(2, v);
385        }
386        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
387        self.special_fields.cached_size().set(my_size as u32);
388        my_size
389    }
390
391    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
392        if let Some(v) = self.type_ {
393            os.write_int32(1, v)?;
394        }
395        if let Some(v) = self.index {
396            os.write_sint32(2, v)?;
397        }
398        os.write_unknown_fields(self.special_fields.unknown_fields())?;
399        ::std::result::Result::Ok(())
400    }
401
402    fn special_fields(&self) -> &::protobuf::SpecialFields {
403        &self.special_fields
404    }
405
406    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
407        &mut self.special_fields
408    }
409
410    fn new() -> BasicMaterialId {
411        BasicMaterialId::new()
412    }
413
414    fn clear(&mut self) {
415        self.type_ = ::std::option::Option::None;
416        self.index = ::std::option::Option::None;
417        self.special_fields.clear();
418    }
419
420    fn default_instance() -> &'static BasicMaterialId {
421        static instance: BasicMaterialId = BasicMaterialId {
422            type_: ::std::option::Option::None,
423            index: ::std::option::Option::None,
424            special_fields: ::protobuf::SpecialFields::new(),
425        };
426        &instance
427    }
428}
429
430impl ::protobuf::MessageFull for BasicMaterialId {
431    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
432        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
433        descriptor.get(|| file_descriptor().message_by_package_relative_name("BasicMaterialId").unwrap()).clone()
434    }
435}
436
437impl ::std::fmt::Display for BasicMaterialId {
438    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
439        ::protobuf::text_format::fmt(self, f)
440    }
441}
442
443impl ::protobuf::reflect::ProtobufValue for BasicMaterialId {
444    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
445}
446
447// @@protoc_insertion_point(message:dfproto.BasicMaterialInfo)
448#[derive(PartialEq,Clone,Default,Debug)]
449pub struct BasicMaterialInfo {
450    // message fields
451    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.type)
452    pub type_: ::std::option::Option<i32>,
453    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.index)
454    pub index: ::std::option::Option<i32>,
455    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.token)
456    pub token: ::std::option::Option<::std::string::String>,
457    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.flags)
458    pub flags: ::std::vec::Vec<i32>,
459    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.subtype)
460    pub subtype: ::std::option::Option<i32>,
461    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.creature_id)
462    pub creature_id: ::std::option::Option<i32>,
463    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.plant_id)
464    pub plant_id: ::std::option::Option<i32>,
465    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.histfig_id)
466    pub histfig_id: ::std::option::Option<i32>,
467    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.name_prefix)
468    pub name_prefix: ::std::option::Option<::std::string::String>,
469    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.state_color)
470    pub state_color: ::std::vec::Vec<u32>,
471    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.state_name)
472    pub state_name: ::std::vec::Vec<::std::string::String>,
473    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.state_adj)
474    pub state_adj: ::std::vec::Vec<::std::string::String>,
475    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.reaction_class)
476    pub reaction_class: ::std::vec::Vec<::std::string::String>,
477    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.reaction_product)
478    pub reaction_product: ::std::vec::Vec<basic_material_info::Product>,
479    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.inorganic_flags)
480    pub inorganic_flags: ::std::vec::Vec<i32>,
481    // special fields
482    // @@protoc_insertion_point(special_field:dfproto.BasicMaterialInfo.special_fields)
483    pub special_fields: ::protobuf::SpecialFields,
484}
485
486impl<'a> ::std::default::Default for &'a BasicMaterialInfo {
487    fn default() -> &'a BasicMaterialInfo {
488        <BasicMaterialInfo as ::protobuf::Message>::default_instance()
489    }
490}
491
492impl BasicMaterialInfo {
493    pub fn new() -> BasicMaterialInfo {
494        ::std::default::Default::default()
495    }
496
497    // required int32 type = 1;
498
499    pub fn type_(&self) -> i32 {
500        self.type_.unwrap_or(0)
501    }
502
503    pub fn clear_type_(&mut self) {
504        self.type_ = ::std::option::Option::None;
505    }
506
507    pub fn has_type(&self) -> bool {
508        self.type_.is_some()
509    }
510
511    // Param is passed by value, moved
512    pub fn set_type(&mut self, v: i32) {
513        self.type_ = ::std::option::Option::Some(v);
514    }
515
516    // required sint32 index = 2;
517
518    pub fn index(&self) -> i32 {
519        self.index.unwrap_or(0)
520    }
521
522    pub fn clear_index(&mut self) {
523        self.index = ::std::option::Option::None;
524    }
525
526    pub fn has_index(&self) -> bool {
527        self.index.is_some()
528    }
529
530    // Param is passed by value, moved
531    pub fn set_index(&mut self, v: i32) {
532        self.index = ::std::option::Option::Some(v);
533    }
534
535    // required string token = 3;
536
537    pub fn token(&self) -> &str {
538        match self.token.as_ref() {
539            Some(v) => v,
540            None => "",
541        }
542    }
543
544    pub fn clear_token(&mut self) {
545        self.token = ::std::option::Option::None;
546    }
547
548    pub fn has_token(&self) -> bool {
549        self.token.is_some()
550    }
551
552    // Param is passed by value, moved
553    pub fn set_token(&mut self, v: ::std::string::String) {
554        self.token = ::std::option::Option::Some(v);
555    }
556
557    // Mutable pointer to the field.
558    // If field is not initialized, it is initialized with default value first.
559    pub fn mut_token(&mut self) -> &mut ::std::string::String {
560        if self.token.is_none() {
561            self.token = ::std::option::Option::Some(::std::string::String::new());
562        }
563        self.token.as_mut().unwrap()
564    }
565
566    // Take field
567    pub fn take_token(&mut self) -> ::std::string::String {
568        self.token.take().unwrap_or_else(|| ::std::string::String::new())
569    }
570
571    // optional int32 subtype = 5;
572
573    pub fn subtype(&self) -> i32 {
574        self.subtype.unwrap_or(-1i32)
575    }
576
577    pub fn clear_subtype(&mut self) {
578        self.subtype = ::std::option::Option::None;
579    }
580
581    pub fn has_subtype(&self) -> bool {
582        self.subtype.is_some()
583    }
584
585    // Param is passed by value, moved
586    pub fn set_subtype(&mut self, v: i32) {
587        self.subtype = ::std::option::Option::Some(v);
588    }
589
590    // optional int32 creature_id = 6;
591
592    pub fn creature_id(&self) -> i32 {
593        self.creature_id.unwrap_or(-1i32)
594    }
595
596    pub fn clear_creature_id(&mut self) {
597        self.creature_id = ::std::option::Option::None;
598    }
599
600    pub fn has_creature_id(&self) -> bool {
601        self.creature_id.is_some()
602    }
603
604    // Param is passed by value, moved
605    pub fn set_creature_id(&mut self, v: i32) {
606        self.creature_id = ::std::option::Option::Some(v);
607    }
608
609    // optional int32 plant_id = 7;
610
611    pub fn plant_id(&self) -> i32 {
612        self.plant_id.unwrap_or(-1i32)
613    }
614
615    pub fn clear_plant_id(&mut self) {
616        self.plant_id = ::std::option::Option::None;
617    }
618
619    pub fn has_plant_id(&self) -> bool {
620        self.plant_id.is_some()
621    }
622
623    // Param is passed by value, moved
624    pub fn set_plant_id(&mut self, v: i32) {
625        self.plant_id = ::std::option::Option::Some(v);
626    }
627
628    // optional int32 histfig_id = 8;
629
630    pub fn histfig_id(&self) -> i32 {
631        self.histfig_id.unwrap_or(-1i32)
632    }
633
634    pub fn clear_histfig_id(&mut self) {
635        self.histfig_id = ::std::option::Option::None;
636    }
637
638    pub fn has_histfig_id(&self) -> bool {
639        self.histfig_id.is_some()
640    }
641
642    // Param is passed by value, moved
643    pub fn set_histfig_id(&mut self, v: i32) {
644        self.histfig_id = ::std::option::Option::Some(v);
645    }
646
647    // optional string name_prefix = 9;
648
649    pub fn name_prefix(&self) -> &str {
650        match self.name_prefix.as_ref() {
651            Some(v) => v,
652            None => "",
653        }
654    }
655
656    pub fn clear_name_prefix(&mut self) {
657        self.name_prefix = ::std::option::Option::None;
658    }
659
660    pub fn has_name_prefix(&self) -> bool {
661        self.name_prefix.is_some()
662    }
663
664    // Param is passed by value, moved
665    pub fn set_name_prefix(&mut self, v: ::std::string::String) {
666        self.name_prefix = ::std::option::Option::Some(v);
667    }
668
669    // Mutable pointer to the field.
670    // If field is not initialized, it is initialized with default value first.
671    pub fn mut_name_prefix(&mut self) -> &mut ::std::string::String {
672        if self.name_prefix.is_none() {
673            self.name_prefix = ::std::option::Option::Some(::std::string::String::new());
674        }
675        self.name_prefix.as_mut().unwrap()
676    }
677
678    // Take field
679    pub fn take_name_prefix(&mut self) -> ::std::string::String {
680        self.name_prefix.take().unwrap_or_else(|| ::std::string::String::new())
681    }
682
683    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
684        let mut fields = ::std::vec::Vec::with_capacity(15);
685        let mut oneofs = ::std::vec::Vec::with_capacity(0);
686        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
687            "type",
688            |m: &BasicMaterialInfo| { &m.type_ },
689            |m: &mut BasicMaterialInfo| { &mut m.type_ },
690        ));
691        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
692            "index",
693            |m: &BasicMaterialInfo| { &m.index },
694            |m: &mut BasicMaterialInfo| { &mut m.index },
695        ));
696        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
697            "token",
698            |m: &BasicMaterialInfo| { &m.token },
699            |m: &mut BasicMaterialInfo| { &mut m.token },
700        ));
701        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
702            "flags",
703            |m: &BasicMaterialInfo| { &m.flags },
704            |m: &mut BasicMaterialInfo| { &mut m.flags },
705        ));
706        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
707            "subtype",
708            |m: &BasicMaterialInfo| { &m.subtype },
709            |m: &mut BasicMaterialInfo| { &mut m.subtype },
710        ));
711        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
712            "creature_id",
713            |m: &BasicMaterialInfo| { &m.creature_id },
714            |m: &mut BasicMaterialInfo| { &mut m.creature_id },
715        ));
716        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
717            "plant_id",
718            |m: &BasicMaterialInfo| { &m.plant_id },
719            |m: &mut BasicMaterialInfo| { &mut m.plant_id },
720        ));
721        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
722            "histfig_id",
723            |m: &BasicMaterialInfo| { &m.histfig_id },
724            |m: &mut BasicMaterialInfo| { &mut m.histfig_id },
725        ));
726        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
727            "name_prefix",
728            |m: &BasicMaterialInfo| { &m.name_prefix },
729            |m: &mut BasicMaterialInfo| { &mut m.name_prefix },
730        ));
731        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
732            "state_color",
733            |m: &BasicMaterialInfo| { &m.state_color },
734            |m: &mut BasicMaterialInfo| { &mut m.state_color },
735        ));
736        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
737            "state_name",
738            |m: &BasicMaterialInfo| { &m.state_name },
739            |m: &mut BasicMaterialInfo| { &mut m.state_name },
740        ));
741        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
742            "state_adj",
743            |m: &BasicMaterialInfo| { &m.state_adj },
744            |m: &mut BasicMaterialInfo| { &mut m.state_adj },
745        ));
746        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
747            "reaction_class",
748            |m: &BasicMaterialInfo| { &m.reaction_class },
749            |m: &mut BasicMaterialInfo| { &mut m.reaction_class },
750        ));
751        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
752            "reaction_product",
753            |m: &BasicMaterialInfo| { &m.reaction_product },
754            |m: &mut BasicMaterialInfo| { &mut m.reaction_product },
755        ));
756        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
757            "inorganic_flags",
758            |m: &BasicMaterialInfo| { &m.inorganic_flags },
759            |m: &mut BasicMaterialInfo| { &mut m.inorganic_flags },
760        ));
761        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<BasicMaterialInfo>(
762            "BasicMaterialInfo",
763            fields,
764            oneofs,
765        )
766    }
767}
768
769impl ::protobuf::Message for BasicMaterialInfo {
770    const NAME: &'static str = "BasicMaterialInfo";
771
772    fn is_initialized(&self) -> bool {
773        if self.type_.is_none() {
774            return false;
775        }
776        if self.index.is_none() {
777            return false;
778        }
779        if self.token.is_none() {
780            return false;
781        }
782        for v in &self.reaction_product {
783            if !v.is_initialized() {
784                return false;
785            }
786        };
787        true
788    }
789
790    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
791        while let Some(tag) = is.read_raw_tag_or_eof()? {
792            match tag {
793                8 => {
794                    self.type_ = ::std::option::Option::Some(is.read_int32()?);
795                },
796                16 => {
797                    self.index = ::std::option::Option::Some(is.read_sint32()?);
798                },
799                26 => {
800                    self.token = ::std::option::Option::Some(is.read_string()?);
801                },
802                34 => {
803                    is.read_repeated_packed_int32_into(&mut self.flags)?;
804                },
805                32 => {
806                    self.flags.push(is.read_int32()?);
807                },
808                40 => {
809                    self.subtype = ::std::option::Option::Some(is.read_int32()?);
810                },
811                48 => {
812                    self.creature_id = ::std::option::Option::Some(is.read_int32()?);
813                },
814                56 => {
815                    self.plant_id = ::std::option::Option::Some(is.read_int32()?);
816                },
817                64 => {
818                    self.histfig_id = ::std::option::Option::Some(is.read_int32()?);
819                },
820                74 => {
821                    self.name_prefix = ::std::option::Option::Some(is.read_string()?);
822                },
823                82 => {
824                    is.read_repeated_packed_fixed32_into(&mut self.state_color)?;
825                },
826                85 => {
827                    self.state_color.push(is.read_fixed32()?);
828                },
829                90 => {
830                    self.state_name.push(is.read_string()?);
831                },
832                98 => {
833                    self.state_adj.push(is.read_string()?);
834                },
835                106 => {
836                    self.reaction_class.push(is.read_string()?);
837                },
838                114 => {
839                    self.reaction_product.push(is.read_message()?);
840                },
841                122 => {
842                    is.read_repeated_packed_int32_into(&mut self.inorganic_flags)?;
843                },
844                120 => {
845                    self.inorganic_flags.push(is.read_int32()?);
846                },
847                tag => {
848                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
849                },
850            };
851        }
852        ::std::result::Result::Ok(())
853    }
854
855    // Compute sizes of nested messages
856    #[allow(unused_variables)]
857    fn compute_size(&self) -> u64 {
858        let mut my_size = 0;
859        if let Some(v) = self.type_ {
860            my_size += ::protobuf::rt::int32_size(1, v);
861        }
862        if let Some(v) = self.index {
863            my_size += ::protobuf::rt::sint32_size(2, v);
864        }
865        if let Some(v) = self.token.as_ref() {
866            my_size += ::protobuf::rt::string_size(3, &v);
867        }
868        for value in &self.flags {
869            my_size += ::protobuf::rt::int32_size(4, *value);
870        };
871        if let Some(v) = self.subtype {
872            my_size += ::protobuf::rt::int32_size(5, v);
873        }
874        if let Some(v) = self.creature_id {
875            my_size += ::protobuf::rt::int32_size(6, v);
876        }
877        if let Some(v) = self.plant_id {
878            my_size += ::protobuf::rt::int32_size(7, v);
879        }
880        if let Some(v) = self.histfig_id {
881            my_size += ::protobuf::rt::int32_size(8, v);
882        }
883        if let Some(v) = self.name_prefix.as_ref() {
884            my_size += ::protobuf::rt::string_size(9, &v);
885        }
886        my_size += 5 * self.state_color.len() as u64;
887        for value in &self.state_name {
888            my_size += ::protobuf::rt::string_size(11, &value);
889        };
890        for value in &self.state_adj {
891            my_size += ::protobuf::rt::string_size(12, &value);
892        };
893        for value in &self.reaction_class {
894            my_size += ::protobuf::rt::string_size(13, &value);
895        };
896        for value in &self.reaction_product {
897            let len = value.compute_size();
898            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
899        };
900        for value in &self.inorganic_flags {
901            my_size += ::protobuf::rt::int32_size(15, *value);
902        };
903        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
904        self.special_fields.cached_size().set(my_size as u32);
905        my_size
906    }
907
908    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
909        if let Some(v) = self.type_ {
910            os.write_int32(1, v)?;
911        }
912        if let Some(v) = self.index {
913            os.write_sint32(2, v)?;
914        }
915        if let Some(v) = self.token.as_ref() {
916            os.write_string(3, v)?;
917        }
918        for v in &self.flags {
919            os.write_int32(4, *v)?;
920        };
921        if let Some(v) = self.subtype {
922            os.write_int32(5, v)?;
923        }
924        if let Some(v) = self.creature_id {
925            os.write_int32(6, v)?;
926        }
927        if let Some(v) = self.plant_id {
928            os.write_int32(7, v)?;
929        }
930        if let Some(v) = self.histfig_id {
931            os.write_int32(8, v)?;
932        }
933        if let Some(v) = self.name_prefix.as_ref() {
934            os.write_string(9, v)?;
935        }
936        for v in &self.state_color {
937            os.write_fixed32(10, *v)?;
938        };
939        for v in &self.state_name {
940            os.write_string(11, &v)?;
941        };
942        for v in &self.state_adj {
943            os.write_string(12, &v)?;
944        };
945        for v in &self.reaction_class {
946            os.write_string(13, &v)?;
947        };
948        for v in &self.reaction_product {
949            ::protobuf::rt::write_message_field_with_cached_size(14, v, os)?;
950        };
951        for v in &self.inorganic_flags {
952            os.write_int32(15, *v)?;
953        };
954        os.write_unknown_fields(self.special_fields.unknown_fields())?;
955        ::std::result::Result::Ok(())
956    }
957
958    fn special_fields(&self) -> &::protobuf::SpecialFields {
959        &self.special_fields
960    }
961
962    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
963        &mut self.special_fields
964    }
965
966    fn new() -> BasicMaterialInfo {
967        BasicMaterialInfo::new()
968    }
969
970    fn clear(&mut self) {
971        self.type_ = ::std::option::Option::None;
972        self.index = ::std::option::Option::None;
973        self.token = ::std::option::Option::None;
974        self.flags.clear();
975        self.subtype = ::std::option::Option::None;
976        self.creature_id = ::std::option::Option::None;
977        self.plant_id = ::std::option::Option::None;
978        self.histfig_id = ::std::option::Option::None;
979        self.name_prefix = ::std::option::Option::None;
980        self.state_color.clear();
981        self.state_name.clear();
982        self.state_adj.clear();
983        self.reaction_class.clear();
984        self.reaction_product.clear();
985        self.inorganic_flags.clear();
986        self.special_fields.clear();
987    }
988
989    fn default_instance() -> &'static BasicMaterialInfo {
990        static instance: BasicMaterialInfo = BasicMaterialInfo {
991            type_: ::std::option::Option::None,
992            index: ::std::option::Option::None,
993            token: ::std::option::Option::None,
994            flags: ::std::vec::Vec::new(),
995            subtype: ::std::option::Option::None,
996            creature_id: ::std::option::Option::None,
997            plant_id: ::std::option::Option::None,
998            histfig_id: ::std::option::Option::None,
999            name_prefix: ::std::option::Option::None,
1000            state_color: ::std::vec::Vec::new(),
1001            state_name: ::std::vec::Vec::new(),
1002            state_adj: ::std::vec::Vec::new(),
1003            reaction_class: ::std::vec::Vec::new(),
1004            reaction_product: ::std::vec::Vec::new(),
1005            inorganic_flags: ::std::vec::Vec::new(),
1006            special_fields: ::protobuf::SpecialFields::new(),
1007        };
1008        &instance
1009    }
1010}
1011
1012impl ::protobuf::MessageFull for BasicMaterialInfo {
1013    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1014        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1015        descriptor.get(|| file_descriptor().message_by_package_relative_name("BasicMaterialInfo").unwrap()).clone()
1016    }
1017}
1018
1019impl ::std::fmt::Display for BasicMaterialInfo {
1020    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1021        ::protobuf::text_format::fmt(self, f)
1022    }
1023}
1024
1025impl ::protobuf::reflect::ProtobufValue for BasicMaterialInfo {
1026    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1027}
1028
1029/// Nested message and enums of message `BasicMaterialInfo`
1030pub mod basic_material_info {
1031    // @@protoc_insertion_point(message:dfproto.BasicMaterialInfo.Product)
1032    #[derive(PartialEq,Clone,Default,Debug)]
1033    pub struct Product {
1034        // message fields
1035        // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.Product.id)
1036        pub id: ::std::option::Option<::std::string::String>,
1037        // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.Product.type)
1038        pub type_: ::std::option::Option<i32>,
1039        // @@protoc_insertion_point(field:dfproto.BasicMaterialInfo.Product.index)
1040        pub index: ::std::option::Option<i32>,
1041        // special fields
1042        // @@protoc_insertion_point(special_field:dfproto.BasicMaterialInfo.Product.special_fields)
1043        pub special_fields: ::protobuf::SpecialFields,
1044    }
1045
1046    impl<'a> ::std::default::Default for &'a Product {
1047        fn default() -> &'a Product {
1048            <Product as ::protobuf::Message>::default_instance()
1049        }
1050    }
1051
1052    impl Product {
1053        pub fn new() -> Product {
1054            ::std::default::Default::default()
1055        }
1056
1057        // required string id = 1;
1058
1059        pub fn id(&self) -> &str {
1060            match self.id.as_ref() {
1061                Some(v) => v,
1062                None => "",
1063            }
1064        }
1065
1066        pub fn clear_id(&mut self) {
1067            self.id = ::std::option::Option::None;
1068        }
1069
1070        pub fn has_id(&self) -> bool {
1071            self.id.is_some()
1072        }
1073
1074        // Param is passed by value, moved
1075        pub fn set_id(&mut self, v: ::std::string::String) {
1076            self.id = ::std::option::Option::Some(v);
1077        }
1078
1079        // Mutable pointer to the field.
1080        // If field is not initialized, it is initialized with default value first.
1081        pub fn mut_id(&mut self) -> &mut ::std::string::String {
1082            if self.id.is_none() {
1083                self.id = ::std::option::Option::Some(::std::string::String::new());
1084            }
1085            self.id.as_mut().unwrap()
1086        }
1087
1088        // Take field
1089        pub fn take_id(&mut self) -> ::std::string::String {
1090            self.id.take().unwrap_or_else(|| ::std::string::String::new())
1091        }
1092
1093        // required int32 type = 2;
1094
1095        pub fn type_(&self) -> i32 {
1096            self.type_.unwrap_or(0)
1097        }
1098
1099        pub fn clear_type_(&mut self) {
1100            self.type_ = ::std::option::Option::None;
1101        }
1102
1103        pub fn has_type(&self) -> bool {
1104            self.type_.is_some()
1105        }
1106
1107        // Param is passed by value, moved
1108        pub fn set_type(&mut self, v: i32) {
1109            self.type_ = ::std::option::Option::Some(v);
1110        }
1111
1112        // required sint32 index = 3;
1113
1114        pub fn index(&self) -> i32 {
1115            self.index.unwrap_or(0)
1116        }
1117
1118        pub fn clear_index(&mut self) {
1119            self.index = ::std::option::Option::None;
1120        }
1121
1122        pub fn has_index(&self) -> bool {
1123            self.index.is_some()
1124        }
1125
1126        // Param is passed by value, moved
1127        pub fn set_index(&mut self, v: i32) {
1128            self.index = ::std::option::Option::Some(v);
1129        }
1130
1131        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1132            let mut fields = ::std::vec::Vec::with_capacity(3);
1133            let mut oneofs = ::std::vec::Vec::with_capacity(0);
1134            fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1135                "id",
1136                |m: &Product| { &m.id },
1137                |m: &mut Product| { &mut m.id },
1138            ));
1139            fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1140                "type",
1141                |m: &Product| { &m.type_ },
1142                |m: &mut Product| { &mut m.type_ },
1143            ));
1144            fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1145                "index",
1146                |m: &Product| { &m.index },
1147                |m: &mut Product| { &mut m.index },
1148            ));
1149            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Product>(
1150                "BasicMaterialInfo.Product",
1151                fields,
1152                oneofs,
1153            )
1154        }
1155    }
1156
1157    impl ::protobuf::Message for Product {
1158        const NAME: &'static str = "Product";
1159
1160        fn is_initialized(&self) -> bool {
1161            if self.id.is_none() {
1162                return false;
1163            }
1164            if self.type_.is_none() {
1165                return false;
1166            }
1167            if self.index.is_none() {
1168                return false;
1169            }
1170            true
1171        }
1172
1173        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1174            while let Some(tag) = is.read_raw_tag_or_eof()? {
1175                match tag {
1176                    10 => {
1177                        self.id = ::std::option::Option::Some(is.read_string()?);
1178                    },
1179                    16 => {
1180                        self.type_ = ::std::option::Option::Some(is.read_int32()?);
1181                    },
1182                    24 => {
1183                        self.index = ::std::option::Option::Some(is.read_sint32()?);
1184                    },
1185                    tag => {
1186                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1187                    },
1188                };
1189            }
1190            ::std::result::Result::Ok(())
1191        }
1192
1193        // Compute sizes of nested messages
1194        #[allow(unused_variables)]
1195        fn compute_size(&self) -> u64 {
1196            let mut my_size = 0;
1197            if let Some(v) = self.id.as_ref() {
1198                my_size += ::protobuf::rt::string_size(1, &v);
1199            }
1200            if let Some(v) = self.type_ {
1201                my_size += ::protobuf::rt::int32_size(2, v);
1202            }
1203            if let Some(v) = self.index {
1204                my_size += ::protobuf::rt::sint32_size(3, v);
1205            }
1206            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1207            self.special_fields.cached_size().set(my_size as u32);
1208            my_size
1209        }
1210
1211        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1212            if let Some(v) = self.id.as_ref() {
1213                os.write_string(1, v)?;
1214            }
1215            if let Some(v) = self.type_ {
1216                os.write_int32(2, v)?;
1217            }
1218            if let Some(v) = self.index {
1219                os.write_sint32(3, v)?;
1220            }
1221            os.write_unknown_fields(self.special_fields.unknown_fields())?;
1222            ::std::result::Result::Ok(())
1223        }
1224
1225        fn special_fields(&self) -> &::protobuf::SpecialFields {
1226            &self.special_fields
1227        }
1228
1229        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1230            &mut self.special_fields
1231        }
1232
1233        fn new() -> Product {
1234            Product::new()
1235        }
1236
1237        fn clear(&mut self) {
1238            self.id = ::std::option::Option::None;
1239            self.type_ = ::std::option::Option::None;
1240            self.index = ::std::option::Option::None;
1241            self.special_fields.clear();
1242        }
1243
1244        fn default_instance() -> &'static Product {
1245            static instance: Product = Product {
1246                id: ::std::option::Option::None,
1247                type_: ::std::option::Option::None,
1248                index: ::std::option::Option::None,
1249                special_fields: ::protobuf::SpecialFields::new(),
1250            };
1251            &instance
1252        }
1253    }
1254
1255    impl ::protobuf::MessageFull for Product {
1256        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1257            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1258            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("BasicMaterialInfo.Product").unwrap()).clone()
1259        }
1260    }
1261
1262    impl ::std::fmt::Display for Product {
1263        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1264            ::protobuf::text_format::fmt(self, f)
1265        }
1266    }
1267
1268    impl ::protobuf::reflect::ProtobufValue for Product {
1269        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1270    }
1271}
1272
1273// @@protoc_insertion_point(message:dfproto.BasicMaterialInfoMask)
1274#[derive(PartialEq,Clone,Default,Debug)]
1275pub struct BasicMaterialInfoMask {
1276    // message fields
1277    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfoMask.states)
1278    pub states: ::std::vec::Vec<::protobuf::EnumOrUnknown<basic_material_info_mask::StateType>>,
1279    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfoMask.temperature)
1280    pub temperature: ::std::option::Option<i32>,
1281    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfoMask.flags)
1282    pub flags: ::std::option::Option<bool>,
1283    // @@protoc_insertion_point(field:dfproto.BasicMaterialInfoMask.reaction)
1284    pub reaction: ::std::option::Option<bool>,
1285    // special fields
1286    // @@protoc_insertion_point(special_field:dfproto.BasicMaterialInfoMask.special_fields)
1287    pub special_fields: ::protobuf::SpecialFields,
1288}
1289
1290impl<'a> ::std::default::Default for &'a BasicMaterialInfoMask {
1291    fn default() -> &'a BasicMaterialInfoMask {
1292        <BasicMaterialInfoMask as ::protobuf::Message>::default_instance()
1293    }
1294}
1295
1296impl BasicMaterialInfoMask {
1297    pub fn new() -> BasicMaterialInfoMask {
1298        ::std::default::Default::default()
1299    }
1300
1301    // optional int32 temperature = 4;
1302
1303    pub fn temperature(&self) -> i32 {
1304        self.temperature.unwrap_or(10015i32)
1305    }
1306
1307    pub fn clear_temperature(&mut self) {
1308        self.temperature = ::std::option::Option::None;
1309    }
1310
1311    pub fn has_temperature(&self) -> bool {
1312        self.temperature.is_some()
1313    }
1314
1315    // Param is passed by value, moved
1316    pub fn set_temperature(&mut self, v: i32) {
1317        self.temperature = ::std::option::Option::Some(v);
1318    }
1319
1320    // optional bool flags = 2;
1321
1322    pub fn flags(&self) -> bool {
1323        self.flags.unwrap_or(false)
1324    }
1325
1326    pub fn clear_flags(&mut self) {
1327        self.flags = ::std::option::Option::None;
1328    }
1329
1330    pub fn has_flags(&self) -> bool {
1331        self.flags.is_some()
1332    }
1333
1334    // Param is passed by value, moved
1335    pub fn set_flags(&mut self, v: bool) {
1336        self.flags = ::std::option::Option::Some(v);
1337    }
1338
1339    // optional bool reaction = 3;
1340
1341    pub fn reaction(&self) -> bool {
1342        self.reaction.unwrap_or(false)
1343    }
1344
1345    pub fn clear_reaction(&mut self) {
1346        self.reaction = ::std::option::Option::None;
1347    }
1348
1349    pub fn has_reaction(&self) -> bool {
1350        self.reaction.is_some()
1351    }
1352
1353    // Param is passed by value, moved
1354    pub fn set_reaction(&mut self, v: bool) {
1355        self.reaction = ::std::option::Option::Some(v);
1356    }
1357
1358    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1359        let mut fields = ::std::vec::Vec::with_capacity(4);
1360        let mut oneofs = ::std::vec::Vec::with_capacity(0);
1361        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
1362            "states",
1363            |m: &BasicMaterialInfoMask| { &m.states },
1364            |m: &mut BasicMaterialInfoMask| { &mut m.states },
1365        ));
1366        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1367            "temperature",
1368            |m: &BasicMaterialInfoMask| { &m.temperature },
1369            |m: &mut BasicMaterialInfoMask| { &mut m.temperature },
1370        ));
1371        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1372            "flags",
1373            |m: &BasicMaterialInfoMask| { &m.flags },
1374            |m: &mut BasicMaterialInfoMask| { &mut m.flags },
1375        ));
1376        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1377            "reaction",
1378            |m: &BasicMaterialInfoMask| { &m.reaction },
1379            |m: &mut BasicMaterialInfoMask| { &mut m.reaction },
1380        ));
1381        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<BasicMaterialInfoMask>(
1382            "BasicMaterialInfoMask",
1383            fields,
1384            oneofs,
1385        )
1386    }
1387}
1388
1389impl ::protobuf::Message for BasicMaterialInfoMask {
1390    const NAME: &'static str = "BasicMaterialInfoMask";
1391
1392    fn is_initialized(&self) -> bool {
1393        true
1394    }
1395
1396    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1397        while let Some(tag) = is.read_raw_tag_or_eof()? {
1398            match tag {
1399                8 => {
1400                    self.states.push(is.read_enum_or_unknown()?);
1401                },
1402                10 => {
1403                    ::protobuf::rt::read_repeated_packed_enum_or_unknown_into(is, &mut self.states)?
1404                },
1405                32 => {
1406                    self.temperature = ::std::option::Option::Some(is.read_int32()?);
1407                },
1408                16 => {
1409                    self.flags = ::std::option::Option::Some(is.read_bool()?);
1410                },
1411                24 => {
1412                    self.reaction = ::std::option::Option::Some(is.read_bool()?);
1413                },
1414                tag => {
1415                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1416                },
1417            };
1418        }
1419        ::std::result::Result::Ok(())
1420    }
1421
1422    // Compute sizes of nested messages
1423    #[allow(unused_variables)]
1424    fn compute_size(&self) -> u64 {
1425        let mut my_size = 0;
1426        for value in &self.states {
1427            my_size += ::protobuf::rt::int32_size(1, value.value());
1428        };
1429        if let Some(v) = self.temperature {
1430            my_size += ::protobuf::rt::int32_size(4, v);
1431        }
1432        if let Some(v) = self.flags {
1433            my_size += 1 + 1;
1434        }
1435        if let Some(v) = self.reaction {
1436            my_size += 1 + 1;
1437        }
1438        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1439        self.special_fields.cached_size().set(my_size as u32);
1440        my_size
1441    }
1442
1443    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1444        for v in &self.states {
1445            os.write_enum(1, ::protobuf::EnumOrUnknown::value(v))?;
1446        };
1447        if let Some(v) = self.temperature {
1448            os.write_int32(4, v)?;
1449        }
1450        if let Some(v) = self.flags {
1451            os.write_bool(2, v)?;
1452        }
1453        if let Some(v) = self.reaction {
1454            os.write_bool(3, v)?;
1455        }
1456        os.write_unknown_fields(self.special_fields.unknown_fields())?;
1457        ::std::result::Result::Ok(())
1458    }
1459
1460    fn special_fields(&self) -> &::protobuf::SpecialFields {
1461        &self.special_fields
1462    }
1463
1464    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1465        &mut self.special_fields
1466    }
1467
1468    fn new() -> BasicMaterialInfoMask {
1469        BasicMaterialInfoMask::new()
1470    }
1471
1472    fn clear(&mut self) {
1473        self.states.clear();
1474        self.temperature = ::std::option::Option::None;
1475        self.flags = ::std::option::Option::None;
1476        self.reaction = ::std::option::Option::None;
1477        self.special_fields.clear();
1478    }
1479
1480    fn default_instance() -> &'static BasicMaterialInfoMask {
1481        static instance: BasicMaterialInfoMask = BasicMaterialInfoMask {
1482            states: ::std::vec::Vec::new(),
1483            temperature: ::std::option::Option::None,
1484            flags: ::std::option::Option::None,
1485            reaction: ::std::option::Option::None,
1486            special_fields: ::protobuf::SpecialFields::new(),
1487        };
1488        &instance
1489    }
1490}
1491
1492impl ::protobuf::MessageFull for BasicMaterialInfoMask {
1493    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1494        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1495        descriptor.get(|| file_descriptor().message_by_package_relative_name("BasicMaterialInfoMask").unwrap()).clone()
1496    }
1497}
1498
1499impl ::std::fmt::Display for BasicMaterialInfoMask {
1500    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1501        ::protobuf::text_format::fmt(self, f)
1502    }
1503}
1504
1505impl ::protobuf::reflect::ProtobufValue for BasicMaterialInfoMask {
1506    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1507}
1508
1509/// Nested message and enums of message `BasicMaterialInfoMask`
1510pub mod basic_material_info_mask {
1511    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
1512    // @@protoc_insertion_point(enum:dfproto.BasicMaterialInfoMask.StateType)
1513    pub enum StateType {
1514        // @@protoc_insertion_point(enum_value:dfproto.BasicMaterialInfoMask.StateType.Solid)
1515        Solid = 0,
1516        // @@protoc_insertion_point(enum_value:dfproto.BasicMaterialInfoMask.StateType.Liquid)
1517        Liquid = 1,
1518        // @@protoc_insertion_point(enum_value:dfproto.BasicMaterialInfoMask.StateType.Gas)
1519        Gas = 2,
1520        // @@protoc_insertion_point(enum_value:dfproto.BasicMaterialInfoMask.StateType.Powder)
1521        Powder = 3,
1522        // @@protoc_insertion_point(enum_value:dfproto.BasicMaterialInfoMask.StateType.Paste)
1523        Paste = 4,
1524        // @@protoc_insertion_point(enum_value:dfproto.BasicMaterialInfoMask.StateType.Pressed)
1525        Pressed = 5,
1526    }
1527
1528    impl ::protobuf::Enum for StateType {
1529        const NAME: &'static str = "StateType";
1530
1531        fn value(&self) -> i32 {
1532            *self as i32
1533        }
1534
1535        fn from_i32(value: i32) -> ::std::option::Option<StateType> {
1536            match value {
1537                0 => ::std::option::Option::Some(StateType::Solid),
1538                1 => ::std::option::Option::Some(StateType::Liquid),
1539                2 => ::std::option::Option::Some(StateType::Gas),
1540                3 => ::std::option::Option::Some(StateType::Powder),
1541                4 => ::std::option::Option::Some(StateType::Paste),
1542                5 => ::std::option::Option::Some(StateType::Pressed),
1543                _ => ::std::option::Option::None
1544            }
1545        }
1546
1547        fn from_str(str: &str) -> ::std::option::Option<StateType> {
1548            match str {
1549                "Solid" => ::std::option::Option::Some(StateType::Solid),
1550                "Liquid" => ::std::option::Option::Some(StateType::Liquid),
1551                "Gas" => ::std::option::Option::Some(StateType::Gas),
1552                "Powder" => ::std::option::Option::Some(StateType::Powder),
1553                "Paste" => ::std::option::Option::Some(StateType::Paste),
1554                "Pressed" => ::std::option::Option::Some(StateType::Pressed),
1555                _ => ::std::option::Option::None
1556            }
1557        }
1558
1559        const VALUES: &'static [StateType] = &[
1560            StateType::Solid,
1561            StateType::Liquid,
1562            StateType::Gas,
1563            StateType::Powder,
1564            StateType::Paste,
1565            StateType::Pressed,
1566        ];
1567    }
1568
1569    impl ::protobuf::EnumFull for StateType {
1570        fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
1571            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
1572            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("BasicMaterialInfoMask.StateType").unwrap()).clone()
1573        }
1574
1575        fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
1576            let index = *self as usize;
1577            Self::enum_descriptor().value_by_index(index)
1578        }
1579    }
1580
1581    impl ::std::default::Default for StateType {
1582        fn default() -> Self {
1583            StateType::Solid
1584        }
1585    }
1586
1587    impl StateType {
1588        pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
1589            ::protobuf::reflect::GeneratedEnumDescriptorData::new::<StateType>("BasicMaterialInfoMask.StateType")
1590        }
1591    }
1592}
1593
1594// @@protoc_insertion_point(message:dfproto.JobSkillAttr)
1595#[derive(PartialEq,Clone,Default,Debug)]
1596pub struct JobSkillAttr {
1597    // message fields
1598    // @@protoc_insertion_point(field:dfproto.JobSkillAttr.id)
1599    pub id: ::std::option::Option<i32>,
1600    // @@protoc_insertion_point(field:dfproto.JobSkillAttr.key)
1601    pub key: ::std::option::Option<::std::string::String>,
1602    // @@protoc_insertion_point(field:dfproto.JobSkillAttr.caption)
1603    pub caption: ::std::option::Option<::std::string::String>,
1604    // @@protoc_insertion_point(field:dfproto.JobSkillAttr.caption_noun)
1605    pub caption_noun: ::std::option::Option<::std::string::String>,
1606    // @@protoc_insertion_point(field:dfproto.JobSkillAttr.profession)
1607    pub profession: ::std::option::Option<i32>,
1608    // @@protoc_insertion_point(field:dfproto.JobSkillAttr.labor)
1609    pub labor: ::std::option::Option<i32>,
1610    // @@protoc_insertion_point(field:dfproto.JobSkillAttr.type)
1611    pub type_: ::std::option::Option<::std::string::String>,
1612    // special fields
1613    // @@protoc_insertion_point(special_field:dfproto.JobSkillAttr.special_fields)
1614    pub special_fields: ::protobuf::SpecialFields,
1615}
1616
1617impl<'a> ::std::default::Default for &'a JobSkillAttr {
1618    fn default() -> &'a JobSkillAttr {
1619        <JobSkillAttr as ::protobuf::Message>::default_instance()
1620    }
1621}
1622
1623impl JobSkillAttr {
1624    pub fn new() -> JobSkillAttr {
1625        ::std::default::Default::default()
1626    }
1627
1628    // required int32 id = 1;
1629
1630    pub fn id(&self) -> i32 {
1631        self.id.unwrap_or(0)
1632    }
1633
1634    pub fn clear_id(&mut self) {
1635        self.id = ::std::option::Option::None;
1636    }
1637
1638    pub fn has_id(&self) -> bool {
1639        self.id.is_some()
1640    }
1641
1642    // Param is passed by value, moved
1643    pub fn set_id(&mut self, v: i32) {
1644        self.id = ::std::option::Option::Some(v);
1645    }
1646
1647    // required string key = 2;
1648
1649    pub fn key(&self) -> &str {
1650        match self.key.as_ref() {
1651            Some(v) => v,
1652            None => "",
1653        }
1654    }
1655
1656    pub fn clear_key(&mut self) {
1657        self.key = ::std::option::Option::None;
1658    }
1659
1660    pub fn has_key(&self) -> bool {
1661        self.key.is_some()
1662    }
1663
1664    // Param is passed by value, moved
1665    pub fn set_key(&mut self, v: ::std::string::String) {
1666        self.key = ::std::option::Option::Some(v);
1667    }
1668
1669    // Mutable pointer to the field.
1670    // If field is not initialized, it is initialized with default value first.
1671    pub fn mut_key(&mut self) -> &mut ::std::string::String {
1672        if self.key.is_none() {
1673            self.key = ::std::option::Option::Some(::std::string::String::new());
1674        }
1675        self.key.as_mut().unwrap()
1676    }
1677
1678    // Take field
1679    pub fn take_key(&mut self) -> ::std::string::String {
1680        self.key.take().unwrap_or_else(|| ::std::string::String::new())
1681    }
1682
1683    // optional string caption = 3;
1684
1685    pub fn caption(&self) -> &str {
1686        match self.caption.as_ref() {
1687            Some(v) => v,
1688            None => "",
1689        }
1690    }
1691
1692    pub fn clear_caption(&mut self) {
1693        self.caption = ::std::option::Option::None;
1694    }
1695
1696    pub fn has_caption(&self) -> bool {
1697        self.caption.is_some()
1698    }
1699
1700    // Param is passed by value, moved
1701    pub fn set_caption(&mut self, v: ::std::string::String) {
1702        self.caption = ::std::option::Option::Some(v);
1703    }
1704
1705    // Mutable pointer to the field.
1706    // If field is not initialized, it is initialized with default value first.
1707    pub fn mut_caption(&mut self) -> &mut ::std::string::String {
1708        if self.caption.is_none() {
1709            self.caption = ::std::option::Option::Some(::std::string::String::new());
1710        }
1711        self.caption.as_mut().unwrap()
1712    }
1713
1714    // Take field
1715    pub fn take_caption(&mut self) -> ::std::string::String {
1716        self.caption.take().unwrap_or_else(|| ::std::string::String::new())
1717    }
1718
1719    // optional string caption_noun = 4;
1720
1721    pub fn caption_noun(&self) -> &str {
1722        match self.caption_noun.as_ref() {
1723            Some(v) => v,
1724            None => "",
1725        }
1726    }
1727
1728    pub fn clear_caption_noun(&mut self) {
1729        self.caption_noun = ::std::option::Option::None;
1730    }
1731
1732    pub fn has_caption_noun(&self) -> bool {
1733        self.caption_noun.is_some()
1734    }
1735
1736    // Param is passed by value, moved
1737    pub fn set_caption_noun(&mut self, v: ::std::string::String) {
1738        self.caption_noun = ::std::option::Option::Some(v);
1739    }
1740
1741    // Mutable pointer to the field.
1742    // If field is not initialized, it is initialized with default value first.
1743    pub fn mut_caption_noun(&mut self) -> &mut ::std::string::String {
1744        if self.caption_noun.is_none() {
1745            self.caption_noun = ::std::option::Option::Some(::std::string::String::new());
1746        }
1747        self.caption_noun.as_mut().unwrap()
1748    }
1749
1750    // Take field
1751    pub fn take_caption_noun(&mut self) -> ::std::string::String {
1752        self.caption_noun.take().unwrap_or_else(|| ::std::string::String::new())
1753    }
1754
1755    // optional int32 profession = 5;
1756
1757    pub fn profession(&self) -> i32 {
1758        self.profession.unwrap_or(0)
1759    }
1760
1761    pub fn clear_profession(&mut self) {
1762        self.profession = ::std::option::Option::None;
1763    }
1764
1765    pub fn has_profession(&self) -> bool {
1766        self.profession.is_some()
1767    }
1768
1769    // Param is passed by value, moved
1770    pub fn set_profession(&mut self, v: i32) {
1771        self.profession = ::std::option::Option::Some(v);
1772    }
1773
1774    // optional int32 labor = 6;
1775
1776    pub fn labor(&self) -> i32 {
1777        self.labor.unwrap_or(0)
1778    }
1779
1780    pub fn clear_labor(&mut self) {
1781        self.labor = ::std::option::Option::None;
1782    }
1783
1784    pub fn has_labor(&self) -> bool {
1785        self.labor.is_some()
1786    }
1787
1788    // Param is passed by value, moved
1789    pub fn set_labor(&mut self, v: i32) {
1790        self.labor = ::std::option::Option::Some(v);
1791    }
1792
1793    // optional string type = 7;
1794
1795    pub fn type_(&self) -> &str {
1796        match self.type_.as_ref() {
1797            Some(v) => v,
1798            None => "",
1799        }
1800    }
1801
1802    pub fn clear_type_(&mut self) {
1803        self.type_ = ::std::option::Option::None;
1804    }
1805
1806    pub fn has_type(&self) -> bool {
1807        self.type_.is_some()
1808    }
1809
1810    // Param is passed by value, moved
1811    pub fn set_type(&mut self, v: ::std::string::String) {
1812        self.type_ = ::std::option::Option::Some(v);
1813    }
1814
1815    // Mutable pointer to the field.
1816    // If field is not initialized, it is initialized with default value first.
1817    pub fn mut_type(&mut self) -> &mut ::std::string::String {
1818        if self.type_.is_none() {
1819            self.type_ = ::std::option::Option::Some(::std::string::String::new());
1820        }
1821        self.type_.as_mut().unwrap()
1822    }
1823
1824    // Take field
1825    pub fn take_type_(&mut self) -> ::std::string::String {
1826        self.type_.take().unwrap_or_else(|| ::std::string::String::new())
1827    }
1828
1829    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1830        let mut fields = ::std::vec::Vec::with_capacity(7);
1831        let mut oneofs = ::std::vec::Vec::with_capacity(0);
1832        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1833            "id",
1834            |m: &JobSkillAttr| { &m.id },
1835            |m: &mut JobSkillAttr| { &mut m.id },
1836        ));
1837        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1838            "key",
1839            |m: &JobSkillAttr| { &m.key },
1840            |m: &mut JobSkillAttr| { &mut m.key },
1841        ));
1842        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1843            "caption",
1844            |m: &JobSkillAttr| { &m.caption },
1845            |m: &mut JobSkillAttr| { &mut m.caption },
1846        ));
1847        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1848            "caption_noun",
1849            |m: &JobSkillAttr| { &m.caption_noun },
1850            |m: &mut JobSkillAttr| { &mut m.caption_noun },
1851        ));
1852        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1853            "profession",
1854            |m: &JobSkillAttr| { &m.profession },
1855            |m: &mut JobSkillAttr| { &mut m.profession },
1856        ));
1857        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1858            "labor",
1859            |m: &JobSkillAttr| { &m.labor },
1860            |m: &mut JobSkillAttr| { &mut m.labor },
1861        ));
1862        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1863            "type",
1864            |m: &JobSkillAttr| { &m.type_ },
1865            |m: &mut JobSkillAttr| { &mut m.type_ },
1866        ));
1867        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<JobSkillAttr>(
1868            "JobSkillAttr",
1869            fields,
1870            oneofs,
1871        )
1872    }
1873}
1874
1875impl ::protobuf::Message for JobSkillAttr {
1876    const NAME: &'static str = "JobSkillAttr";
1877
1878    fn is_initialized(&self) -> bool {
1879        if self.id.is_none() {
1880            return false;
1881        }
1882        if self.key.is_none() {
1883            return false;
1884        }
1885        true
1886    }
1887
1888    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1889        while let Some(tag) = is.read_raw_tag_or_eof()? {
1890            match tag {
1891                8 => {
1892                    self.id = ::std::option::Option::Some(is.read_int32()?);
1893                },
1894                18 => {
1895                    self.key = ::std::option::Option::Some(is.read_string()?);
1896                },
1897                26 => {
1898                    self.caption = ::std::option::Option::Some(is.read_string()?);
1899                },
1900                34 => {
1901                    self.caption_noun = ::std::option::Option::Some(is.read_string()?);
1902                },
1903                40 => {
1904                    self.profession = ::std::option::Option::Some(is.read_int32()?);
1905                },
1906                48 => {
1907                    self.labor = ::std::option::Option::Some(is.read_int32()?);
1908                },
1909                58 => {
1910                    self.type_ = ::std::option::Option::Some(is.read_string()?);
1911                },
1912                tag => {
1913                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1914                },
1915            };
1916        }
1917        ::std::result::Result::Ok(())
1918    }
1919
1920    // Compute sizes of nested messages
1921    #[allow(unused_variables)]
1922    fn compute_size(&self) -> u64 {
1923        let mut my_size = 0;
1924        if let Some(v) = self.id {
1925            my_size += ::protobuf::rt::int32_size(1, v);
1926        }
1927        if let Some(v) = self.key.as_ref() {
1928            my_size += ::protobuf::rt::string_size(2, &v);
1929        }
1930        if let Some(v) = self.caption.as_ref() {
1931            my_size += ::protobuf::rt::string_size(3, &v);
1932        }
1933        if let Some(v) = self.caption_noun.as_ref() {
1934            my_size += ::protobuf::rt::string_size(4, &v);
1935        }
1936        if let Some(v) = self.profession {
1937            my_size += ::protobuf::rt::int32_size(5, v);
1938        }
1939        if let Some(v) = self.labor {
1940            my_size += ::protobuf::rt::int32_size(6, v);
1941        }
1942        if let Some(v) = self.type_.as_ref() {
1943            my_size += ::protobuf::rt::string_size(7, &v);
1944        }
1945        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1946        self.special_fields.cached_size().set(my_size as u32);
1947        my_size
1948    }
1949
1950    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1951        if let Some(v) = self.id {
1952            os.write_int32(1, v)?;
1953        }
1954        if let Some(v) = self.key.as_ref() {
1955            os.write_string(2, v)?;
1956        }
1957        if let Some(v) = self.caption.as_ref() {
1958            os.write_string(3, v)?;
1959        }
1960        if let Some(v) = self.caption_noun.as_ref() {
1961            os.write_string(4, v)?;
1962        }
1963        if let Some(v) = self.profession {
1964            os.write_int32(5, v)?;
1965        }
1966        if let Some(v) = self.labor {
1967            os.write_int32(6, v)?;
1968        }
1969        if let Some(v) = self.type_.as_ref() {
1970            os.write_string(7, v)?;
1971        }
1972        os.write_unknown_fields(self.special_fields.unknown_fields())?;
1973        ::std::result::Result::Ok(())
1974    }
1975
1976    fn special_fields(&self) -> &::protobuf::SpecialFields {
1977        &self.special_fields
1978    }
1979
1980    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1981        &mut self.special_fields
1982    }
1983
1984    fn new() -> JobSkillAttr {
1985        JobSkillAttr::new()
1986    }
1987
1988    fn clear(&mut self) {
1989        self.id = ::std::option::Option::None;
1990        self.key = ::std::option::Option::None;
1991        self.caption = ::std::option::Option::None;
1992        self.caption_noun = ::std::option::Option::None;
1993        self.profession = ::std::option::Option::None;
1994        self.labor = ::std::option::Option::None;
1995        self.type_ = ::std::option::Option::None;
1996        self.special_fields.clear();
1997    }
1998
1999    fn default_instance() -> &'static JobSkillAttr {
2000        static instance: JobSkillAttr = JobSkillAttr {
2001            id: ::std::option::Option::None,
2002            key: ::std::option::Option::None,
2003            caption: ::std::option::Option::None,
2004            caption_noun: ::std::option::Option::None,
2005            profession: ::std::option::Option::None,
2006            labor: ::std::option::Option::None,
2007            type_: ::std::option::Option::None,
2008            special_fields: ::protobuf::SpecialFields::new(),
2009        };
2010        &instance
2011    }
2012}
2013
2014impl ::protobuf::MessageFull for JobSkillAttr {
2015    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2016        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2017        descriptor.get(|| file_descriptor().message_by_package_relative_name("JobSkillAttr").unwrap()).clone()
2018    }
2019}
2020
2021impl ::std::fmt::Display for JobSkillAttr {
2022    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2023        ::protobuf::text_format::fmt(self, f)
2024    }
2025}
2026
2027impl ::protobuf::reflect::ProtobufValue for JobSkillAttr {
2028    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2029}
2030
2031// @@protoc_insertion_point(message:dfproto.ProfessionAttr)
2032#[derive(PartialEq,Clone,Default,Debug)]
2033pub struct ProfessionAttr {
2034    // message fields
2035    // @@protoc_insertion_point(field:dfproto.ProfessionAttr.id)
2036    pub id: ::std::option::Option<i32>,
2037    // @@protoc_insertion_point(field:dfproto.ProfessionAttr.key)
2038    pub key: ::std::option::Option<::std::string::String>,
2039    // @@protoc_insertion_point(field:dfproto.ProfessionAttr.caption)
2040    pub caption: ::std::option::Option<::std::string::String>,
2041    // @@protoc_insertion_point(field:dfproto.ProfessionAttr.military)
2042    pub military: ::std::option::Option<bool>,
2043    // @@protoc_insertion_point(field:dfproto.ProfessionAttr.can_assign_labor)
2044    pub can_assign_labor: ::std::option::Option<bool>,
2045    // @@protoc_insertion_point(field:dfproto.ProfessionAttr.parent)
2046    pub parent: ::std::option::Option<i32>,
2047    // special fields
2048    // @@protoc_insertion_point(special_field:dfproto.ProfessionAttr.special_fields)
2049    pub special_fields: ::protobuf::SpecialFields,
2050}
2051
2052impl<'a> ::std::default::Default for &'a ProfessionAttr {
2053    fn default() -> &'a ProfessionAttr {
2054        <ProfessionAttr as ::protobuf::Message>::default_instance()
2055    }
2056}
2057
2058impl ProfessionAttr {
2059    pub fn new() -> ProfessionAttr {
2060        ::std::default::Default::default()
2061    }
2062
2063    // required int32 id = 1;
2064
2065    pub fn id(&self) -> i32 {
2066        self.id.unwrap_or(0)
2067    }
2068
2069    pub fn clear_id(&mut self) {
2070        self.id = ::std::option::Option::None;
2071    }
2072
2073    pub fn has_id(&self) -> bool {
2074        self.id.is_some()
2075    }
2076
2077    // Param is passed by value, moved
2078    pub fn set_id(&mut self, v: i32) {
2079        self.id = ::std::option::Option::Some(v);
2080    }
2081
2082    // required string key = 2;
2083
2084    pub fn key(&self) -> &str {
2085        match self.key.as_ref() {
2086            Some(v) => v,
2087            None => "",
2088        }
2089    }
2090
2091    pub fn clear_key(&mut self) {
2092        self.key = ::std::option::Option::None;
2093    }
2094
2095    pub fn has_key(&self) -> bool {
2096        self.key.is_some()
2097    }
2098
2099    // Param is passed by value, moved
2100    pub fn set_key(&mut self, v: ::std::string::String) {
2101        self.key = ::std::option::Option::Some(v);
2102    }
2103
2104    // Mutable pointer to the field.
2105    // If field is not initialized, it is initialized with default value first.
2106    pub fn mut_key(&mut self) -> &mut ::std::string::String {
2107        if self.key.is_none() {
2108            self.key = ::std::option::Option::Some(::std::string::String::new());
2109        }
2110        self.key.as_mut().unwrap()
2111    }
2112
2113    // Take field
2114    pub fn take_key(&mut self) -> ::std::string::String {
2115        self.key.take().unwrap_or_else(|| ::std::string::String::new())
2116    }
2117
2118    // optional string caption = 3;
2119
2120    pub fn caption(&self) -> &str {
2121        match self.caption.as_ref() {
2122            Some(v) => v,
2123            None => "",
2124        }
2125    }
2126
2127    pub fn clear_caption(&mut self) {
2128        self.caption = ::std::option::Option::None;
2129    }
2130
2131    pub fn has_caption(&self) -> bool {
2132        self.caption.is_some()
2133    }
2134
2135    // Param is passed by value, moved
2136    pub fn set_caption(&mut self, v: ::std::string::String) {
2137        self.caption = ::std::option::Option::Some(v);
2138    }
2139
2140    // Mutable pointer to the field.
2141    // If field is not initialized, it is initialized with default value first.
2142    pub fn mut_caption(&mut self) -> &mut ::std::string::String {
2143        if self.caption.is_none() {
2144            self.caption = ::std::option::Option::Some(::std::string::String::new());
2145        }
2146        self.caption.as_mut().unwrap()
2147    }
2148
2149    // Take field
2150    pub fn take_caption(&mut self) -> ::std::string::String {
2151        self.caption.take().unwrap_or_else(|| ::std::string::String::new())
2152    }
2153
2154    // optional bool military = 4;
2155
2156    pub fn military(&self) -> bool {
2157        self.military.unwrap_or(false)
2158    }
2159
2160    pub fn clear_military(&mut self) {
2161        self.military = ::std::option::Option::None;
2162    }
2163
2164    pub fn has_military(&self) -> bool {
2165        self.military.is_some()
2166    }
2167
2168    // Param is passed by value, moved
2169    pub fn set_military(&mut self, v: bool) {
2170        self.military = ::std::option::Option::Some(v);
2171    }
2172
2173    // optional bool can_assign_labor = 5;
2174
2175    pub fn can_assign_labor(&self) -> bool {
2176        self.can_assign_labor.unwrap_or(false)
2177    }
2178
2179    pub fn clear_can_assign_labor(&mut self) {
2180        self.can_assign_labor = ::std::option::Option::None;
2181    }
2182
2183    pub fn has_can_assign_labor(&self) -> bool {
2184        self.can_assign_labor.is_some()
2185    }
2186
2187    // Param is passed by value, moved
2188    pub fn set_can_assign_labor(&mut self, v: bool) {
2189        self.can_assign_labor = ::std::option::Option::Some(v);
2190    }
2191
2192    // optional int32 parent = 6;
2193
2194    pub fn parent(&self) -> i32 {
2195        self.parent.unwrap_or(0)
2196    }
2197
2198    pub fn clear_parent(&mut self) {
2199        self.parent = ::std::option::Option::None;
2200    }
2201
2202    pub fn has_parent(&self) -> bool {
2203        self.parent.is_some()
2204    }
2205
2206    // Param is passed by value, moved
2207    pub fn set_parent(&mut self, v: i32) {
2208        self.parent = ::std::option::Option::Some(v);
2209    }
2210
2211    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
2212        let mut fields = ::std::vec::Vec::with_capacity(6);
2213        let mut oneofs = ::std::vec::Vec::with_capacity(0);
2214        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2215            "id",
2216            |m: &ProfessionAttr| { &m.id },
2217            |m: &mut ProfessionAttr| { &mut m.id },
2218        ));
2219        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2220            "key",
2221            |m: &ProfessionAttr| { &m.key },
2222            |m: &mut ProfessionAttr| { &mut m.key },
2223        ));
2224        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2225            "caption",
2226            |m: &ProfessionAttr| { &m.caption },
2227            |m: &mut ProfessionAttr| { &mut m.caption },
2228        ));
2229        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2230            "military",
2231            |m: &ProfessionAttr| { &m.military },
2232            |m: &mut ProfessionAttr| { &mut m.military },
2233        ));
2234        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2235            "can_assign_labor",
2236            |m: &ProfessionAttr| { &m.can_assign_labor },
2237            |m: &mut ProfessionAttr| { &mut m.can_assign_labor },
2238        ));
2239        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2240            "parent",
2241            |m: &ProfessionAttr| { &m.parent },
2242            |m: &mut ProfessionAttr| { &mut m.parent },
2243        ));
2244        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ProfessionAttr>(
2245            "ProfessionAttr",
2246            fields,
2247            oneofs,
2248        )
2249    }
2250}
2251
2252impl ::protobuf::Message for ProfessionAttr {
2253    const NAME: &'static str = "ProfessionAttr";
2254
2255    fn is_initialized(&self) -> bool {
2256        if self.id.is_none() {
2257            return false;
2258        }
2259        if self.key.is_none() {
2260            return false;
2261        }
2262        true
2263    }
2264
2265    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
2266        while let Some(tag) = is.read_raw_tag_or_eof()? {
2267            match tag {
2268                8 => {
2269                    self.id = ::std::option::Option::Some(is.read_int32()?);
2270                },
2271                18 => {
2272                    self.key = ::std::option::Option::Some(is.read_string()?);
2273                },
2274                26 => {
2275                    self.caption = ::std::option::Option::Some(is.read_string()?);
2276                },
2277                32 => {
2278                    self.military = ::std::option::Option::Some(is.read_bool()?);
2279                },
2280                40 => {
2281                    self.can_assign_labor = ::std::option::Option::Some(is.read_bool()?);
2282                },
2283                48 => {
2284                    self.parent = ::std::option::Option::Some(is.read_int32()?);
2285                },
2286                tag => {
2287                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2288                },
2289            };
2290        }
2291        ::std::result::Result::Ok(())
2292    }
2293
2294    // Compute sizes of nested messages
2295    #[allow(unused_variables)]
2296    fn compute_size(&self) -> u64 {
2297        let mut my_size = 0;
2298        if let Some(v) = self.id {
2299            my_size += ::protobuf::rt::int32_size(1, v);
2300        }
2301        if let Some(v) = self.key.as_ref() {
2302            my_size += ::protobuf::rt::string_size(2, &v);
2303        }
2304        if let Some(v) = self.caption.as_ref() {
2305            my_size += ::protobuf::rt::string_size(3, &v);
2306        }
2307        if let Some(v) = self.military {
2308            my_size += 1 + 1;
2309        }
2310        if let Some(v) = self.can_assign_labor {
2311            my_size += 1 + 1;
2312        }
2313        if let Some(v) = self.parent {
2314            my_size += ::protobuf::rt::int32_size(6, v);
2315        }
2316        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2317        self.special_fields.cached_size().set(my_size as u32);
2318        my_size
2319    }
2320
2321    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
2322        if let Some(v) = self.id {
2323            os.write_int32(1, v)?;
2324        }
2325        if let Some(v) = self.key.as_ref() {
2326            os.write_string(2, v)?;
2327        }
2328        if let Some(v) = self.caption.as_ref() {
2329            os.write_string(3, v)?;
2330        }
2331        if let Some(v) = self.military {
2332            os.write_bool(4, v)?;
2333        }
2334        if let Some(v) = self.can_assign_labor {
2335            os.write_bool(5, v)?;
2336        }
2337        if let Some(v) = self.parent {
2338            os.write_int32(6, v)?;
2339        }
2340        os.write_unknown_fields(self.special_fields.unknown_fields())?;
2341        ::std::result::Result::Ok(())
2342    }
2343
2344    fn special_fields(&self) -> &::protobuf::SpecialFields {
2345        &self.special_fields
2346    }
2347
2348    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2349        &mut self.special_fields
2350    }
2351
2352    fn new() -> ProfessionAttr {
2353        ProfessionAttr::new()
2354    }
2355
2356    fn clear(&mut self) {
2357        self.id = ::std::option::Option::None;
2358        self.key = ::std::option::Option::None;
2359        self.caption = ::std::option::Option::None;
2360        self.military = ::std::option::Option::None;
2361        self.can_assign_labor = ::std::option::Option::None;
2362        self.parent = ::std::option::Option::None;
2363        self.special_fields.clear();
2364    }
2365
2366    fn default_instance() -> &'static ProfessionAttr {
2367        static instance: ProfessionAttr = ProfessionAttr {
2368            id: ::std::option::Option::None,
2369            key: ::std::option::Option::None,
2370            caption: ::std::option::Option::None,
2371            military: ::std::option::Option::None,
2372            can_assign_labor: ::std::option::Option::None,
2373            parent: ::std::option::Option::None,
2374            special_fields: ::protobuf::SpecialFields::new(),
2375        };
2376        &instance
2377    }
2378}
2379
2380impl ::protobuf::MessageFull for ProfessionAttr {
2381    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2382        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2383        descriptor.get(|| file_descriptor().message_by_package_relative_name("ProfessionAttr").unwrap()).clone()
2384    }
2385}
2386
2387impl ::std::fmt::Display for ProfessionAttr {
2388    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2389        ::protobuf::text_format::fmt(self, f)
2390    }
2391}
2392
2393impl ::protobuf::reflect::ProtobufValue for ProfessionAttr {
2394    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2395}
2396
2397// @@protoc_insertion_point(message:dfproto.UnitLaborAttr)
2398#[derive(PartialEq,Clone,Default,Debug)]
2399pub struct UnitLaborAttr {
2400    // message fields
2401    // @@protoc_insertion_point(field:dfproto.UnitLaborAttr.id)
2402    pub id: ::std::option::Option<i32>,
2403    // @@protoc_insertion_point(field:dfproto.UnitLaborAttr.key)
2404    pub key: ::std::option::Option<::std::string::String>,
2405    // @@protoc_insertion_point(field:dfproto.UnitLaborAttr.caption)
2406    pub caption: ::std::option::Option<::std::string::String>,
2407    // special fields
2408    // @@protoc_insertion_point(special_field:dfproto.UnitLaborAttr.special_fields)
2409    pub special_fields: ::protobuf::SpecialFields,
2410}
2411
2412impl<'a> ::std::default::Default for &'a UnitLaborAttr {
2413    fn default() -> &'a UnitLaborAttr {
2414        <UnitLaborAttr as ::protobuf::Message>::default_instance()
2415    }
2416}
2417
2418impl UnitLaborAttr {
2419    pub fn new() -> UnitLaborAttr {
2420        ::std::default::Default::default()
2421    }
2422
2423    // required int32 id = 1;
2424
2425    pub fn id(&self) -> i32 {
2426        self.id.unwrap_or(0)
2427    }
2428
2429    pub fn clear_id(&mut self) {
2430        self.id = ::std::option::Option::None;
2431    }
2432
2433    pub fn has_id(&self) -> bool {
2434        self.id.is_some()
2435    }
2436
2437    // Param is passed by value, moved
2438    pub fn set_id(&mut self, v: i32) {
2439        self.id = ::std::option::Option::Some(v);
2440    }
2441
2442    // required string key = 2;
2443
2444    pub fn key(&self) -> &str {
2445        match self.key.as_ref() {
2446            Some(v) => v,
2447            None => "",
2448        }
2449    }
2450
2451    pub fn clear_key(&mut self) {
2452        self.key = ::std::option::Option::None;
2453    }
2454
2455    pub fn has_key(&self) -> bool {
2456        self.key.is_some()
2457    }
2458
2459    // Param is passed by value, moved
2460    pub fn set_key(&mut self, v: ::std::string::String) {
2461        self.key = ::std::option::Option::Some(v);
2462    }
2463
2464    // Mutable pointer to the field.
2465    // If field is not initialized, it is initialized with default value first.
2466    pub fn mut_key(&mut self) -> &mut ::std::string::String {
2467        if self.key.is_none() {
2468            self.key = ::std::option::Option::Some(::std::string::String::new());
2469        }
2470        self.key.as_mut().unwrap()
2471    }
2472
2473    // Take field
2474    pub fn take_key(&mut self) -> ::std::string::String {
2475        self.key.take().unwrap_or_else(|| ::std::string::String::new())
2476    }
2477
2478    // optional string caption = 3;
2479
2480    pub fn caption(&self) -> &str {
2481        match self.caption.as_ref() {
2482            Some(v) => v,
2483            None => "",
2484        }
2485    }
2486
2487    pub fn clear_caption(&mut self) {
2488        self.caption = ::std::option::Option::None;
2489    }
2490
2491    pub fn has_caption(&self) -> bool {
2492        self.caption.is_some()
2493    }
2494
2495    // Param is passed by value, moved
2496    pub fn set_caption(&mut self, v: ::std::string::String) {
2497        self.caption = ::std::option::Option::Some(v);
2498    }
2499
2500    // Mutable pointer to the field.
2501    // If field is not initialized, it is initialized with default value first.
2502    pub fn mut_caption(&mut self) -> &mut ::std::string::String {
2503        if self.caption.is_none() {
2504            self.caption = ::std::option::Option::Some(::std::string::String::new());
2505        }
2506        self.caption.as_mut().unwrap()
2507    }
2508
2509    // Take field
2510    pub fn take_caption(&mut self) -> ::std::string::String {
2511        self.caption.take().unwrap_or_else(|| ::std::string::String::new())
2512    }
2513
2514    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
2515        let mut fields = ::std::vec::Vec::with_capacity(3);
2516        let mut oneofs = ::std::vec::Vec::with_capacity(0);
2517        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2518            "id",
2519            |m: &UnitLaborAttr| { &m.id },
2520            |m: &mut UnitLaborAttr| { &mut m.id },
2521        ));
2522        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2523            "key",
2524            |m: &UnitLaborAttr| { &m.key },
2525            |m: &mut UnitLaborAttr| { &mut m.key },
2526        ));
2527        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2528            "caption",
2529            |m: &UnitLaborAttr| { &m.caption },
2530            |m: &mut UnitLaborAttr| { &mut m.caption },
2531        ));
2532        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UnitLaborAttr>(
2533            "UnitLaborAttr",
2534            fields,
2535            oneofs,
2536        )
2537    }
2538}
2539
2540impl ::protobuf::Message for UnitLaborAttr {
2541    const NAME: &'static str = "UnitLaborAttr";
2542
2543    fn is_initialized(&self) -> bool {
2544        if self.id.is_none() {
2545            return false;
2546        }
2547        if self.key.is_none() {
2548            return false;
2549        }
2550        true
2551    }
2552
2553    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
2554        while let Some(tag) = is.read_raw_tag_or_eof()? {
2555            match tag {
2556                8 => {
2557                    self.id = ::std::option::Option::Some(is.read_int32()?);
2558                },
2559                18 => {
2560                    self.key = ::std::option::Option::Some(is.read_string()?);
2561                },
2562                26 => {
2563                    self.caption = ::std::option::Option::Some(is.read_string()?);
2564                },
2565                tag => {
2566                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2567                },
2568            };
2569        }
2570        ::std::result::Result::Ok(())
2571    }
2572
2573    // Compute sizes of nested messages
2574    #[allow(unused_variables)]
2575    fn compute_size(&self) -> u64 {
2576        let mut my_size = 0;
2577        if let Some(v) = self.id {
2578            my_size += ::protobuf::rt::int32_size(1, v);
2579        }
2580        if let Some(v) = self.key.as_ref() {
2581            my_size += ::protobuf::rt::string_size(2, &v);
2582        }
2583        if let Some(v) = self.caption.as_ref() {
2584            my_size += ::protobuf::rt::string_size(3, &v);
2585        }
2586        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2587        self.special_fields.cached_size().set(my_size as u32);
2588        my_size
2589    }
2590
2591    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
2592        if let Some(v) = self.id {
2593            os.write_int32(1, v)?;
2594        }
2595        if let Some(v) = self.key.as_ref() {
2596            os.write_string(2, v)?;
2597        }
2598        if let Some(v) = self.caption.as_ref() {
2599            os.write_string(3, v)?;
2600        }
2601        os.write_unknown_fields(self.special_fields.unknown_fields())?;
2602        ::std::result::Result::Ok(())
2603    }
2604
2605    fn special_fields(&self) -> &::protobuf::SpecialFields {
2606        &self.special_fields
2607    }
2608
2609    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2610        &mut self.special_fields
2611    }
2612
2613    fn new() -> UnitLaborAttr {
2614        UnitLaborAttr::new()
2615    }
2616
2617    fn clear(&mut self) {
2618        self.id = ::std::option::Option::None;
2619        self.key = ::std::option::Option::None;
2620        self.caption = ::std::option::Option::None;
2621        self.special_fields.clear();
2622    }
2623
2624    fn default_instance() -> &'static UnitLaborAttr {
2625        static instance: UnitLaborAttr = UnitLaborAttr {
2626            id: ::std::option::Option::None,
2627            key: ::std::option::Option::None,
2628            caption: ::std::option::Option::None,
2629            special_fields: ::protobuf::SpecialFields::new(),
2630        };
2631        &instance
2632    }
2633}
2634
2635impl ::protobuf::MessageFull for UnitLaborAttr {
2636    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2637        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2638        descriptor.get(|| file_descriptor().message_by_package_relative_name("UnitLaborAttr").unwrap()).clone()
2639    }
2640}
2641
2642impl ::std::fmt::Display for UnitLaborAttr {
2643    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2644        ::protobuf::text_format::fmt(self, f)
2645    }
2646}
2647
2648impl ::protobuf::reflect::ProtobufValue for UnitLaborAttr {
2649    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2650}
2651
2652// @@protoc_insertion_point(message:dfproto.NameInfo)
2653#[derive(PartialEq,Clone,Default,Debug)]
2654pub struct NameInfo {
2655    // message fields
2656    // @@protoc_insertion_point(field:dfproto.NameInfo.first_name)
2657    pub first_name: ::std::option::Option<::std::string::String>,
2658    // @@protoc_insertion_point(field:dfproto.NameInfo.nickname)
2659    pub nickname: ::std::option::Option<::std::string::String>,
2660    // @@protoc_insertion_point(field:dfproto.NameInfo.language_id)
2661    pub language_id: ::std::option::Option<i32>,
2662    // @@protoc_insertion_point(field:dfproto.NameInfo.last_name)
2663    pub last_name: ::std::option::Option<::std::string::String>,
2664    // @@protoc_insertion_point(field:dfproto.NameInfo.english_name)
2665    pub english_name: ::std::option::Option<::std::string::String>,
2666    // special fields
2667    // @@protoc_insertion_point(special_field:dfproto.NameInfo.special_fields)
2668    pub special_fields: ::protobuf::SpecialFields,
2669}
2670
2671impl<'a> ::std::default::Default for &'a NameInfo {
2672    fn default() -> &'a NameInfo {
2673        <NameInfo as ::protobuf::Message>::default_instance()
2674    }
2675}
2676
2677impl NameInfo {
2678    pub fn new() -> NameInfo {
2679        ::std::default::Default::default()
2680    }
2681
2682    // optional string first_name = 1;
2683
2684    pub fn first_name(&self) -> &str {
2685        match self.first_name.as_ref() {
2686            Some(v) => v,
2687            None => "",
2688        }
2689    }
2690
2691    pub fn clear_first_name(&mut self) {
2692        self.first_name = ::std::option::Option::None;
2693    }
2694
2695    pub fn has_first_name(&self) -> bool {
2696        self.first_name.is_some()
2697    }
2698
2699    // Param is passed by value, moved
2700    pub fn set_first_name(&mut self, v: ::std::string::String) {
2701        self.first_name = ::std::option::Option::Some(v);
2702    }
2703
2704    // Mutable pointer to the field.
2705    // If field is not initialized, it is initialized with default value first.
2706    pub fn mut_first_name(&mut self) -> &mut ::std::string::String {
2707        if self.first_name.is_none() {
2708            self.first_name = ::std::option::Option::Some(::std::string::String::new());
2709        }
2710        self.first_name.as_mut().unwrap()
2711    }
2712
2713    // Take field
2714    pub fn take_first_name(&mut self) -> ::std::string::String {
2715        self.first_name.take().unwrap_or_else(|| ::std::string::String::new())
2716    }
2717
2718    // optional string nickname = 2;
2719
2720    pub fn nickname(&self) -> &str {
2721        match self.nickname.as_ref() {
2722            Some(v) => v,
2723            None => "",
2724        }
2725    }
2726
2727    pub fn clear_nickname(&mut self) {
2728        self.nickname = ::std::option::Option::None;
2729    }
2730
2731    pub fn has_nickname(&self) -> bool {
2732        self.nickname.is_some()
2733    }
2734
2735    // Param is passed by value, moved
2736    pub fn set_nickname(&mut self, v: ::std::string::String) {
2737        self.nickname = ::std::option::Option::Some(v);
2738    }
2739
2740    // Mutable pointer to the field.
2741    // If field is not initialized, it is initialized with default value first.
2742    pub fn mut_nickname(&mut self) -> &mut ::std::string::String {
2743        if self.nickname.is_none() {
2744            self.nickname = ::std::option::Option::Some(::std::string::String::new());
2745        }
2746        self.nickname.as_mut().unwrap()
2747    }
2748
2749    // Take field
2750    pub fn take_nickname(&mut self) -> ::std::string::String {
2751        self.nickname.take().unwrap_or_else(|| ::std::string::String::new())
2752    }
2753
2754    // optional int32 language_id = 3;
2755
2756    pub fn language_id(&self) -> i32 {
2757        self.language_id.unwrap_or(-1i32)
2758    }
2759
2760    pub fn clear_language_id(&mut self) {
2761        self.language_id = ::std::option::Option::None;
2762    }
2763
2764    pub fn has_language_id(&self) -> bool {
2765        self.language_id.is_some()
2766    }
2767
2768    // Param is passed by value, moved
2769    pub fn set_language_id(&mut self, v: i32) {
2770        self.language_id = ::std::option::Option::Some(v);
2771    }
2772
2773    // optional string last_name = 4;
2774
2775    pub fn last_name(&self) -> &str {
2776        match self.last_name.as_ref() {
2777            Some(v) => v,
2778            None => "",
2779        }
2780    }
2781
2782    pub fn clear_last_name(&mut self) {
2783        self.last_name = ::std::option::Option::None;
2784    }
2785
2786    pub fn has_last_name(&self) -> bool {
2787        self.last_name.is_some()
2788    }
2789
2790    // Param is passed by value, moved
2791    pub fn set_last_name(&mut self, v: ::std::string::String) {
2792        self.last_name = ::std::option::Option::Some(v);
2793    }
2794
2795    // Mutable pointer to the field.
2796    // If field is not initialized, it is initialized with default value first.
2797    pub fn mut_last_name(&mut self) -> &mut ::std::string::String {
2798        if self.last_name.is_none() {
2799            self.last_name = ::std::option::Option::Some(::std::string::String::new());
2800        }
2801        self.last_name.as_mut().unwrap()
2802    }
2803
2804    // Take field
2805    pub fn take_last_name(&mut self) -> ::std::string::String {
2806        self.last_name.take().unwrap_or_else(|| ::std::string::String::new())
2807    }
2808
2809    // optional string english_name = 5;
2810
2811    pub fn english_name(&self) -> &str {
2812        match self.english_name.as_ref() {
2813            Some(v) => v,
2814            None => "",
2815        }
2816    }
2817
2818    pub fn clear_english_name(&mut self) {
2819        self.english_name = ::std::option::Option::None;
2820    }
2821
2822    pub fn has_english_name(&self) -> bool {
2823        self.english_name.is_some()
2824    }
2825
2826    // Param is passed by value, moved
2827    pub fn set_english_name(&mut self, v: ::std::string::String) {
2828        self.english_name = ::std::option::Option::Some(v);
2829    }
2830
2831    // Mutable pointer to the field.
2832    // If field is not initialized, it is initialized with default value first.
2833    pub fn mut_english_name(&mut self) -> &mut ::std::string::String {
2834        if self.english_name.is_none() {
2835            self.english_name = ::std::option::Option::Some(::std::string::String::new());
2836        }
2837        self.english_name.as_mut().unwrap()
2838    }
2839
2840    // Take field
2841    pub fn take_english_name(&mut self) -> ::std::string::String {
2842        self.english_name.take().unwrap_or_else(|| ::std::string::String::new())
2843    }
2844
2845    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
2846        let mut fields = ::std::vec::Vec::with_capacity(5);
2847        let mut oneofs = ::std::vec::Vec::with_capacity(0);
2848        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2849            "first_name",
2850            |m: &NameInfo| { &m.first_name },
2851            |m: &mut NameInfo| { &mut m.first_name },
2852        ));
2853        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2854            "nickname",
2855            |m: &NameInfo| { &m.nickname },
2856            |m: &mut NameInfo| { &mut m.nickname },
2857        ));
2858        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2859            "language_id",
2860            |m: &NameInfo| { &m.language_id },
2861            |m: &mut NameInfo| { &mut m.language_id },
2862        ));
2863        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2864            "last_name",
2865            |m: &NameInfo| { &m.last_name },
2866            |m: &mut NameInfo| { &mut m.last_name },
2867        ));
2868        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2869            "english_name",
2870            |m: &NameInfo| { &m.english_name },
2871            |m: &mut NameInfo| { &mut m.english_name },
2872        ));
2873        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<NameInfo>(
2874            "NameInfo",
2875            fields,
2876            oneofs,
2877        )
2878    }
2879}
2880
2881impl ::protobuf::Message for NameInfo {
2882    const NAME: &'static str = "NameInfo";
2883
2884    fn is_initialized(&self) -> bool {
2885        true
2886    }
2887
2888    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
2889        while let Some(tag) = is.read_raw_tag_or_eof()? {
2890            match tag {
2891                10 => {
2892                    self.first_name = ::std::option::Option::Some(is.read_string()?);
2893                },
2894                18 => {
2895                    self.nickname = ::std::option::Option::Some(is.read_string()?);
2896                },
2897                24 => {
2898                    self.language_id = ::std::option::Option::Some(is.read_int32()?);
2899                },
2900                34 => {
2901                    self.last_name = ::std::option::Option::Some(is.read_string()?);
2902                },
2903                42 => {
2904                    self.english_name = ::std::option::Option::Some(is.read_string()?);
2905                },
2906                tag => {
2907                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2908                },
2909            };
2910        }
2911        ::std::result::Result::Ok(())
2912    }
2913
2914    // Compute sizes of nested messages
2915    #[allow(unused_variables)]
2916    fn compute_size(&self) -> u64 {
2917        let mut my_size = 0;
2918        if let Some(v) = self.first_name.as_ref() {
2919            my_size += ::protobuf::rt::string_size(1, &v);
2920        }
2921        if let Some(v) = self.nickname.as_ref() {
2922            my_size += ::protobuf::rt::string_size(2, &v);
2923        }
2924        if let Some(v) = self.language_id {
2925            my_size += ::protobuf::rt::int32_size(3, v);
2926        }
2927        if let Some(v) = self.last_name.as_ref() {
2928            my_size += ::protobuf::rt::string_size(4, &v);
2929        }
2930        if let Some(v) = self.english_name.as_ref() {
2931            my_size += ::protobuf::rt::string_size(5, &v);
2932        }
2933        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2934        self.special_fields.cached_size().set(my_size as u32);
2935        my_size
2936    }
2937
2938    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
2939        if let Some(v) = self.first_name.as_ref() {
2940            os.write_string(1, v)?;
2941        }
2942        if let Some(v) = self.nickname.as_ref() {
2943            os.write_string(2, v)?;
2944        }
2945        if let Some(v) = self.language_id {
2946            os.write_int32(3, v)?;
2947        }
2948        if let Some(v) = self.last_name.as_ref() {
2949            os.write_string(4, v)?;
2950        }
2951        if let Some(v) = self.english_name.as_ref() {
2952            os.write_string(5, v)?;
2953        }
2954        os.write_unknown_fields(self.special_fields.unknown_fields())?;
2955        ::std::result::Result::Ok(())
2956    }
2957
2958    fn special_fields(&self) -> &::protobuf::SpecialFields {
2959        &self.special_fields
2960    }
2961
2962    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2963        &mut self.special_fields
2964    }
2965
2966    fn new() -> NameInfo {
2967        NameInfo::new()
2968    }
2969
2970    fn clear(&mut self) {
2971        self.first_name = ::std::option::Option::None;
2972        self.nickname = ::std::option::Option::None;
2973        self.language_id = ::std::option::Option::None;
2974        self.last_name = ::std::option::Option::None;
2975        self.english_name = ::std::option::Option::None;
2976        self.special_fields.clear();
2977    }
2978
2979    fn default_instance() -> &'static NameInfo {
2980        static instance: NameInfo = NameInfo {
2981            first_name: ::std::option::Option::None,
2982            nickname: ::std::option::Option::None,
2983            language_id: ::std::option::Option::None,
2984            last_name: ::std::option::Option::None,
2985            english_name: ::std::option::Option::None,
2986            special_fields: ::protobuf::SpecialFields::new(),
2987        };
2988        &instance
2989    }
2990}
2991
2992impl ::protobuf::MessageFull for NameInfo {
2993    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2994        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2995        descriptor.get(|| file_descriptor().message_by_package_relative_name("NameInfo").unwrap()).clone()
2996    }
2997}
2998
2999impl ::std::fmt::Display for NameInfo {
3000    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3001        ::protobuf::text_format::fmt(self, f)
3002    }
3003}
3004
3005impl ::protobuf::reflect::ProtobufValue for NameInfo {
3006    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
3007}
3008
3009// @@protoc_insertion_point(message:dfproto.NameTriple)
3010#[derive(PartialEq,Clone,Default,Debug)]
3011pub struct NameTriple {
3012    // message fields
3013    // @@protoc_insertion_point(field:dfproto.NameTriple.normal)
3014    pub normal: ::std::option::Option<::std::string::String>,
3015    // @@protoc_insertion_point(field:dfproto.NameTriple.plural)
3016    pub plural: ::std::option::Option<::std::string::String>,
3017    // @@protoc_insertion_point(field:dfproto.NameTriple.adjective)
3018    pub adjective: ::std::option::Option<::std::string::String>,
3019    // special fields
3020    // @@protoc_insertion_point(special_field:dfproto.NameTriple.special_fields)
3021    pub special_fields: ::protobuf::SpecialFields,
3022}
3023
3024impl<'a> ::std::default::Default for &'a NameTriple {
3025    fn default() -> &'a NameTriple {
3026        <NameTriple as ::protobuf::Message>::default_instance()
3027    }
3028}
3029
3030impl NameTriple {
3031    pub fn new() -> NameTriple {
3032        ::std::default::Default::default()
3033    }
3034
3035    // required string normal = 1;
3036
3037    pub fn normal(&self) -> &str {
3038        match self.normal.as_ref() {
3039            Some(v) => v,
3040            None => "",
3041        }
3042    }
3043
3044    pub fn clear_normal(&mut self) {
3045        self.normal = ::std::option::Option::None;
3046    }
3047
3048    pub fn has_normal(&self) -> bool {
3049        self.normal.is_some()
3050    }
3051
3052    // Param is passed by value, moved
3053    pub fn set_normal(&mut self, v: ::std::string::String) {
3054        self.normal = ::std::option::Option::Some(v);
3055    }
3056
3057    // Mutable pointer to the field.
3058    // If field is not initialized, it is initialized with default value first.
3059    pub fn mut_normal(&mut self) -> &mut ::std::string::String {
3060        if self.normal.is_none() {
3061            self.normal = ::std::option::Option::Some(::std::string::String::new());
3062        }
3063        self.normal.as_mut().unwrap()
3064    }
3065
3066    // Take field
3067    pub fn take_normal(&mut self) -> ::std::string::String {
3068        self.normal.take().unwrap_or_else(|| ::std::string::String::new())
3069    }
3070
3071    // optional string plural = 2;
3072
3073    pub fn plural(&self) -> &str {
3074        match self.plural.as_ref() {
3075            Some(v) => v,
3076            None => "",
3077        }
3078    }
3079
3080    pub fn clear_plural(&mut self) {
3081        self.plural = ::std::option::Option::None;
3082    }
3083
3084    pub fn has_plural(&self) -> bool {
3085        self.plural.is_some()
3086    }
3087
3088    // Param is passed by value, moved
3089    pub fn set_plural(&mut self, v: ::std::string::String) {
3090        self.plural = ::std::option::Option::Some(v);
3091    }
3092
3093    // Mutable pointer to the field.
3094    // If field is not initialized, it is initialized with default value first.
3095    pub fn mut_plural(&mut self) -> &mut ::std::string::String {
3096        if self.plural.is_none() {
3097            self.plural = ::std::option::Option::Some(::std::string::String::new());
3098        }
3099        self.plural.as_mut().unwrap()
3100    }
3101
3102    // Take field
3103    pub fn take_plural(&mut self) -> ::std::string::String {
3104        self.plural.take().unwrap_or_else(|| ::std::string::String::new())
3105    }
3106
3107    // optional string adjective = 3;
3108
3109    pub fn adjective(&self) -> &str {
3110        match self.adjective.as_ref() {
3111            Some(v) => v,
3112            None => "",
3113        }
3114    }
3115
3116    pub fn clear_adjective(&mut self) {
3117        self.adjective = ::std::option::Option::None;
3118    }
3119
3120    pub fn has_adjective(&self) -> bool {
3121        self.adjective.is_some()
3122    }
3123
3124    // Param is passed by value, moved
3125    pub fn set_adjective(&mut self, v: ::std::string::String) {
3126        self.adjective = ::std::option::Option::Some(v);
3127    }
3128
3129    // Mutable pointer to the field.
3130    // If field is not initialized, it is initialized with default value first.
3131    pub fn mut_adjective(&mut self) -> &mut ::std::string::String {
3132        if self.adjective.is_none() {
3133            self.adjective = ::std::option::Option::Some(::std::string::String::new());
3134        }
3135        self.adjective.as_mut().unwrap()
3136    }
3137
3138    // Take field
3139    pub fn take_adjective(&mut self) -> ::std::string::String {
3140        self.adjective.take().unwrap_or_else(|| ::std::string::String::new())
3141    }
3142
3143    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
3144        let mut fields = ::std::vec::Vec::with_capacity(3);
3145        let mut oneofs = ::std::vec::Vec::with_capacity(0);
3146        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3147            "normal",
3148            |m: &NameTriple| { &m.normal },
3149            |m: &mut NameTriple| { &mut m.normal },
3150        ));
3151        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3152            "plural",
3153            |m: &NameTriple| { &m.plural },
3154            |m: &mut NameTriple| { &mut m.plural },
3155        ));
3156        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3157            "adjective",
3158            |m: &NameTriple| { &m.adjective },
3159            |m: &mut NameTriple| { &mut m.adjective },
3160        ));
3161        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<NameTriple>(
3162            "NameTriple",
3163            fields,
3164            oneofs,
3165        )
3166    }
3167}
3168
3169impl ::protobuf::Message for NameTriple {
3170    const NAME: &'static str = "NameTriple";
3171
3172    fn is_initialized(&self) -> bool {
3173        if self.normal.is_none() {
3174            return false;
3175        }
3176        true
3177    }
3178
3179    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
3180        while let Some(tag) = is.read_raw_tag_or_eof()? {
3181            match tag {
3182                10 => {
3183                    self.normal = ::std::option::Option::Some(is.read_string()?);
3184                },
3185                18 => {
3186                    self.plural = ::std::option::Option::Some(is.read_string()?);
3187                },
3188                26 => {
3189                    self.adjective = ::std::option::Option::Some(is.read_string()?);
3190                },
3191                tag => {
3192                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3193                },
3194            };
3195        }
3196        ::std::result::Result::Ok(())
3197    }
3198
3199    // Compute sizes of nested messages
3200    #[allow(unused_variables)]
3201    fn compute_size(&self) -> u64 {
3202        let mut my_size = 0;
3203        if let Some(v) = self.normal.as_ref() {
3204            my_size += ::protobuf::rt::string_size(1, &v);
3205        }
3206        if let Some(v) = self.plural.as_ref() {
3207            my_size += ::protobuf::rt::string_size(2, &v);
3208        }
3209        if let Some(v) = self.adjective.as_ref() {
3210            my_size += ::protobuf::rt::string_size(3, &v);
3211        }
3212        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3213        self.special_fields.cached_size().set(my_size as u32);
3214        my_size
3215    }
3216
3217    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
3218        if let Some(v) = self.normal.as_ref() {
3219            os.write_string(1, v)?;
3220        }
3221        if let Some(v) = self.plural.as_ref() {
3222            os.write_string(2, v)?;
3223        }
3224        if let Some(v) = self.adjective.as_ref() {
3225            os.write_string(3, v)?;
3226        }
3227        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3228        ::std::result::Result::Ok(())
3229    }
3230
3231    fn special_fields(&self) -> &::protobuf::SpecialFields {
3232        &self.special_fields
3233    }
3234
3235    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
3236        &mut self.special_fields
3237    }
3238
3239    fn new() -> NameTriple {
3240        NameTriple::new()
3241    }
3242
3243    fn clear(&mut self) {
3244        self.normal = ::std::option::Option::None;
3245        self.plural = ::std::option::Option::None;
3246        self.adjective = ::std::option::Option::None;
3247        self.special_fields.clear();
3248    }
3249
3250    fn default_instance() -> &'static NameTriple {
3251        static instance: NameTriple = NameTriple {
3252            normal: ::std::option::Option::None,
3253            plural: ::std::option::Option::None,
3254            adjective: ::std::option::Option::None,
3255            special_fields: ::protobuf::SpecialFields::new(),
3256        };
3257        &instance
3258    }
3259}
3260
3261impl ::protobuf::MessageFull for NameTriple {
3262    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
3263        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
3264        descriptor.get(|| file_descriptor().message_by_package_relative_name("NameTriple").unwrap()).clone()
3265    }
3266}
3267
3268impl ::std::fmt::Display for NameTriple {
3269    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3270        ::protobuf::text_format::fmt(self, f)
3271    }
3272}
3273
3274impl ::protobuf::reflect::ProtobufValue for NameTriple {
3275    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
3276}
3277
3278// @@protoc_insertion_point(message:dfproto.UnitCurseInfo)
3279#[derive(PartialEq,Clone,Default,Debug)]
3280pub struct UnitCurseInfo {
3281    // message fields
3282    // @@protoc_insertion_point(field:dfproto.UnitCurseInfo.add_tags1)
3283    pub add_tags1: ::std::option::Option<u32>,
3284    // @@protoc_insertion_point(field:dfproto.UnitCurseInfo.rem_tags1)
3285    pub rem_tags1: ::std::option::Option<u32>,
3286    // @@protoc_insertion_point(field:dfproto.UnitCurseInfo.add_tags2)
3287    pub add_tags2: ::std::option::Option<u32>,
3288    // @@protoc_insertion_point(field:dfproto.UnitCurseInfo.rem_tags2)
3289    pub rem_tags2: ::std::option::Option<u32>,
3290    // @@protoc_insertion_point(field:dfproto.UnitCurseInfo.name)
3291    pub name: ::protobuf::MessageField<NameTriple>,
3292    // special fields
3293    // @@protoc_insertion_point(special_field:dfproto.UnitCurseInfo.special_fields)
3294    pub special_fields: ::protobuf::SpecialFields,
3295}
3296
3297impl<'a> ::std::default::Default for &'a UnitCurseInfo {
3298    fn default() -> &'a UnitCurseInfo {
3299        <UnitCurseInfo as ::protobuf::Message>::default_instance()
3300    }
3301}
3302
3303impl UnitCurseInfo {
3304    pub fn new() -> UnitCurseInfo {
3305        ::std::default::Default::default()
3306    }
3307
3308    // required fixed32 add_tags1 = 1;
3309
3310    pub fn add_tags1(&self) -> u32 {
3311        self.add_tags1.unwrap_or(0)
3312    }
3313
3314    pub fn clear_add_tags1(&mut self) {
3315        self.add_tags1 = ::std::option::Option::None;
3316    }
3317
3318    pub fn has_add_tags1(&self) -> bool {
3319        self.add_tags1.is_some()
3320    }
3321
3322    // Param is passed by value, moved
3323    pub fn set_add_tags1(&mut self, v: u32) {
3324        self.add_tags1 = ::std::option::Option::Some(v);
3325    }
3326
3327    // required fixed32 rem_tags1 = 2;
3328
3329    pub fn rem_tags1(&self) -> u32 {
3330        self.rem_tags1.unwrap_or(0)
3331    }
3332
3333    pub fn clear_rem_tags1(&mut self) {
3334        self.rem_tags1 = ::std::option::Option::None;
3335    }
3336
3337    pub fn has_rem_tags1(&self) -> bool {
3338        self.rem_tags1.is_some()
3339    }
3340
3341    // Param is passed by value, moved
3342    pub fn set_rem_tags1(&mut self, v: u32) {
3343        self.rem_tags1 = ::std::option::Option::Some(v);
3344    }
3345
3346    // required fixed32 add_tags2 = 3;
3347
3348    pub fn add_tags2(&self) -> u32 {
3349        self.add_tags2.unwrap_or(0)
3350    }
3351
3352    pub fn clear_add_tags2(&mut self) {
3353        self.add_tags2 = ::std::option::Option::None;
3354    }
3355
3356    pub fn has_add_tags2(&self) -> bool {
3357        self.add_tags2.is_some()
3358    }
3359
3360    // Param is passed by value, moved
3361    pub fn set_add_tags2(&mut self, v: u32) {
3362        self.add_tags2 = ::std::option::Option::Some(v);
3363    }
3364
3365    // required fixed32 rem_tags2 = 4;
3366
3367    pub fn rem_tags2(&self) -> u32 {
3368        self.rem_tags2.unwrap_or(0)
3369    }
3370
3371    pub fn clear_rem_tags2(&mut self) {
3372        self.rem_tags2 = ::std::option::Option::None;
3373    }
3374
3375    pub fn has_rem_tags2(&self) -> bool {
3376        self.rem_tags2.is_some()
3377    }
3378
3379    // Param is passed by value, moved
3380    pub fn set_rem_tags2(&mut self, v: u32) {
3381        self.rem_tags2 = ::std::option::Option::Some(v);
3382    }
3383
3384    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
3385        let mut fields = ::std::vec::Vec::with_capacity(5);
3386        let mut oneofs = ::std::vec::Vec::with_capacity(0);
3387        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3388            "add_tags1",
3389            |m: &UnitCurseInfo| { &m.add_tags1 },
3390            |m: &mut UnitCurseInfo| { &mut m.add_tags1 },
3391        ));
3392        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3393            "rem_tags1",
3394            |m: &UnitCurseInfo| { &m.rem_tags1 },
3395            |m: &mut UnitCurseInfo| { &mut m.rem_tags1 },
3396        ));
3397        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3398            "add_tags2",
3399            |m: &UnitCurseInfo| { &m.add_tags2 },
3400            |m: &mut UnitCurseInfo| { &mut m.add_tags2 },
3401        ));
3402        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3403            "rem_tags2",
3404            |m: &UnitCurseInfo| { &m.rem_tags2 },
3405            |m: &mut UnitCurseInfo| { &mut m.rem_tags2 },
3406        ));
3407        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, NameTriple>(
3408            "name",
3409            |m: &UnitCurseInfo| { &m.name },
3410            |m: &mut UnitCurseInfo| { &mut m.name },
3411        ));
3412        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UnitCurseInfo>(
3413            "UnitCurseInfo",
3414            fields,
3415            oneofs,
3416        )
3417    }
3418}
3419
3420impl ::protobuf::Message for UnitCurseInfo {
3421    const NAME: &'static str = "UnitCurseInfo";
3422
3423    fn is_initialized(&self) -> bool {
3424        if self.add_tags1.is_none() {
3425            return false;
3426        }
3427        if self.rem_tags1.is_none() {
3428            return false;
3429        }
3430        if self.add_tags2.is_none() {
3431            return false;
3432        }
3433        if self.rem_tags2.is_none() {
3434            return false;
3435        }
3436        for v in &self.name {
3437            if !v.is_initialized() {
3438                return false;
3439            }
3440        };
3441        true
3442    }
3443
3444    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
3445        while let Some(tag) = is.read_raw_tag_or_eof()? {
3446            match tag {
3447                13 => {
3448                    self.add_tags1 = ::std::option::Option::Some(is.read_fixed32()?);
3449                },
3450                21 => {
3451                    self.rem_tags1 = ::std::option::Option::Some(is.read_fixed32()?);
3452                },
3453                29 => {
3454                    self.add_tags2 = ::std::option::Option::Some(is.read_fixed32()?);
3455                },
3456                37 => {
3457                    self.rem_tags2 = ::std::option::Option::Some(is.read_fixed32()?);
3458                },
3459                42 => {
3460                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.name)?;
3461                },
3462                tag => {
3463                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3464                },
3465            };
3466        }
3467        ::std::result::Result::Ok(())
3468    }
3469
3470    // Compute sizes of nested messages
3471    #[allow(unused_variables)]
3472    fn compute_size(&self) -> u64 {
3473        let mut my_size = 0;
3474        if let Some(v) = self.add_tags1 {
3475            my_size += 1 + 4;
3476        }
3477        if let Some(v) = self.rem_tags1 {
3478            my_size += 1 + 4;
3479        }
3480        if let Some(v) = self.add_tags2 {
3481            my_size += 1 + 4;
3482        }
3483        if let Some(v) = self.rem_tags2 {
3484            my_size += 1 + 4;
3485        }
3486        if let Some(v) = self.name.as_ref() {
3487            let len = v.compute_size();
3488            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
3489        }
3490        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3491        self.special_fields.cached_size().set(my_size as u32);
3492        my_size
3493    }
3494
3495    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
3496        if let Some(v) = self.add_tags1 {
3497            os.write_fixed32(1, v)?;
3498        }
3499        if let Some(v) = self.rem_tags1 {
3500            os.write_fixed32(2, v)?;
3501        }
3502        if let Some(v) = self.add_tags2 {
3503            os.write_fixed32(3, v)?;
3504        }
3505        if let Some(v) = self.rem_tags2 {
3506            os.write_fixed32(4, v)?;
3507        }
3508        if let Some(v) = self.name.as_ref() {
3509            ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
3510        }
3511        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3512        ::std::result::Result::Ok(())
3513    }
3514
3515    fn special_fields(&self) -> &::protobuf::SpecialFields {
3516        &self.special_fields
3517    }
3518
3519    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
3520        &mut self.special_fields
3521    }
3522
3523    fn new() -> UnitCurseInfo {
3524        UnitCurseInfo::new()
3525    }
3526
3527    fn clear(&mut self) {
3528        self.add_tags1 = ::std::option::Option::None;
3529        self.rem_tags1 = ::std::option::Option::None;
3530        self.add_tags2 = ::std::option::Option::None;
3531        self.rem_tags2 = ::std::option::Option::None;
3532        self.name.clear();
3533        self.special_fields.clear();
3534    }
3535
3536    fn default_instance() -> &'static UnitCurseInfo {
3537        static instance: UnitCurseInfo = UnitCurseInfo {
3538            add_tags1: ::std::option::Option::None,
3539            rem_tags1: ::std::option::Option::None,
3540            add_tags2: ::std::option::Option::None,
3541            rem_tags2: ::std::option::Option::None,
3542            name: ::protobuf::MessageField::none(),
3543            special_fields: ::protobuf::SpecialFields::new(),
3544        };
3545        &instance
3546    }
3547}
3548
3549impl ::protobuf::MessageFull for UnitCurseInfo {
3550    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
3551        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
3552        descriptor.get(|| file_descriptor().message_by_package_relative_name("UnitCurseInfo").unwrap()).clone()
3553    }
3554}
3555
3556impl ::std::fmt::Display for UnitCurseInfo {
3557    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3558        ::protobuf::text_format::fmt(self, f)
3559    }
3560}
3561
3562impl ::protobuf::reflect::ProtobufValue for UnitCurseInfo {
3563    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
3564}
3565
3566// @@protoc_insertion_point(message:dfproto.SkillInfo)
3567#[derive(PartialEq,Clone,Default,Debug)]
3568pub struct SkillInfo {
3569    // message fields
3570    // @@protoc_insertion_point(field:dfproto.SkillInfo.id)
3571    pub id: ::std::option::Option<i32>,
3572    // @@protoc_insertion_point(field:dfproto.SkillInfo.level)
3573    pub level: ::std::option::Option<i32>,
3574    // @@protoc_insertion_point(field:dfproto.SkillInfo.experience)
3575    pub experience: ::std::option::Option<i32>,
3576    // special fields
3577    // @@protoc_insertion_point(special_field:dfproto.SkillInfo.special_fields)
3578    pub special_fields: ::protobuf::SpecialFields,
3579}
3580
3581impl<'a> ::std::default::Default for &'a SkillInfo {
3582    fn default() -> &'a SkillInfo {
3583        <SkillInfo as ::protobuf::Message>::default_instance()
3584    }
3585}
3586
3587impl SkillInfo {
3588    pub fn new() -> SkillInfo {
3589        ::std::default::Default::default()
3590    }
3591
3592    // required int32 id = 1;
3593
3594    pub fn id(&self) -> i32 {
3595        self.id.unwrap_or(0)
3596    }
3597
3598    pub fn clear_id(&mut self) {
3599        self.id = ::std::option::Option::None;
3600    }
3601
3602    pub fn has_id(&self) -> bool {
3603        self.id.is_some()
3604    }
3605
3606    // Param is passed by value, moved
3607    pub fn set_id(&mut self, v: i32) {
3608        self.id = ::std::option::Option::Some(v);
3609    }
3610
3611    // required int32 level = 2;
3612
3613    pub fn level(&self) -> i32 {
3614        self.level.unwrap_or(0)
3615    }
3616
3617    pub fn clear_level(&mut self) {
3618        self.level = ::std::option::Option::None;
3619    }
3620
3621    pub fn has_level(&self) -> bool {
3622        self.level.is_some()
3623    }
3624
3625    // Param is passed by value, moved
3626    pub fn set_level(&mut self, v: i32) {
3627        self.level = ::std::option::Option::Some(v);
3628    }
3629
3630    // required int32 experience = 3;
3631
3632    pub fn experience(&self) -> i32 {
3633        self.experience.unwrap_or(0)
3634    }
3635
3636    pub fn clear_experience(&mut self) {
3637        self.experience = ::std::option::Option::None;
3638    }
3639
3640    pub fn has_experience(&self) -> bool {
3641        self.experience.is_some()
3642    }
3643
3644    // Param is passed by value, moved
3645    pub fn set_experience(&mut self, v: i32) {
3646        self.experience = ::std::option::Option::Some(v);
3647    }
3648
3649    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
3650        let mut fields = ::std::vec::Vec::with_capacity(3);
3651        let mut oneofs = ::std::vec::Vec::with_capacity(0);
3652        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3653            "id",
3654            |m: &SkillInfo| { &m.id },
3655            |m: &mut SkillInfo| { &mut m.id },
3656        ));
3657        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3658            "level",
3659            |m: &SkillInfo| { &m.level },
3660            |m: &mut SkillInfo| { &mut m.level },
3661        ));
3662        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3663            "experience",
3664            |m: &SkillInfo| { &m.experience },
3665            |m: &mut SkillInfo| { &mut m.experience },
3666        ));
3667        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SkillInfo>(
3668            "SkillInfo",
3669            fields,
3670            oneofs,
3671        )
3672    }
3673}
3674
3675impl ::protobuf::Message for SkillInfo {
3676    const NAME: &'static str = "SkillInfo";
3677
3678    fn is_initialized(&self) -> bool {
3679        if self.id.is_none() {
3680            return false;
3681        }
3682        if self.level.is_none() {
3683            return false;
3684        }
3685        if self.experience.is_none() {
3686            return false;
3687        }
3688        true
3689    }
3690
3691    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
3692        while let Some(tag) = is.read_raw_tag_or_eof()? {
3693            match tag {
3694                8 => {
3695                    self.id = ::std::option::Option::Some(is.read_int32()?);
3696                },
3697                16 => {
3698                    self.level = ::std::option::Option::Some(is.read_int32()?);
3699                },
3700                24 => {
3701                    self.experience = ::std::option::Option::Some(is.read_int32()?);
3702                },
3703                tag => {
3704                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3705                },
3706            };
3707        }
3708        ::std::result::Result::Ok(())
3709    }
3710
3711    // Compute sizes of nested messages
3712    #[allow(unused_variables)]
3713    fn compute_size(&self) -> u64 {
3714        let mut my_size = 0;
3715        if let Some(v) = self.id {
3716            my_size += ::protobuf::rt::int32_size(1, v);
3717        }
3718        if let Some(v) = self.level {
3719            my_size += ::protobuf::rt::int32_size(2, v);
3720        }
3721        if let Some(v) = self.experience {
3722            my_size += ::protobuf::rt::int32_size(3, v);
3723        }
3724        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3725        self.special_fields.cached_size().set(my_size as u32);
3726        my_size
3727    }
3728
3729    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
3730        if let Some(v) = self.id {
3731            os.write_int32(1, v)?;
3732        }
3733        if let Some(v) = self.level {
3734            os.write_int32(2, v)?;
3735        }
3736        if let Some(v) = self.experience {
3737            os.write_int32(3, v)?;
3738        }
3739        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3740        ::std::result::Result::Ok(())
3741    }
3742
3743    fn special_fields(&self) -> &::protobuf::SpecialFields {
3744        &self.special_fields
3745    }
3746
3747    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
3748        &mut self.special_fields
3749    }
3750
3751    fn new() -> SkillInfo {
3752        SkillInfo::new()
3753    }
3754
3755    fn clear(&mut self) {
3756        self.id = ::std::option::Option::None;
3757        self.level = ::std::option::Option::None;
3758        self.experience = ::std::option::Option::None;
3759        self.special_fields.clear();
3760    }
3761
3762    fn default_instance() -> &'static SkillInfo {
3763        static instance: SkillInfo = SkillInfo {
3764            id: ::std::option::Option::None,
3765            level: ::std::option::Option::None,
3766            experience: ::std::option::Option::None,
3767            special_fields: ::protobuf::SpecialFields::new(),
3768        };
3769        &instance
3770    }
3771}
3772
3773impl ::protobuf::MessageFull for SkillInfo {
3774    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
3775        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
3776        descriptor.get(|| file_descriptor().message_by_package_relative_name("SkillInfo").unwrap()).clone()
3777    }
3778}
3779
3780impl ::std::fmt::Display for SkillInfo {
3781    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3782        ::protobuf::text_format::fmt(self, f)
3783    }
3784}
3785
3786impl ::protobuf::reflect::ProtobufValue for SkillInfo {
3787    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
3788}
3789
3790// @@protoc_insertion_point(message:dfproto.UnitMiscTrait)
3791#[derive(PartialEq,Clone,Default,Debug)]
3792pub struct UnitMiscTrait {
3793    // message fields
3794    // @@protoc_insertion_point(field:dfproto.UnitMiscTrait.id)
3795    pub id: ::std::option::Option<i32>,
3796    // @@protoc_insertion_point(field:dfproto.UnitMiscTrait.value)
3797    pub value: ::std::option::Option<i32>,
3798    // special fields
3799    // @@protoc_insertion_point(special_field:dfproto.UnitMiscTrait.special_fields)
3800    pub special_fields: ::protobuf::SpecialFields,
3801}
3802
3803impl<'a> ::std::default::Default for &'a UnitMiscTrait {
3804    fn default() -> &'a UnitMiscTrait {
3805        <UnitMiscTrait as ::protobuf::Message>::default_instance()
3806    }
3807}
3808
3809impl UnitMiscTrait {
3810    pub fn new() -> UnitMiscTrait {
3811        ::std::default::Default::default()
3812    }
3813
3814    // required int32 id = 1;
3815
3816    pub fn id(&self) -> i32 {
3817        self.id.unwrap_or(0)
3818    }
3819
3820    pub fn clear_id(&mut self) {
3821        self.id = ::std::option::Option::None;
3822    }
3823
3824    pub fn has_id(&self) -> bool {
3825        self.id.is_some()
3826    }
3827
3828    // Param is passed by value, moved
3829    pub fn set_id(&mut self, v: i32) {
3830        self.id = ::std::option::Option::Some(v);
3831    }
3832
3833    // required int32 value = 2;
3834
3835    pub fn value(&self) -> i32 {
3836        self.value.unwrap_or(0)
3837    }
3838
3839    pub fn clear_value(&mut self) {
3840        self.value = ::std::option::Option::None;
3841    }
3842
3843    pub fn has_value(&self) -> bool {
3844        self.value.is_some()
3845    }
3846
3847    // Param is passed by value, moved
3848    pub fn set_value(&mut self, v: i32) {
3849        self.value = ::std::option::Option::Some(v);
3850    }
3851
3852    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
3853        let mut fields = ::std::vec::Vec::with_capacity(2);
3854        let mut oneofs = ::std::vec::Vec::with_capacity(0);
3855        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3856            "id",
3857            |m: &UnitMiscTrait| { &m.id },
3858            |m: &mut UnitMiscTrait| { &mut m.id },
3859        ));
3860        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3861            "value",
3862            |m: &UnitMiscTrait| { &m.value },
3863            |m: &mut UnitMiscTrait| { &mut m.value },
3864        ));
3865        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UnitMiscTrait>(
3866            "UnitMiscTrait",
3867            fields,
3868            oneofs,
3869        )
3870    }
3871}
3872
3873impl ::protobuf::Message for UnitMiscTrait {
3874    const NAME: &'static str = "UnitMiscTrait";
3875
3876    fn is_initialized(&self) -> bool {
3877        if self.id.is_none() {
3878            return false;
3879        }
3880        if self.value.is_none() {
3881            return false;
3882        }
3883        true
3884    }
3885
3886    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
3887        while let Some(tag) = is.read_raw_tag_or_eof()? {
3888            match tag {
3889                8 => {
3890                    self.id = ::std::option::Option::Some(is.read_int32()?);
3891                },
3892                16 => {
3893                    self.value = ::std::option::Option::Some(is.read_int32()?);
3894                },
3895                tag => {
3896                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3897                },
3898            };
3899        }
3900        ::std::result::Result::Ok(())
3901    }
3902
3903    // Compute sizes of nested messages
3904    #[allow(unused_variables)]
3905    fn compute_size(&self) -> u64 {
3906        let mut my_size = 0;
3907        if let Some(v) = self.id {
3908            my_size += ::protobuf::rt::int32_size(1, v);
3909        }
3910        if let Some(v) = self.value {
3911            my_size += ::protobuf::rt::int32_size(2, v);
3912        }
3913        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3914        self.special_fields.cached_size().set(my_size as u32);
3915        my_size
3916    }
3917
3918    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
3919        if let Some(v) = self.id {
3920            os.write_int32(1, v)?;
3921        }
3922        if let Some(v) = self.value {
3923            os.write_int32(2, v)?;
3924        }
3925        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3926        ::std::result::Result::Ok(())
3927    }
3928
3929    fn special_fields(&self) -> &::protobuf::SpecialFields {
3930        &self.special_fields
3931    }
3932
3933    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
3934        &mut self.special_fields
3935    }
3936
3937    fn new() -> UnitMiscTrait {
3938        UnitMiscTrait::new()
3939    }
3940
3941    fn clear(&mut self) {
3942        self.id = ::std::option::Option::None;
3943        self.value = ::std::option::Option::None;
3944        self.special_fields.clear();
3945    }
3946
3947    fn default_instance() -> &'static UnitMiscTrait {
3948        static instance: UnitMiscTrait = UnitMiscTrait {
3949            id: ::std::option::Option::None,
3950            value: ::std::option::Option::None,
3951            special_fields: ::protobuf::SpecialFields::new(),
3952        };
3953        &instance
3954    }
3955}
3956
3957impl ::protobuf::MessageFull for UnitMiscTrait {
3958    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
3959        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
3960        descriptor.get(|| file_descriptor().message_by_package_relative_name("UnitMiscTrait").unwrap()).clone()
3961    }
3962}
3963
3964impl ::std::fmt::Display for UnitMiscTrait {
3965    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3966        ::protobuf::text_format::fmt(self, f)
3967    }
3968}
3969
3970impl ::protobuf::reflect::ProtobufValue for UnitMiscTrait {
3971    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
3972}
3973
3974// @@protoc_insertion_point(message:dfproto.BasicUnitInfo)
3975#[derive(PartialEq,Clone,Default,Debug)]
3976pub struct BasicUnitInfo {
3977    // message fields
3978    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.unit_id)
3979    pub unit_id: ::std::option::Option<i32>,
3980    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.pos_x)
3981    pub pos_x: ::std::option::Option<i32>,
3982    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.pos_y)
3983    pub pos_y: ::std::option::Option<i32>,
3984    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.pos_z)
3985    pub pos_z: ::std::option::Option<i32>,
3986    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.name)
3987    pub name: ::protobuf::MessageField<NameInfo>,
3988    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.flags1)
3989    pub flags1: ::std::option::Option<u32>,
3990    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.flags2)
3991    pub flags2: ::std::option::Option<u32>,
3992    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.flags3)
3993    pub flags3: ::std::option::Option<u32>,
3994    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.race)
3995    pub race: ::std::option::Option<i32>,
3996    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.caste)
3997    pub caste: ::std::option::Option<i32>,
3998    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.gender)
3999    pub gender: ::std::option::Option<i32>,
4000    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.civ_id)
4001    pub civ_id: ::std::option::Option<i32>,
4002    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.histfig_id)
4003    pub histfig_id: ::std::option::Option<i32>,
4004    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.death_id)
4005    pub death_id: ::std::option::Option<i32>,
4006    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.death_flags)
4007    pub death_flags: ::std::option::Option<u32>,
4008    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.squad_id)
4009    pub squad_id: ::std::option::Option<i32>,
4010    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.squad_position)
4011    pub squad_position: ::std::option::Option<i32>,
4012    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.profession)
4013    pub profession: ::std::option::Option<i32>,
4014    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.custom_profession)
4015    pub custom_profession: ::std::option::Option<::std::string::String>,
4016    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.labors)
4017    pub labors: ::std::vec::Vec<i32>,
4018    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.skills)
4019    pub skills: ::std::vec::Vec<SkillInfo>,
4020    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.misc_traits)
4021    pub misc_traits: ::std::vec::Vec<UnitMiscTrait>,
4022    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.curse)
4023    pub curse: ::protobuf::MessageField<UnitCurseInfo>,
4024    // @@protoc_insertion_point(field:dfproto.BasicUnitInfo.burrows)
4025    pub burrows: ::std::vec::Vec<i32>,
4026    // special fields
4027    // @@protoc_insertion_point(special_field:dfproto.BasicUnitInfo.special_fields)
4028    pub special_fields: ::protobuf::SpecialFields,
4029}
4030
4031impl<'a> ::std::default::Default for &'a BasicUnitInfo {
4032    fn default() -> &'a BasicUnitInfo {
4033        <BasicUnitInfo as ::protobuf::Message>::default_instance()
4034    }
4035}
4036
4037impl BasicUnitInfo {
4038    pub fn new() -> BasicUnitInfo {
4039        ::std::default::Default::default()
4040    }
4041
4042    // required int32 unit_id = 1;
4043
4044    pub fn unit_id(&self) -> i32 {
4045        self.unit_id.unwrap_or(0)
4046    }
4047
4048    pub fn clear_unit_id(&mut self) {
4049        self.unit_id = ::std::option::Option::None;
4050    }
4051
4052    pub fn has_unit_id(&self) -> bool {
4053        self.unit_id.is_some()
4054    }
4055
4056    // Param is passed by value, moved
4057    pub fn set_unit_id(&mut self, v: i32) {
4058        self.unit_id = ::std::option::Option::Some(v);
4059    }
4060
4061    // required int32 pos_x = 13;
4062
4063    pub fn pos_x(&self) -> i32 {
4064        self.pos_x.unwrap_or(0)
4065    }
4066
4067    pub fn clear_pos_x(&mut self) {
4068        self.pos_x = ::std::option::Option::None;
4069    }
4070
4071    pub fn has_pos_x(&self) -> bool {
4072        self.pos_x.is_some()
4073    }
4074
4075    // Param is passed by value, moved
4076    pub fn set_pos_x(&mut self, v: i32) {
4077        self.pos_x = ::std::option::Option::Some(v);
4078    }
4079
4080    // required int32 pos_y = 14;
4081
4082    pub fn pos_y(&self) -> i32 {
4083        self.pos_y.unwrap_or(0)
4084    }
4085
4086    pub fn clear_pos_y(&mut self) {
4087        self.pos_y = ::std::option::Option::None;
4088    }
4089
4090    pub fn has_pos_y(&self) -> bool {
4091        self.pos_y.is_some()
4092    }
4093
4094    // Param is passed by value, moved
4095    pub fn set_pos_y(&mut self, v: i32) {
4096        self.pos_y = ::std::option::Option::Some(v);
4097    }
4098
4099    // required int32 pos_z = 15;
4100
4101    pub fn pos_z(&self) -> i32 {
4102        self.pos_z.unwrap_or(0)
4103    }
4104
4105    pub fn clear_pos_z(&mut self) {
4106        self.pos_z = ::std::option::Option::None;
4107    }
4108
4109    pub fn has_pos_z(&self) -> bool {
4110        self.pos_z.is_some()
4111    }
4112
4113    // Param is passed by value, moved
4114    pub fn set_pos_z(&mut self, v: i32) {
4115        self.pos_z = ::std::option::Option::Some(v);
4116    }
4117
4118    // required fixed32 flags1 = 3;
4119
4120    pub fn flags1(&self) -> u32 {
4121        self.flags1.unwrap_or(0)
4122    }
4123
4124    pub fn clear_flags1(&mut self) {
4125        self.flags1 = ::std::option::Option::None;
4126    }
4127
4128    pub fn has_flags1(&self) -> bool {
4129        self.flags1.is_some()
4130    }
4131
4132    // Param is passed by value, moved
4133    pub fn set_flags1(&mut self, v: u32) {
4134        self.flags1 = ::std::option::Option::Some(v);
4135    }
4136
4137    // required fixed32 flags2 = 4;
4138
4139    pub fn flags2(&self) -> u32 {
4140        self.flags2.unwrap_or(0)
4141    }
4142
4143    pub fn clear_flags2(&mut self) {
4144        self.flags2 = ::std::option::Option::None;
4145    }
4146
4147    pub fn has_flags2(&self) -> bool {
4148        self.flags2.is_some()
4149    }
4150
4151    // Param is passed by value, moved
4152    pub fn set_flags2(&mut self, v: u32) {
4153        self.flags2 = ::std::option::Option::Some(v);
4154    }
4155
4156    // required fixed32 flags3 = 5;
4157
4158    pub fn flags3(&self) -> u32 {
4159        self.flags3.unwrap_or(0)
4160    }
4161
4162    pub fn clear_flags3(&mut self) {
4163        self.flags3 = ::std::option::Option::None;
4164    }
4165
4166    pub fn has_flags3(&self) -> bool {
4167        self.flags3.is_some()
4168    }
4169
4170    // Param is passed by value, moved
4171    pub fn set_flags3(&mut self, v: u32) {
4172        self.flags3 = ::std::option::Option::Some(v);
4173    }
4174
4175    // required int32 race = 6;
4176
4177    pub fn race(&self) -> i32 {
4178        self.race.unwrap_or(0)
4179    }
4180
4181    pub fn clear_race(&mut self) {
4182        self.race = ::std::option::Option::None;
4183    }
4184
4185    pub fn has_race(&self) -> bool {
4186        self.race.is_some()
4187    }
4188
4189    // Param is passed by value, moved
4190    pub fn set_race(&mut self, v: i32) {
4191        self.race = ::std::option::Option::Some(v);
4192    }
4193
4194    // required int32 caste = 7;
4195
4196    pub fn caste(&self) -> i32 {
4197        self.caste.unwrap_or(0)
4198    }
4199
4200    pub fn clear_caste(&mut self) {
4201        self.caste = ::std::option::Option::None;
4202    }
4203
4204    pub fn has_caste(&self) -> bool {
4205        self.caste.is_some()
4206    }
4207
4208    // Param is passed by value, moved
4209    pub fn set_caste(&mut self, v: i32) {
4210        self.caste = ::std::option::Option::Some(v);
4211    }
4212
4213    // optional int32 gender = 8;
4214
4215    pub fn gender(&self) -> i32 {
4216        self.gender.unwrap_or(-1i32)
4217    }
4218
4219    pub fn clear_gender(&mut self) {
4220        self.gender = ::std::option::Option::None;
4221    }
4222
4223    pub fn has_gender(&self) -> bool {
4224        self.gender.is_some()
4225    }
4226
4227    // Param is passed by value, moved
4228    pub fn set_gender(&mut self, v: i32) {
4229        self.gender = ::std::option::Option::Some(v);
4230    }
4231
4232    // optional int32 civ_id = 9;
4233
4234    pub fn civ_id(&self) -> i32 {
4235        self.civ_id.unwrap_or(-1i32)
4236    }
4237
4238    pub fn clear_civ_id(&mut self) {
4239        self.civ_id = ::std::option::Option::None;
4240    }
4241
4242    pub fn has_civ_id(&self) -> bool {
4243        self.civ_id.is_some()
4244    }
4245
4246    // Param is passed by value, moved
4247    pub fn set_civ_id(&mut self, v: i32) {
4248        self.civ_id = ::std::option::Option::Some(v);
4249    }
4250
4251    // optional int32 histfig_id = 10;
4252
4253    pub fn histfig_id(&self) -> i32 {
4254        self.histfig_id.unwrap_or(-1i32)
4255    }
4256
4257    pub fn clear_histfig_id(&mut self) {
4258        self.histfig_id = ::std::option::Option::None;
4259    }
4260
4261    pub fn has_histfig_id(&self) -> bool {
4262        self.histfig_id.is_some()
4263    }
4264
4265    // Param is passed by value, moved
4266    pub fn set_histfig_id(&mut self, v: i32) {
4267        self.histfig_id = ::std::option::Option::Some(v);
4268    }
4269
4270    // optional int32 death_id = 17;
4271
4272    pub fn death_id(&self) -> i32 {
4273        self.death_id.unwrap_or(-1i32)
4274    }
4275
4276    pub fn clear_death_id(&mut self) {
4277        self.death_id = ::std::option::Option::None;
4278    }
4279
4280    pub fn has_death_id(&self) -> bool {
4281        self.death_id.is_some()
4282    }
4283
4284    // Param is passed by value, moved
4285    pub fn set_death_id(&mut self, v: i32) {
4286        self.death_id = ::std::option::Option::Some(v);
4287    }
4288
4289    // optional uint32 death_flags = 18;
4290
4291    pub fn death_flags(&self) -> u32 {
4292        self.death_flags.unwrap_or(0)
4293    }
4294
4295    pub fn clear_death_flags(&mut self) {
4296        self.death_flags = ::std::option::Option::None;
4297    }
4298
4299    pub fn has_death_flags(&self) -> bool {
4300        self.death_flags.is_some()
4301    }
4302
4303    // Param is passed by value, moved
4304    pub fn set_death_flags(&mut self, v: u32) {
4305        self.death_flags = ::std::option::Option::Some(v);
4306    }
4307
4308    // optional int32 squad_id = 19;
4309
4310    pub fn squad_id(&self) -> i32 {
4311        self.squad_id.unwrap_or(-1i32)
4312    }
4313
4314    pub fn clear_squad_id(&mut self) {
4315        self.squad_id = ::std::option::Option::None;
4316    }
4317
4318    pub fn has_squad_id(&self) -> bool {
4319        self.squad_id.is_some()
4320    }
4321
4322    // Param is passed by value, moved
4323    pub fn set_squad_id(&mut self, v: i32) {
4324        self.squad_id = ::std::option::Option::Some(v);
4325    }
4326
4327    // optional int32 squad_position = 20;
4328
4329    pub fn squad_position(&self) -> i32 {
4330        self.squad_position.unwrap_or(-1i32)
4331    }
4332
4333    pub fn clear_squad_position(&mut self) {
4334        self.squad_position = ::std::option::Option::None;
4335    }
4336
4337    pub fn has_squad_position(&self) -> bool {
4338        self.squad_position.is_some()
4339    }
4340
4341    // Param is passed by value, moved
4342    pub fn set_squad_position(&mut self, v: i32) {
4343        self.squad_position = ::std::option::Option::Some(v);
4344    }
4345
4346    // optional int32 profession = 22;
4347
4348    pub fn profession(&self) -> i32 {
4349        self.profession.unwrap_or(-1i32)
4350    }
4351
4352    pub fn clear_profession(&mut self) {
4353        self.profession = ::std::option::Option::None;
4354    }
4355
4356    pub fn has_profession(&self) -> bool {
4357        self.profession.is_some()
4358    }
4359
4360    // Param is passed by value, moved
4361    pub fn set_profession(&mut self, v: i32) {
4362        self.profession = ::std::option::Option::Some(v);
4363    }
4364
4365    // optional string custom_profession = 23;
4366
4367    pub fn custom_profession(&self) -> &str {
4368        match self.custom_profession.as_ref() {
4369            Some(v) => v,
4370            None => "",
4371        }
4372    }
4373
4374    pub fn clear_custom_profession(&mut self) {
4375        self.custom_profession = ::std::option::Option::None;
4376    }
4377
4378    pub fn has_custom_profession(&self) -> bool {
4379        self.custom_profession.is_some()
4380    }
4381
4382    // Param is passed by value, moved
4383    pub fn set_custom_profession(&mut self, v: ::std::string::String) {
4384        self.custom_profession = ::std::option::Option::Some(v);
4385    }
4386
4387    // Mutable pointer to the field.
4388    // If field is not initialized, it is initialized with default value first.
4389    pub fn mut_custom_profession(&mut self) -> &mut ::std::string::String {
4390        if self.custom_profession.is_none() {
4391            self.custom_profession = ::std::option::Option::Some(::std::string::String::new());
4392        }
4393        self.custom_profession.as_mut().unwrap()
4394    }
4395
4396    // Take field
4397    pub fn take_custom_profession(&mut self) -> ::std::string::String {
4398        self.custom_profession.take().unwrap_or_else(|| ::std::string::String::new())
4399    }
4400
4401    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
4402        let mut fields = ::std::vec::Vec::with_capacity(24);
4403        let mut oneofs = ::std::vec::Vec::with_capacity(0);
4404        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4405            "unit_id",
4406            |m: &BasicUnitInfo| { &m.unit_id },
4407            |m: &mut BasicUnitInfo| { &mut m.unit_id },
4408        ));
4409        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4410            "pos_x",
4411            |m: &BasicUnitInfo| { &m.pos_x },
4412            |m: &mut BasicUnitInfo| { &mut m.pos_x },
4413        ));
4414        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4415            "pos_y",
4416            |m: &BasicUnitInfo| { &m.pos_y },
4417            |m: &mut BasicUnitInfo| { &mut m.pos_y },
4418        ));
4419        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4420            "pos_z",
4421            |m: &BasicUnitInfo| { &m.pos_z },
4422            |m: &mut BasicUnitInfo| { &mut m.pos_z },
4423        ));
4424        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, NameInfo>(
4425            "name",
4426            |m: &BasicUnitInfo| { &m.name },
4427            |m: &mut BasicUnitInfo| { &mut m.name },
4428        ));
4429        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4430            "flags1",
4431            |m: &BasicUnitInfo| { &m.flags1 },
4432            |m: &mut BasicUnitInfo| { &mut m.flags1 },
4433        ));
4434        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4435            "flags2",
4436            |m: &BasicUnitInfo| { &m.flags2 },
4437            |m: &mut BasicUnitInfo| { &mut m.flags2 },
4438        ));
4439        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4440            "flags3",
4441            |m: &BasicUnitInfo| { &m.flags3 },
4442            |m: &mut BasicUnitInfo| { &mut m.flags3 },
4443        ));
4444        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4445            "race",
4446            |m: &BasicUnitInfo| { &m.race },
4447            |m: &mut BasicUnitInfo| { &mut m.race },
4448        ));
4449        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4450            "caste",
4451            |m: &BasicUnitInfo| { &m.caste },
4452            |m: &mut BasicUnitInfo| { &mut m.caste },
4453        ));
4454        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4455            "gender",
4456            |m: &BasicUnitInfo| { &m.gender },
4457            |m: &mut BasicUnitInfo| { &mut m.gender },
4458        ));
4459        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4460            "civ_id",
4461            |m: &BasicUnitInfo| { &m.civ_id },
4462            |m: &mut BasicUnitInfo| { &mut m.civ_id },
4463        ));
4464        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4465            "histfig_id",
4466            |m: &BasicUnitInfo| { &m.histfig_id },
4467            |m: &mut BasicUnitInfo| { &mut m.histfig_id },
4468        ));
4469        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4470            "death_id",
4471            |m: &BasicUnitInfo| { &m.death_id },
4472            |m: &mut BasicUnitInfo| { &mut m.death_id },
4473        ));
4474        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4475            "death_flags",
4476            |m: &BasicUnitInfo| { &m.death_flags },
4477            |m: &mut BasicUnitInfo| { &mut m.death_flags },
4478        ));
4479        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4480            "squad_id",
4481            |m: &BasicUnitInfo| { &m.squad_id },
4482            |m: &mut BasicUnitInfo| { &mut m.squad_id },
4483        ));
4484        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4485            "squad_position",
4486            |m: &BasicUnitInfo| { &m.squad_position },
4487            |m: &mut BasicUnitInfo| { &mut m.squad_position },
4488        ));
4489        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4490            "profession",
4491            |m: &BasicUnitInfo| { &m.profession },
4492            |m: &mut BasicUnitInfo| { &mut m.profession },
4493        ));
4494        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4495            "custom_profession",
4496            |m: &BasicUnitInfo| { &m.custom_profession },
4497            |m: &mut BasicUnitInfo| { &mut m.custom_profession },
4498        ));
4499        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
4500            "labors",
4501            |m: &BasicUnitInfo| { &m.labors },
4502            |m: &mut BasicUnitInfo| { &mut m.labors },
4503        ));
4504        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
4505            "skills",
4506            |m: &BasicUnitInfo| { &m.skills },
4507            |m: &mut BasicUnitInfo| { &mut m.skills },
4508        ));
4509        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
4510            "misc_traits",
4511            |m: &BasicUnitInfo| { &m.misc_traits },
4512            |m: &mut BasicUnitInfo| { &mut m.misc_traits },
4513        ));
4514        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, UnitCurseInfo>(
4515            "curse",
4516            |m: &BasicUnitInfo| { &m.curse },
4517            |m: &mut BasicUnitInfo| { &mut m.curse },
4518        ));
4519        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
4520            "burrows",
4521            |m: &BasicUnitInfo| { &m.burrows },
4522            |m: &mut BasicUnitInfo| { &mut m.burrows },
4523        ));
4524        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<BasicUnitInfo>(
4525            "BasicUnitInfo",
4526            fields,
4527            oneofs,
4528        )
4529    }
4530}
4531
4532impl ::protobuf::Message for BasicUnitInfo {
4533    const NAME: &'static str = "BasicUnitInfo";
4534
4535    fn is_initialized(&self) -> bool {
4536        if self.unit_id.is_none() {
4537            return false;
4538        }
4539        if self.pos_x.is_none() {
4540            return false;
4541        }
4542        if self.pos_y.is_none() {
4543            return false;
4544        }
4545        if self.pos_z.is_none() {
4546            return false;
4547        }
4548        if self.flags1.is_none() {
4549            return false;
4550        }
4551        if self.flags2.is_none() {
4552            return false;
4553        }
4554        if self.flags3.is_none() {
4555            return false;
4556        }
4557        if self.race.is_none() {
4558            return false;
4559        }
4560        if self.caste.is_none() {
4561            return false;
4562        }
4563        for v in &self.name {
4564            if !v.is_initialized() {
4565                return false;
4566            }
4567        };
4568        for v in &self.skills {
4569            if !v.is_initialized() {
4570                return false;
4571            }
4572        };
4573        for v in &self.misc_traits {
4574            if !v.is_initialized() {
4575                return false;
4576            }
4577        };
4578        for v in &self.curse {
4579            if !v.is_initialized() {
4580                return false;
4581            }
4582        };
4583        true
4584    }
4585
4586    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
4587        while let Some(tag) = is.read_raw_tag_or_eof()? {
4588            match tag {
4589                8 => {
4590                    self.unit_id = ::std::option::Option::Some(is.read_int32()?);
4591                },
4592                104 => {
4593                    self.pos_x = ::std::option::Option::Some(is.read_int32()?);
4594                },
4595                112 => {
4596                    self.pos_y = ::std::option::Option::Some(is.read_int32()?);
4597                },
4598                120 => {
4599                    self.pos_z = ::std::option::Option::Some(is.read_int32()?);
4600                },
4601                18 => {
4602                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.name)?;
4603                },
4604                29 => {
4605                    self.flags1 = ::std::option::Option::Some(is.read_fixed32()?);
4606                },
4607                37 => {
4608                    self.flags2 = ::std::option::Option::Some(is.read_fixed32()?);
4609                },
4610                45 => {
4611                    self.flags3 = ::std::option::Option::Some(is.read_fixed32()?);
4612                },
4613                48 => {
4614                    self.race = ::std::option::Option::Some(is.read_int32()?);
4615                },
4616                56 => {
4617                    self.caste = ::std::option::Option::Some(is.read_int32()?);
4618                },
4619                64 => {
4620                    self.gender = ::std::option::Option::Some(is.read_int32()?);
4621                },
4622                72 => {
4623                    self.civ_id = ::std::option::Option::Some(is.read_int32()?);
4624                },
4625                80 => {
4626                    self.histfig_id = ::std::option::Option::Some(is.read_int32()?);
4627                },
4628                136 => {
4629                    self.death_id = ::std::option::Option::Some(is.read_int32()?);
4630                },
4631                144 => {
4632                    self.death_flags = ::std::option::Option::Some(is.read_uint32()?);
4633                },
4634                152 => {
4635                    self.squad_id = ::std::option::Option::Some(is.read_int32()?);
4636                },
4637                160 => {
4638                    self.squad_position = ::std::option::Option::Some(is.read_int32()?);
4639                },
4640                176 => {
4641                    self.profession = ::std::option::Option::Some(is.read_int32()?);
4642                },
4643                186 => {
4644                    self.custom_profession = ::std::option::Option::Some(is.read_string()?);
4645                },
4646                90 => {
4647                    is.read_repeated_packed_int32_into(&mut self.labors)?;
4648                },
4649                88 => {
4650                    self.labors.push(is.read_int32()?);
4651                },
4652                98 => {
4653                    self.skills.push(is.read_message()?);
4654                },
4655                194 => {
4656                    self.misc_traits.push(is.read_message()?);
4657                },
4658                130 => {
4659                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.curse)?;
4660                },
4661                170 => {
4662                    is.read_repeated_packed_int32_into(&mut self.burrows)?;
4663                },
4664                168 => {
4665                    self.burrows.push(is.read_int32()?);
4666                },
4667                tag => {
4668                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
4669                },
4670            };
4671        }
4672        ::std::result::Result::Ok(())
4673    }
4674
4675    // Compute sizes of nested messages
4676    #[allow(unused_variables)]
4677    fn compute_size(&self) -> u64 {
4678        let mut my_size = 0;
4679        if let Some(v) = self.unit_id {
4680            my_size += ::protobuf::rt::int32_size(1, v);
4681        }
4682        if let Some(v) = self.pos_x {
4683            my_size += ::protobuf::rt::int32_size(13, v);
4684        }
4685        if let Some(v) = self.pos_y {
4686            my_size += ::protobuf::rt::int32_size(14, v);
4687        }
4688        if let Some(v) = self.pos_z {
4689            my_size += ::protobuf::rt::int32_size(15, v);
4690        }
4691        if let Some(v) = self.name.as_ref() {
4692            let len = v.compute_size();
4693            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
4694        }
4695        if let Some(v) = self.flags1 {
4696            my_size += 1 + 4;
4697        }
4698        if let Some(v) = self.flags2 {
4699            my_size += 1 + 4;
4700        }
4701        if let Some(v) = self.flags3 {
4702            my_size += 1 + 4;
4703        }
4704        if let Some(v) = self.race {
4705            my_size += ::protobuf::rt::int32_size(6, v);
4706        }
4707        if let Some(v) = self.caste {
4708            my_size += ::protobuf::rt::int32_size(7, v);
4709        }
4710        if let Some(v) = self.gender {
4711            my_size += ::protobuf::rt::int32_size(8, v);
4712        }
4713        if let Some(v) = self.civ_id {
4714            my_size += ::protobuf::rt::int32_size(9, v);
4715        }
4716        if let Some(v) = self.histfig_id {
4717            my_size += ::protobuf::rt::int32_size(10, v);
4718        }
4719        if let Some(v) = self.death_id {
4720            my_size += ::protobuf::rt::int32_size(17, v);
4721        }
4722        if let Some(v) = self.death_flags {
4723            my_size += ::protobuf::rt::uint32_size(18, v);
4724        }
4725        if let Some(v) = self.squad_id {
4726            my_size += ::protobuf::rt::int32_size(19, v);
4727        }
4728        if let Some(v) = self.squad_position {
4729            my_size += ::protobuf::rt::int32_size(20, v);
4730        }
4731        if let Some(v) = self.profession {
4732            my_size += ::protobuf::rt::int32_size(22, v);
4733        }
4734        if let Some(v) = self.custom_profession.as_ref() {
4735            my_size += ::protobuf::rt::string_size(23, &v);
4736        }
4737        for value in &self.labors {
4738            my_size += ::protobuf::rt::int32_size(11, *value);
4739        };
4740        for value in &self.skills {
4741            let len = value.compute_size();
4742            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
4743        };
4744        for value in &self.misc_traits {
4745            let len = value.compute_size();
4746            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
4747        };
4748        if let Some(v) = self.curse.as_ref() {
4749            let len = v.compute_size();
4750            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
4751        }
4752        for value in &self.burrows {
4753            my_size += ::protobuf::rt::int32_size(21, *value);
4754        };
4755        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
4756        self.special_fields.cached_size().set(my_size as u32);
4757        my_size
4758    }
4759
4760    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
4761        if let Some(v) = self.unit_id {
4762            os.write_int32(1, v)?;
4763        }
4764        if let Some(v) = self.pos_x {
4765            os.write_int32(13, v)?;
4766        }
4767        if let Some(v) = self.pos_y {
4768            os.write_int32(14, v)?;
4769        }
4770        if let Some(v) = self.pos_z {
4771            os.write_int32(15, v)?;
4772        }
4773        if let Some(v) = self.name.as_ref() {
4774            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
4775        }
4776        if let Some(v) = self.flags1 {
4777            os.write_fixed32(3, v)?;
4778        }
4779        if let Some(v) = self.flags2 {
4780            os.write_fixed32(4, v)?;
4781        }
4782        if let Some(v) = self.flags3 {
4783            os.write_fixed32(5, v)?;
4784        }
4785        if let Some(v) = self.race {
4786            os.write_int32(6, v)?;
4787        }
4788        if let Some(v) = self.caste {
4789            os.write_int32(7, v)?;
4790        }
4791        if let Some(v) = self.gender {
4792            os.write_int32(8, v)?;
4793        }
4794        if let Some(v) = self.civ_id {
4795            os.write_int32(9, v)?;
4796        }
4797        if let Some(v) = self.histfig_id {
4798            os.write_int32(10, v)?;
4799        }
4800        if let Some(v) = self.death_id {
4801            os.write_int32(17, v)?;
4802        }
4803        if let Some(v) = self.death_flags {
4804            os.write_uint32(18, v)?;
4805        }
4806        if let Some(v) = self.squad_id {
4807            os.write_int32(19, v)?;
4808        }
4809        if let Some(v) = self.squad_position {
4810            os.write_int32(20, v)?;
4811        }
4812        if let Some(v) = self.profession {
4813            os.write_int32(22, v)?;
4814        }
4815        if let Some(v) = self.custom_profession.as_ref() {
4816            os.write_string(23, v)?;
4817        }
4818        for v in &self.labors {
4819            os.write_int32(11, *v)?;
4820        };
4821        for v in &self.skills {
4822            ::protobuf::rt::write_message_field_with_cached_size(12, v, os)?;
4823        };
4824        for v in &self.misc_traits {
4825            ::protobuf::rt::write_message_field_with_cached_size(24, v, os)?;
4826        };
4827        if let Some(v) = self.curse.as_ref() {
4828            ::protobuf::rt::write_message_field_with_cached_size(16, v, os)?;
4829        }
4830        for v in &self.burrows {
4831            os.write_int32(21, *v)?;
4832        };
4833        os.write_unknown_fields(self.special_fields.unknown_fields())?;
4834        ::std::result::Result::Ok(())
4835    }
4836
4837    fn special_fields(&self) -> &::protobuf::SpecialFields {
4838        &self.special_fields
4839    }
4840
4841    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
4842        &mut self.special_fields
4843    }
4844
4845    fn new() -> BasicUnitInfo {
4846        BasicUnitInfo::new()
4847    }
4848
4849    fn clear(&mut self) {
4850        self.unit_id = ::std::option::Option::None;
4851        self.pos_x = ::std::option::Option::None;
4852        self.pos_y = ::std::option::Option::None;
4853        self.pos_z = ::std::option::Option::None;
4854        self.name.clear();
4855        self.flags1 = ::std::option::Option::None;
4856        self.flags2 = ::std::option::Option::None;
4857        self.flags3 = ::std::option::Option::None;
4858        self.race = ::std::option::Option::None;
4859        self.caste = ::std::option::Option::None;
4860        self.gender = ::std::option::Option::None;
4861        self.civ_id = ::std::option::Option::None;
4862        self.histfig_id = ::std::option::Option::None;
4863        self.death_id = ::std::option::Option::None;
4864        self.death_flags = ::std::option::Option::None;
4865        self.squad_id = ::std::option::Option::None;
4866        self.squad_position = ::std::option::Option::None;
4867        self.profession = ::std::option::Option::None;
4868        self.custom_profession = ::std::option::Option::None;
4869        self.labors.clear();
4870        self.skills.clear();
4871        self.misc_traits.clear();
4872        self.curse.clear();
4873        self.burrows.clear();
4874        self.special_fields.clear();
4875    }
4876
4877    fn default_instance() -> &'static BasicUnitInfo {
4878        static instance: BasicUnitInfo = BasicUnitInfo {
4879            unit_id: ::std::option::Option::None,
4880            pos_x: ::std::option::Option::None,
4881            pos_y: ::std::option::Option::None,
4882            pos_z: ::std::option::Option::None,
4883            name: ::protobuf::MessageField::none(),
4884            flags1: ::std::option::Option::None,
4885            flags2: ::std::option::Option::None,
4886            flags3: ::std::option::Option::None,
4887            race: ::std::option::Option::None,
4888            caste: ::std::option::Option::None,
4889            gender: ::std::option::Option::None,
4890            civ_id: ::std::option::Option::None,
4891            histfig_id: ::std::option::Option::None,
4892            death_id: ::std::option::Option::None,
4893            death_flags: ::std::option::Option::None,
4894            squad_id: ::std::option::Option::None,
4895            squad_position: ::std::option::Option::None,
4896            profession: ::std::option::Option::None,
4897            custom_profession: ::std::option::Option::None,
4898            labors: ::std::vec::Vec::new(),
4899            skills: ::std::vec::Vec::new(),
4900            misc_traits: ::std::vec::Vec::new(),
4901            curse: ::protobuf::MessageField::none(),
4902            burrows: ::std::vec::Vec::new(),
4903            special_fields: ::protobuf::SpecialFields::new(),
4904        };
4905        &instance
4906    }
4907}
4908
4909impl ::protobuf::MessageFull for BasicUnitInfo {
4910    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
4911        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
4912        descriptor.get(|| file_descriptor().message_by_package_relative_name("BasicUnitInfo").unwrap()).clone()
4913    }
4914}
4915
4916impl ::std::fmt::Display for BasicUnitInfo {
4917    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4918        ::protobuf::text_format::fmt(self, f)
4919    }
4920}
4921
4922impl ::protobuf::reflect::ProtobufValue for BasicUnitInfo {
4923    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
4924}
4925
4926// @@protoc_insertion_point(message:dfproto.BasicUnitInfoMask)
4927#[derive(PartialEq,Clone,Default,Debug)]
4928pub struct BasicUnitInfoMask {
4929    // message fields
4930    // @@protoc_insertion_point(field:dfproto.BasicUnitInfoMask.labors)
4931    pub labors: ::std::option::Option<bool>,
4932    // @@protoc_insertion_point(field:dfproto.BasicUnitInfoMask.skills)
4933    pub skills: ::std::option::Option<bool>,
4934    // @@protoc_insertion_point(field:dfproto.BasicUnitInfoMask.profession)
4935    pub profession: ::std::option::Option<bool>,
4936    // @@protoc_insertion_point(field:dfproto.BasicUnitInfoMask.misc_traits)
4937    pub misc_traits: ::std::option::Option<bool>,
4938    // special fields
4939    // @@protoc_insertion_point(special_field:dfproto.BasicUnitInfoMask.special_fields)
4940    pub special_fields: ::protobuf::SpecialFields,
4941}
4942
4943impl<'a> ::std::default::Default for &'a BasicUnitInfoMask {
4944    fn default() -> &'a BasicUnitInfoMask {
4945        <BasicUnitInfoMask as ::protobuf::Message>::default_instance()
4946    }
4947}
4948
4949impl BasicUnitInfoMask {
4950    pub fn new() -> BasicUnitInfoMask {
4951        ::std::default::Default::default()
4952    }
4953
4954    // optional bool labors = 1;
4955
4956    pub fn labors(&self) -> bool {
4957        self.labors.unwrap_or(false)
4958    }
4959
4960    pub fn clear_labors(&mut self) {
4961        self.labors = ::std::option::Option::None;
4962    }
4963
4964    pub fn has_labors(&self) -> bool {
4965        self.labors.is_some()
4966    }
4967
4968    // Param is passed by value, moved
4969    pub fn set_labors(&mut self, v: bool) {
4970        self.labors = ::std::option::Option::Some(v);
4971    }
4972
4973    // optional bool skills = 2;
4974
4975    pub fn skills(&self) -> bool {
4976        self.skills.unwrap_or(false)
4977    }
4978
4979    pub fn clear_skills(&mut self) {
4980        self.skills = ::std::option::Option::None;
4981    }
4982
4983    pub fn has_skills(&self) -> bool {
4984        self.skills.is_some()
4985    }
4986
4987    // Param is passed by value, moved
4988    pub fn set_skills(&mut self, v: bool) {
4989        self.skills = ::std::option::Option::Some(v);
4990    }
4991
4992    // optional bool profession = 3;
4993
4994    pub fn profession(&self) -> bool {
4995        self.profession.unwrap_or(false)
4996    }
4997
4998    pub fn clear_profession(&mut self) {
4999        self.profession = ::std::option::Option::None;
5000    }
5001
5002    pub fn has_profession(&self) -> bool {
5003        self.profession.is_some()
5004    }
5005
5006    // Param is passed by value, moved
5007    pub fn set_profession(&mut self, v: bool) {
5008        self.profession = ::std::option::Option::Some(v);
5009    }
5010
5011    // optional bool misc_traits = 4;
5012
5013    pub fn misc_traits(&self) -> bool {
5014        self.misc_traits.unwrap_or(false)
5015    }
5016
5017    pub fn clear_misc_traits(&mut self) {
5018        self.misc_traits = ::std::option::Option::None;
5019    }
5020
5021    pub fn has_misc_traits(&self) -> bool {
5022        self.misc_traits.is_some()
5023    }
5024
5025    // Param is passed by value, moved
5026    pub fn set_misc_traits(&mut self, v: bool) {
5027        self.misc_traits = ::std::option::Option::Some(v);
5028    }
5029
5030    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
5031        let mut fields = ::std::vec::Vec::with_capacity(4);
5032        let mut oneofs = ::std::vec::Vec::with_capacity(0);
5033        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5034            "labors",
5035            |m: &BasicUnitInfoMask| { &m.labors },
5036            |m: &mut BasicUnitInfoMask| { &mut m.labors },
5037        ));
5038        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5039            "skills",
5040            |m: &BasicUnitInfoMask| { &m.skills },
5041            |m: &mut BasicUnitInfoMask| { &mut m.skills },
5042        ));
5043        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5044            "profession",
5045            |m: &BasicUnitInfoMask| { &m.profession },
5046            |m: &mut BasicUnitInfoMask| { &mut m.profession },
5047        ));
5048        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5049            "misc_traits",
5050            |m: &BasicUnitInfoMask| { &m.misc_traits },
5051            |m: &mut BasicUnitInfoMask| { &mut m.misc_traits },
5052        ));
5053        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<BasicUnitInfoMask>(
5054            "BasicUnitInfoMask",
5055            fields,
5056            oneofs,
5057        )
5058    }
5059}
5060
5061impl ::protobuf::Message for BasicUnitInfoMask {
5062    const NAME: &'static str = "BasicUnitInfoMask";
5063
5064    fn is_initialized(&self) -> bool {
5065        true
5066    }
5067
5068    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
5069        while let Some(tag) = is.read_raw_tag_or_eof()? {
5070            match tag {
5071                8 => {
5072                    self.labors = ::std::option::Option::Some(is.read_bool()?);
5073                },
5074                16 => {
5075                    self.skills = ::std::option::Option::Some(is.read_bool()?);
5076                },
5077                24 => {
5078                    self.profession = ::std::option::Option::Some(is.read_bool()?);
5079                },
5080                32 => {
5081                    self.misc_traits = ::std::option::Option::Some(is.read_bool()?);
5082                },
5083                tag => {
5084                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5085                },
5086            };
5087        }
5088        ::std::result::Result::Ok(())
5089    }
5090
5091    // Compute sizes of nested messages
5092    #[allow(unused_variables)]
5093    fn compute_size(&self) -> u64 {
5094        let mut my_size = 0;
5095        if let Some(v) = self.labors {
5096            my_size += 1 + 1;
5097        }
5098        if let Some(v) = self.skills {
5099            my_size += 1 + 1;
5100        }
5101        if let Some(v) = self.profession {
5102            my_size += 1 + 1;
5103        }
5104        if let Some(v) = self.misc_traits {
5105            my_size += 1 + 1;
5106        }
5107        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
5108        self.special_fields.cached_size().set(my_size as u32);
5109        my_size
5110    }
5111
5112    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
5113        if let Some(v) = self.labors {
5114            os.write_bool(1, v)?;
5115        }
5116        if let Some(v) = self.skills {
5117            os.write_bool(2, v)?;
5118        }
5119        if let Some(v) = self.profession {
5120            os.write_bool(3, v)?;
5121        }
5122        if let Some(v) = self.misc_traits {
5123            os.write_bool(4, v)?;
5124        }
5125        os.write_unknown_fields(self.special_fields.unknown_fields())?;
5126        ::std::result::Result::Ok(())
5127    }
5128
5129    fn special_fields(&self) -> &::protobuf::SpecialFields {
5130        &self.special_fields
5131    }
5132
5133    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
5134        &mut self.special_fields
5135    }
5136
5137    fn new() -> BasicUnitInfoMask {
5138        BasicUnitInfoMask::new()
5139    }
5140
5141    fn clear(&mut self) {
5142        self.labors = ::std::option::Option::None;
5143        self.skills = ::std::option::Option::None;
5144        self.profession = ::std::option::Option::None;
5145        self.misc_traits = ::std::option::Option::None;
5146        self.special_fields.clear();
5147    }
5148
5149    fn default_instance() -> &'static BasicUnitInfoMask {
5150        static instance: BasicUnitInfoMask = BasicUnitInfoMask {
5151            labors: ::std::option::Option::None,
5152            skills: ::std::option::Option::None,
5153            profession: ::std::option::Option::None,
5154            misc_traits: ::std::option::Option::None,
5155            special_fields: ::protobuf::SpecialFields::new(),
5156        };
5157        &instance
5158    }
5159}
5160
5161impl ::protobuf::MessageFull for BasicUnitInfoMask {
5162    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
5163        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
5164        descriptor.get(|| file_descriptor().message_by_package_relative_name("BasicUnitInfoMask").unwrap()).clone()
5165    }
5166}
5167
5168impl ::std::fmt::Display for BasicUnitInfoMask {
5169    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5170        ::protobuf::text_format::fmt(self, f)
5171    }
5172}
5173
5174impl ::protobuf::reflect::ProtobufValue for BasicUnitInfoMask {
5175    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
5176}
5177
5178// @@protoc_insertion_point(message:dfproto.BasicSquadInfo)
5179#[derive(PartialEq,Clone,Default,Debug)]
5180pub struct BasicSquadInfo {
5181    // message fields
5182    // @@protoc_insertion_point(field:dfproto.BasicSquadInfo.squad_id)
5183    pub squad_id: ::std::option::Option<i32>,
5184    // @@protoc_insertion_point(field:dfproto.BasicSquadInfo.name)
5185    pub name: ::protobuf::MessageField<NameInfo>,
5186    // @@protoc_insertion_point(field:dfproto.BasicSquadInfo.alias)
5187    pub alias: ::std::option::Option<::std::string::String>,
5188    // @@protoc_insertion_point(field:dfproto.BasicSquadInfo.members)
5189    pub members: ::std::vec::Vec<i32>,
5190    // special fields
5191    // @@protoc_insertion_point(special_field:dfproto.BasicSquadInfo.special_fields)
5192    pub special_fields: ::protobuf::SpecialFields,
5193}
5194
5195impl<'a> ::std::default::Default for &'a BasicSquadInfo {
5196    fn default() -> &'a BasicSquadInfo {
5197        <BasicSquadInfo as ::protobuf::Message>::default_instance()
5198    }
5199}
5200
5201impl BasicSquadInfo {
5202    pub fn new() -> BasicSquadInfo {
5203        ::std::default::Default::default()
5204    }
5205
5206    // required int32 squad_id = 1;
5207
5208    pub fn squad_id(&self) -> i32 {
5209        self.squad_id.unwrap_or(0)
5210    }
5211
5212    pub fn clear_squad_id(&mut self) {
5213        self.squad_id = ::std::option::Option::None;
5214    }
5215
5216    pub fn has_squad_id(&self) -> bool {
5217        self.squad_id.is_some()
5218    }
5219
5220    // Param is passed by value, moved
5221    pub fn set_squad_id(&mut self, v: i32) {
5222        self.squad_id = ::std::option::Option::Some(v);
5223    }
5224
5225    // optional string alias = 3;
5226
5227    pub fn alias(&self) -> &str {
5228        match self.alias.as_ref() {
5229            Some(v) => v,
5230            None => "",
5231        }
5232    }
5233
5234    pub fn clear_alias(&mut self) {
5235        self.alias = ::std::option::Option::None;
5236    }
5237
5238    pub fn has_alias(&self) -> bool {
5239        self.alias.is_some()
5240    }
5241
5242    // Param is passed by value, moved
5243    pub fn set_alias(&mut self, v: ::std::string::String) {
5244        self.alias = ::std::option::Option::Some(v);
5245    }
5246
5247    // Mutable pointer to the field.
5248    // If field is not initialized, it is initialized with default value first.
5249    pub fn mut_alias(&mut self) -> &mut ::std::string::String {
5250        if self.alias.is_none() {
5251            self.alias = ::std::option::Option::Some(::std::string::String::new());
5252        }
5253        self.alias.as_mut().unwrap()
5254    }
5255
5256    // Take field
5257    pub fn take_alias(&mut self) -> ::std::string::String {
5258        self.alias.take().unwrap_or_else(|| ::std::string::String::new())
5259    }
5260
5261    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
5262        let mut fields = ::std::vec::Vec::with_capacity(4);
5263        let mut oneofs = ::std::vec::Vec::with_capacity(0);
5264        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5265            "squad_id",
5266            |m: &BasicSquadInfo| { &m.squad_id },
5267            |m: &mut BasicSquadInfo| { &mut m.squad_id },
5268        ));
5269        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, NameInfo>(
5270            "name",
5271            |m: &BasicSquadInfo| { &m.name },
5272            |m: &mut BasicSquadInfo| { &mut m.name },
5273        ));
5274        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5275            "alias",
5276            |m: &BasicSquadInfo| { &m.alias },
5277            |m: &mut BasicSquadInfo| { &mut m.alias },
5278        ));
5279        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
5280            "members",
5281            |m: &BasicSquadInfo| { &m.members },
5282            |m: &mut BasicSquadInfo| { &mut m.members },
5283        ));
5284        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<BasicSquadInfo>(
5285            "BasicSquadInfo",
5286            fields,
5287            oneofs,
5288        )
5289    }
5290}
5291
5292impl ::protobuf::Message for BasicSquadInfo {
5293    const NAME: &'static str = "BasicSquadInfo";
5294
5295    fn is_initialized(&self) -> bool {
5296        if self.squad_id.is_none() {
5297            return false;
5298        }
5299        for v in &self.name {
5300            if !v.is_initialized() {
5301                return false;
5302            }
5303        };
5304        true
5305    }
5306
5307    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
5308        while let Some(tag) = is.read_raw_tag_or_eof()? {
5309            match tag {
5310                8 => {
5311                    self.squad_id = ::std::option::Option::Some(is.read_int32()?);
5312                },
5313                18 => {
5314                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.name)?;
5315                },
5316                26 => {
5317                    self.alias = ::std::option::Option::Some(is.read_string()?);
5318                },
5319                34 => {
5320                    is.read_repeated_packed_sint32_into(&mut self.members)?;
5321                },
5322                32 => {
5323                    self.members.push(is.read_sint32()?);
5324                },
5325                tag => {
5326                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5327                },
5328            };
5329        }
5330        ::std::result::Result::Ok(())
5331    }
5332
5333    // Compute sizes of nested messages
5334    #[allow(unused_variables)]
5335    fn compute_size(&self) -> u64 {
5336        let mut my_size = 0;
5337        if let Some(v) = self.squad_id {
5338            my_size += ::protobuf::rt::int32_size(1, v);
5339        }
5340        if let Some(v) = self.name.as_ref() {
5341            let len = v.compute_size();
5342            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
5343        }
5344        if let Some(v) = self.alias.as_ref() {
5345            my_size += ::protobuf::rt::string_size(3, &v);
5346        }
5347        for value in &self.members {
5348            my_size += ::protobuf::rt::sint32_size(4, *value);
5349        };
5350        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
5351        self.special_fields.cached_size().set(my_size as u32);
5352        my_size
5353    }
5354
5355    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
5356        if let Some(v) = self.squad_id {
5357            os.write_int32(1, v)?;
5358        }
5359        if let Some(v) = self.name.as_ref() {
5360            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
5361        }
5362        if let Some(v) = self.alias.as_ref() {
5363            os.write_string(3, v)?;
5364        }
5365        for v in &self.members {
5366            os.write_sint32(4, *v)?;
5367        };
5368        os.write_unknown_fields(self.special_fields.unknown_fields())?;
5369        ::std::result::Result::Ok(())
5370    }
5371
5372    fn special_fields(&self) -> &::protobuf::SpecialFields {
5373        &self.special_fields
5374    }
5375
5376    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
5377        &mut self.special_fields
5378    }
5379
5380    fn new() -> BasicSquadInfo {
5381        BasicSquadInfo::new()
5382    }
5383
5384    fn clear(&mut self) {
5385        self.squad_id = ::std::option::Option::None;
5386        self.name.clear();
5387        self.alias = ::std::option::Option::None;
5388        self.members.clear();
5389        self.special_fields.clear();
5390    }
5391
5392    fn default_instance() -> &'static BasicSquadInfo {
5393        static instance: BasicSquadInfo = BasicSquadInfo {
5394            squad_id: ::std::option::Option::None,
5395            name: ::protobuf::MessageField::none(),
5396            alias: ::std::option::Option::None,
5397            members: ::std::vec::Vec::new(),
5398            special_fields: ::protobuf::SpecialFields::new(),
5399        };
5400        &instance
5401    }
5402}
5403
5404impl ::protobuf::MessageFull for BasicSquadInfo {
5405    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
5406        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
5407        descriptor.get(|| file_descriptor().message_by_package_relative_name("BasicSquadInfo").unwrap()).clone()
5408    }
5409}
5410
5411impl ::std::fmt::Display for BasicSquadInfo {
5412    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5413        ::protobuf::text_format::fmt(self, f)
5414    }
5415}
5416
5417impl ::protobuf::reflect::ProtobufValue for BasicSquadInfo {
5418    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
5419}
5420
5421// @@protoc_insertion_point(message:dfproto.UnitLaborState)
5422#[derive(PartialEq,Clone,Default,Debug)]
5423pub struct UnitLaborState {
5424    // message fields
5425    // @@protoc_insertion_point(field:dfproto.UnitLaborState.unit_id)
5426    pub unit_id: ::std::option::Option<i32>,
5427    // @@protoc_insertion_point(field:dfproto.UnitLaborState.labor)
5428    pub labor: ::std::option::Option<i32>,
5429    // @@protoc_insertion_point(field:dfproto.UnitLaborState.value)
5430    pub value: ::std::option::Option<bool>,
5431    // special fields
5432    // @@protoc_insertion_point(special_field:dfproto.UnitLaborState.special_fields)
5433    pub special_fields: ::protobuf::SpecialFields,
5434}
5435
5436impl<'a> ::std::default::Default for &'a UnitLaborState {
5437    fn default() -> &'a UnitLaborState {
5438        <UnitLaborState as ::protobuf::Message>::default_instance()
5439    }
5440}
5441
5442impl UnitLaborState {
5443    pub fn new() -> UnitLaborState {
5444        ::std::default::Default::default()
5445    }
5446
5447    // required int32 unit_id = 1;
5448
5449    pub fn unit_id(&self) -> i32 {
5450        self.unit_id.unwrap_or(0)
5451    }
5452
5453    pub fn clear_unit_id(&mut self) {
5454        self.unit_id = ::std::option::Option::None;
5455    }
5456
5457    pub fn has_unit_id(&self) -> bool {
5458        self.unit_id.is_some()
5459    }
5460
5461    // Param is passed by value, moved
5462    pub fn set_unit_id(&mut self, v: i32) {
5463        self.unit_id = ::std::option::Option::Some(v);
5464    }
5465
5466    // required int32 labor = 2;
5467
5468    pub fn labor(&self) -> i32 {
5469        self.labor.unwrap_or(0)
5470    }
5471
5472    pub fn clear_labor(&mut self) {
5473        self.labor = ::std::option::Option::None;
5474    }
5475
5476    pub fn has_labor(&self) -> bool {
5477        self.labor.is_some()
5478    }
5479
5480    // Param is passed by value, moved
5481    pub fn set_labor(&mut self, v: i32) {
5482        self.labor = ::std::option::Option::Some(v);
5483    }
5484
5485    // required bool value = 3;
5486
5487    pub fn value(&self) -> bool {
5488        self.value.unwrap_or(false)
5489    }
5490
5491    pub fn clear_value(&mut self) {
5492        self.value = ::std::option::Option::None;
5493    }
5494
5495    pub fn has_value(&self) -> bool {
5496        self.value.is_some()
5497    }
5498
5499    // Param is passed by value, moved
5500    pub fn set_value(&mut self, v: bool) {
5501        self.value = ::std::option::Option::Some(v);
5502    }
5503
5504    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
5505        let mut fields = ::std::vec::Vec::with_capacity(3);
5506        let mut oneofs = ::std::vec::Vec::with_capacity(0);
5507        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5508            "unit_id",
5509            |m: &UnitLaborState| { &m.unit_id },
5510            |m: &mut UnitLaborState| { &mut m.unit_id },
5511        ));
5512        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5513            "labor",
5514            |m: &UnitLaborState| { &m.labor },
5515            |m: &mut UnitLaborState| { &mut m.labor },
5516        ));
5517        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5518            "value",
5519            |m: &UnitLaborState| { &m.value },
5520            |m: &mut UnitLaborState| { &mut m.value },
5521        ));
5522        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UnitLaborState>(
5523            "UnitLaborState",
5524            fields,
5525            oneofs,
5526        )
5527    }
5528}
5529
5530impl ::protobuf::Message for UnitLaborState {
5531    const NAME: &'static str = "UnitLaborState";
5532
5533    fn is_initialized(&self) -> bool {
5534        if self.unit_id.is_none() {
5535            return false;
5536        }
5537        if self.labor.is_none() {
5538            return false;
5539        }
5540        if self.value.is_none() {
5541            return false;
5542        }
5543        true
5544    }
5545
5546    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
5547        while let Some(tag) = is.read_raw_tag_or_eof()? {
5548            match tag {
5549                8 => {
5550                    self.unit_id = ::std::option::Option::Some(is.read_int32()?);
5551                },
5552                16 => {
5553                    self.labor = ::std::option::Option::Some(is.read_int32()?);
5554                },
5555                24 => {
5556                    self.value = ::std::option::Option::Some(is.read_bool()?);
5557                },
5558                tag => {
5559                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5560                },
5561            };
5562        }
5563        ::std::result::Result::Ok(())
5564    }
5565
5566    // Compute sizes of nested messages
5567    #[allow(unused_variables)]
5568    fn compute_size(&self) -> u64 {
5569        let mut my_size = 0;
5570        if let Some(v) = self.unit_id {
5571            my_size += ::protobuf::rt::int32_size(1, v);
5572        }
5573        if let Some(v) = self.labor {
5574            my_size += ::protobuf::rt::int32_size(2, v);
5575        }
5576        if let Some(v) = self.value {
5577            my_size += 1 + 1;
5578        }
5579        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
5580        self.special_fields.cached_size().set(my_size as u32);
5581        my_size
5582    }
5583
5584    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
5585        if let Some(v) = self.unit_id {
5586            os.write_int32(1, v)?;
5587        }
5588        if let Some(v) = self.labor {
5589            os.write_int32(2, v)?;
5590        }
5591        if let Some(v) = self.value {
5592            os.write_bool(3, v)?;
5593        }
5594        os.write_unknown_fields(self.special_fields.unknown_fields())?;
5595        ::std::result::Result::Ok(())
5596    }
5597
5598    fn special_fields(&self) -> &::protobuf::SpecialFields {
5599        &self.special_fields
5600    }
5601
5602    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
5603        &mut self.special_fields
5604    }
5605
5606    fn new() -> UnitLaborState {
5607        UnitLaborState::new()
5608    }
5609
5610    fn clear(&mut self) {
5611        self.unit_id = ::std::option::Option::None;
5612        self.labor = ::std::option::Option::None;
5613        self.value = ::std::option::Option::None;
5614        self.special_fields.clear();
5615    }
5616
5617    fn default_instance() -> &'static UnitLaborState {
5618        static instance: UnitLaborState = UnitLaborState {
5619            unit_id: ::std::option::Option::None,
5620            labor: ::std::option::Option::None,
5621            value: ::std::option::Option::None,
5622            special_fields: ::protobuf::SpecialFields::new(),
5623        };
5624        &instance
5625    }
5626}
5627
5628impl ::protobuf::MessageFull for UnitLaborState {
5629    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
5630        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
5631        descriptor.get(|| file_descriptor().message_by_package_relative_name("UnitLaborState").unwrap()).clone()
5632    }
5633}
5634
5635impl ::std::fmt::Display for UnitLaborState {
5636    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5637        ::protobuf::text_format::fmt(self, f)
5638    }
5639}
5640
5641impl ::protobuf::reflect::ProtobufValue for UnitLaborState {
5642    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
5643}
5644
5645static file_descriptor_proto_data: &'static [u8] = b"\
5646    \n\x0bBasic.proto\x12\x07dfproto\"X\n\x0cEnumItemName\x12\x14\n\x05value\
5647    \x18\x01\x20\x02(\x05R\x05value\x12\x12\n\x04name\x18\x02\x20\x01(\tR\
5648    \x04name\x12\x1e\n\x08bit_size\x18\x03\x20\x01(\x05:\x011R\x07bitSizeB\0\
5649    \";\n\x0fBasicMaterialId\x12\x12\n\x04type\x18\x01\x20\x02(\x05R\x04type\
5650    \x12\x14\n\x05index\x18\x02\x20\x02(\x11R\x05index\"\xdc\x04\n\x11BasicM\
5651    aterialInfo\x12\x12\n\x04type\x18\x01\x20\x02(\x05R\x04type\x12\x14\n\
5652    \x05index\x18\x02\x20\x02(\x11R\x05index\x12\x14\n\x05token\x18\x03\x20\
5653    \x02(\tR\x05token\x12\x14\n\x05flags\x18\x04\x20\x03(\x05R\x05flags\x12\
5654    \x1e\n\x07subtype\x18\x05\x20\x01(\x05:\x02-1R\x07subtypeB\0\x12%\n\x0bc\
5655    reature_id\x18\x06\x20\x01(\x05:\x02-1R\ncreatureIdB\0\x12\x1f\n\x08plan\
5656    t_id\x18\x07\x20\x01(\x05:\x02-1R\x07plantIdB\0\x12#\n\nhistfig_id\x18\
5657    \x08\x20\x01(\x05:\x02-1R\thistfigIdB\0\x12#\n\x0bname_prefix\x18\t\x20\
5658    \x01(\t:\0R\nnamePrefixB\0\x12\x1f\n\x0bstate_color\x18\n\x20\x03(\x07R\
5659    \nstateColor\x12\x1d\n\nstate_name\x18\x0b\x20\x03(\tR\tstateName\x12\
5660    \x1b\n\tstate_adj\x18\x0c\x20\x03(\tR\x08stateAdj\x12%\n\x0ereaction_cla\
5661    ss\x18\r\x20\x03(\tR\rreactionClass\x12M\n\x10reaction_product\x18\x0e\
5662    \x20\x03(\x0b2\".dfproto.BasicMaterialInfo.ProductR\x0freactionProduct\
5663    \x12'\n\x0finorganic_flags\x18\x0f\x20\x03(\x05R\x0einorganicFlags\x1aC\
5664    \n\x07Product\x12\x0e\n\x02id\x18\x01\x20\x02(\tR\x02id\x12\x12\n\x04typ\
5665    e\x18\x02\x20\x02(\x05R\x04type\x12\x14\n\x05index\x18\x03\x20\x02(\x11R\
5666    \x05index\"\x99\x02\n\x15BasicMaterialInfoMask\x12@\n\x06states\x18\x01\
5667    \x20\x03(\x0e2(.dfproto.BasicMaterialInfoMask.StateTypeR\x06states\x12)\
5668    \n\x0btemperature\x18\x04\x20\x01(\x05:\x0510015R\x0btemperatureB\0\x12\
5669    \x1d\n\x05flags\x18\x02\x20\x01(\x08:\x05falseR\x05flagsB\0\x12#\n\x08re\
5670    action\x18\x03\x20\x01(\x08:\x05falseR\x08reactionB\0\"O\n\tStateType\
5671    \x12\t\n\x05Solid\x10\0\x12\n\n\x06Liquid\x10\x01\x12\x07\n\x03Gas\x10\
5672    \x02\x12\n\n\x06Powder\x10\x03\x12\t\n\x05Paste\x10\x04\x12\x0b\n\x07Pre\
5673    ssed\x10\x05\"\xb7\x01\n\x0cJobSkillAttr\x12\x0e\n\x02id\x18\x01\x20\x02\
5674    (\x05R\x02id\x12\x10\n\x03key\x18\x02\x20\x02(\tR\x03key\x12\x18\n\x07ca\
5675    ption\x18\x03\x20\x01(\tR\x07caption\x12!\n\x0ccaption_noun\x18\x04\x20\
5676    \x01(\tR\x0bcaptionNoun\x12\x1e\n\nprofession\x18\x05\x20\x01(\x05R\npro\
5677    fession\x12\x14\n\x05labor\x18\x06\x20\x01(\x05R\x05labor\x12\x12\n\x04t\
5678    ype\x18\x07\x20\x01(\tR\x04type\"\xaa\x01\n\x0eProfessionAttr\x12\x0e\n\
5679    \x02id\x18\x01\x20\x02(\x05R\x02id\x12\x10\n\x03key\x18\x02\x20\x02(\tR\
5680    \x03key\x12\x18\n\x07caption\x18\x03\x20\x01(\tR\x07caption\x12\x1a\n\
5681    \x08military\x18\x04\x20\x01(\x08R\x08military\x12(\n\x10can_assign_labo\
5682    r\x18\x05\x20\x01(\x08R\x0ecanAssignLabor\x12\x16\n\x06parent\x18\x06\
5683    \x20\x01(\x05R\x06parent\"K\n\rUnitLaborAttr\x12\x0e\n\x02id\x18\x01\x20\
5684    \x02(\x05R\x02id\x12\x10\n\x03key\x18\x02\x20\x02(\tR\x03key\x12\x18\n\
5685    \x07caption\x18\x03\x20\x01(\tR\x07caption\"\xac\x01\n\x08NameInfo\x12\
5686    \x1d\n\nfirst_name\x18\x01\x20\x01(\tR\tfirstName\x12\x1a\n\x08nickname\
5687    \x18\x02\x20\x01(\tR\x08nickname\x12%\n\x0blanguage_id\x18\x03\x20\x01(\
5688    \x05:\x02-1R\nlanguageIdB\0\x12\x1b\n\tlast_name\x18\x04\x20\x01(\tR\x08\
5689    lastName\x12!\n\x0cenglish_name\x18\x05\x20\x01(\tR\x0benglishName\"Z\n\
5690    \nNameTriple\x12\x16\n\x06normal\x18\x01\x20\x02(\tR\x06normal\x12\x16\n\
5691    \x06plural\x18\x02\x20\x01(\tR\x06plural\x12\x1c\n\tadjective\x18\x03\
5692    \x20\x01(\tR\tadjective\"\xac\x01\n\rUnitCurseInfo\x12\x1b\n\tadd_tags1\
5693    \x18\x01\x20\x02(\x07R\x08addTags1\x12\x1b\n\trem_tags1\x18\x02\x20\x02(\
5694    \x07R\x08remTags1\x12\x1b\n\tadd_tags2\x18\x03\x20\x02(\x07R\x08addTags2\
5695    \x12\x1b\n\trem_tags2\x18\x04\x20\x02(\x07R\x08remTags2\x12'\n\x04name\
5696    \x18\x05\x20\x01(\x0b2\x13.dfproto.NameTripleR\x04name\"Q\n\tSkillInfo\
5697    \x12\x0e\n\x02id\x18\x01\x20\x02(\x05R\x02id\x12\x14\n\x05level\x18\x02\
5698    \x20\x02(\x05R\x05level\x12\x1e\n\nexperience\x18\x03\x20\x02(\x05R\nexp\
5699    erience\"5\n\rUnitMiscTrait\x12\x0e\n\x02id\x18\x01\x20\x02(\x05R\x02id\
5700    \x12\x14\n\x05value\x18\x02\x20\x02(\x05R\x05value\"\x88\x06\n\rBasicUni\
5701    tInfo\x12\x17\n\x07unit_id\x18\x01\x20\x02(\x05R\x06unitId\x12\x13\n\x05\
5702    pos_x\x18\r\x20\x02(\x05R\x04posX\x12\x13\n\x05pos_y\x18\x0e\x20\x02(\
5703    \x05R\x04posY\x12\x13\n\x05pos_z\x18\x0f\x20\x02(\x05R\x04posZ\x12%\n\
5704    \x04name\x18\x02\x20\x01(\x0b2\x11.dfproto.NameInfoR\x04name\x12\x16\n\
5705    \x06flags1\x18\x03\x20\x02(\x07R\x06flags1\x12\x16\n\x06flags2\x18\x04\
5706    \x20\x02(\x07R\x06flags2\x12\x16\n\x06flags3\x18\x05\x20\x02(\x07R\x06fl\
5707    ags3\x12\x12\n\x04race\x18\x06\x20\x02(\x05R\x04race\x12\x14\n\x05caste\
5708    \x18\x07\x20\x02(\x05R\x05caste\x12\x1c\n\x06gender\x18\x08\x20\x01(\x05\
5709    :\x02-1R\x06genderB\0\x12\x1b\n\x06civ_id\x18\t\x20\x01(\x05:\x02-1R\x05\
5710    civIdB\0\x12#\n\nhistfig_id\x18\n\x20\x01(\x05:\x02-1R\thistfigIdB\0\x12\
5711    \x1f\n\x08death_id\x18\x11\x20\x01(\x05:\x02-1R\x07deathIdB\0\x12\x1f\n\
5712    \x0bdeath_flags\x18\x12\x20\x01(\rR\ndeathFlags\x12\x1f\n\x08squad_id\
5713    \x18\x13\x20\x01(\x05:\x02-1R\x07squadIdB\0\x12+\n\x0esquad_position\x18\
5714    \x14\x20\x01(\x05:\x02-1R\rsquadPositionB\0\x12$\n\nprofession\x18\x16\
5715    \x20\x01(\x05:\x02-1R\nprofessionB\0\x12+\n\x11custom_profession\x18\x17\
5716    \x20\x01(\tR\x10customProfession\x12\x16\n\x06labors\x18\x0b\x20\x03(\
5717    \x05R\x06labors\x12*\n\x06skills\x18\x0c\x20\x03(\x0b2\x12.dfproto.Skill\
5718    InfoR\x06skills\x127\n\x0bmisc_traits\x18\x18\x20\x03(\x0b2\x16.dfproto.\
5719    UnitMiscTraitR\nmiscTraits\x12,\n\x05curse\x18\x10\x20\x01(\x0b2\x16.dfp\
5720    roto.UnitCurseInfoR\x05curse\x12\x18\n\x07burrows\x18\x15\x20\x03(\x05R\
5721    \x07burrows\"\xa8\x01\n\x11BasicUnitInfoMask\x12\x1f\n\x06labors\x18\x01\
5722    \x20\x01(\x08:\x05falseR\x06laborsB\0\x12\x1f\n\x06skills\x18\x02\x20\
5723    \x01(\x08:\x05falseR\x06skillsB\0\x12'\n\nprofession\x18\x03\x20\x01(\
5724    \x08:\x05falseR\nprofessionB\0\x12(\n\x0bmisc_traits\x18\x04\x20\x01(\
5725    \x08:\x05falseR\nmiscTraitsB\0\"\x82\x01\n\x0eBasicSquadInfo\x12\x19\n\
5726    \x08squad_id\x18\x01\x20\x02(\x05R\x07squadId\x12%\n\x04name\x18\x02\x20\
5727    \x01(\x0b2\x11.dfproto.NameInfoR\x04name\x12\x14\n\x05alias\x18\x03\x20\
5728    \x01(\tR\x05alias\x12\x18\n\x07members\x18\x04\x20\x03(\x11R\x07members\
5729    \"U\n\x0eUnitLaborState\x12\x17\n\x07unit_id\x18\x01\x20\x02(\x05R\x06un\
5730    itId\x12\x14\n\x05labor\x18\x02\x20\x02(\x05R\x05labor\x12\x14\n\x05valu\
5731    e\x18\x03\x20\x02(\x08R\x05valueB\x02H\x03b\x06proto2\
5732";
5733
5734/// `FileDescriptorProto` object which was a source for this generated file
5735fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
5736    static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
5737    file_descriptor_proto_lazy.get(|| {
5738        ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
5739    })
5740}
5741
5742/// `FileDescriptor` object which allows dynamic access to files
5743pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
5744    static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
5745    static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
5746    file_descriptor.get(|| {
5747        let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
5748            let mut deps = ::std::vec::Vec::with_capacity(0);
5749            let mut messages = ::std::vec::Vec::with_capacity(17);
5750            messages.push(EnumItemName::generated_message_descriptor_data());
5751            messages.push(BasicMaterialId::generated_message_descriptor_data());
5752            messages.push(BasicMaterialInfo::generated_message_descriptor_data());
5753            messages.push(BasicMaterialInfoMask::generated_message_descriptor_data());
5754            messages.push(JobSkillAttr::generated_message_descriptor_data());
5755            messages.push(ProfessionAttr::generated_message_descriptor_data());
5756            messages.push(UnitLaborAttr::generated_message_descriptor_data());
5757            messages.push(NameInfo::generated_message_descriptor_data());
5758            messages.push(NameTriple::generated_message_descriptor_data());
5759            messages.push(UnitCurseInfo::generated_message_descriptor_data());
5760            messages.push(SkillInfo::generated_message_descriptor_data());
5761            messages.push(UnitMiscTrait::generated_message_descriptor_data());
5762            messages.push(BasicUnitInfo::generated_message_descriptor_data());
5763            messages.push(BasicUnitInfoMask::generated_message_descriptor_data());
5764            messages.push(BasicSquadInfo::generated_message_descriptor_data());
5765            messages.push(UnitLaborState::generated_message_descriptor_data());
5766            messages.push(basic_material_info::Product::generated_message_descriptor_data());
5767            let mut enums = ::std::vec::Vec::with_capacity(1);
5768            enums.push(basic_material_info_mask::StateType::generated_enum_descriptor_data());
5769            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
5770                file_descriptor_proto(),
5771                deps,
5772                messages,
5773                enums,
5774            )
5775        });
5776        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
5777    })
5778}
dfhack_proto/generated/messages/Basic.rs

dfhack_proto/generated/messages/
Basic.rs
