fixer_fix/fix50sp2/
contrary_intention_report.rs

1// Code generated by fixer-gen. DO NOT EDIT.
2#![allow(clippy::new_without_default)]
3#![allow(clippy::needless_pass_by_value)]
4#![allow(clippy::too_many_arguments)]
5#![allow(unused_imports)]
6
7use fixer::message::Message;
8use fixer::fix_string::FIXString;
9use fixer::errors::MessageRejectErrorEnum;
10use fixer::session::session_id::SessionID;
11
12use rust_decimal::Decimal;
13
14
15use jiff::Timestamp;
16
17use crate::field;
18use crate::tag;
19
20/// `ContraryIntentionReport` is the `fix50sp2` `ContraryIntentionReport` type, `MsgType` = BO.
21pub struct ContraryIntentionReport {
22    pub message: Message,
23}
24
25impl ContraryIntentionReport {
26    /// Creates a new `ContraryIntentionReport` with required fields.
27    pub fn new(cont_int_rpt_id: field::ContIntRptIDField, clearing_business_date: field::ClearingBusinessDateField) -> Self {
28        let mut msg = Message::new();
29        msg.header.set_field(tag::MSG_TYPE, FIXString::from("BO".to_string()));
30
31        msg.body.set_field(tag::CONT_INT_RPT_ID, cont_int_rpt_id.0);
32
33        msg.body.set_field(tag::CLEARING_BUSINESS_DATE, clearing_business_date.0);
34
35        Self { message: msg }
36    }
37
38    /// Creates a `ContraryIntentionReport` from an existing `Message`.
39    pub fn from_message(msg: Message) -> Self {
40        Self { message: msg }
41    }
42
43    /// Returns the underlying `Message`.
44    pub fn to_message(self) -> Message {
45        self.message
46    }
47
48
49
50
51    /// Sets `ApplID`, Tag 1180.
52    pub fn set_appl_id(&mut self, v: String) {
53        self.message.body.set_field(tag::APPL_ID, FIXString::from(v));
54    }
55
56    /// Gets `ApplID`, Tag 1180.
57    pub fn get_appl_id(&self) -> Result<String, MessageRejectErrorEnum> {
58        let mut fld = field::ApplIDField::new(String::new());
59        self.message.body.get_field(tag::APPL_ID, &mut fld.0)?;
60        Ok(fld.value().to_string())
61    }
62
63
64    /// Returns true if `ApplID` is present, Tag 1180.
65    pub fn has_appl_id(&self) -> bool {
66        self.message.body.has(tag::APPL_ID)
67    }
68
69
70
71
72    /// Sets `ApplLastSeqNum`, Tag 1350.
73    pub fn set_appl_last_seq_num(&mut self, v: isize) {
74        self.message.body.set_field(tag::APPL_LAST_SEQ_NUM, fixer::fix_int::FIXInt::from(v));
75    }
76
77    /// Gets `ApplLastSeqNum`, Tag 1350.
78    pub fn get_appl_last_seq_num(&self) -> Result<isize, MessageRejectErrorEnum> {
79        let mut fld = field::ApplLastSeqNumField::new(0);
80        self.message.body.get_field(tag::APPL_LAST_SEQ_NUM, &mut fld.0)?;
81        Ok(fld.value())
82    }
83
84
85    /// Returns true if `ApplLastSeqNum` is present, Tag 1350.
86    pub fn has_appl_last_seq_num(&self) -> bool {
87        self.message.body.has(tag::APPL_LAST_SEQ_NUM)
88    }
89
90
91
92
93    /// Sets `ApplResendFlag`, Tag 1352.
94    pub fn set_appl_resend_flag(&mut self, v: bool) {
95        self.message.body.set_field(tag::APPL_RESEND_FLAG, fixer::fix_boolean::FIXBoolean::from(v));
96    }
97
98    /// Gets `ApplResendFlag`, Tag 1352.
99    pub fn get_appl_resend_flag(&self) -> Result<bool, MessageRejectErrorEnum> {
100        let mut fld = field::ApplResendFlagField::new(false);
101        self.message.body.get_field(tag::APPL_RESEND_FLAG, &mut fld.0)?;
102        Ok(fld.value())
103    }
104
105
106    /// Returns true if `ApplResendFlag` is present, Tag 1352.
107    pub fn has_appl_resend_flag(&self) -> bool {
108        self.message.body.has(tag::APPL_RESEND_FLAG)
109    }
110
111
112
113
114    /// Sets `ApplSeqNum`, Tag 1181.
115    pub fn set_appl_seq_num(&mut self, v: isize) {
116        self.message.body.set_field(tag::APPL_SEQ_NUM, fixer::fix_int::FIXInt::from(v));
117    }
118
119    /// Gets `ApplSeqNum`, Tag 1181.
120    pub fn get_appl_seq_num(&self) -> Result<isize, MessageRejectErrorEnum> {
121        let mut fld = field::ApplSeqNumField::new(0);
122        self.message.body.get_field(tag::APPL_SEQ_NUM, &mut fld.0)?;
123        Ok(fld.value())
124    }
125
126
127    /// Returns true if `ApplSeqNum` is present, Tag 1181.
128    pub fn has_appl_seq_num(&self) -> bool {
129        self.message.body.has(tag::APPL_SEQ_NUM)
130    }
131
132
133
134
135    /// Sets `AttachmentPoint`, Tag 1457.
136    pub fn set_attachment_point(&mut self, val: Decimal, scale: i32) {
137        self.message.body.set_field(tag::ATTACHMENT_POINT, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
138    }
139
140    /// Gets `AttachmentPoint`, Tag 1457.
141    pub fn get_attachment_point(&self) -> Result<Decimal, MessageRejectErrorEnum> {
142        let mut fld = field::AttachmentPointField::new(Decimal::ZERO, 0);
143        self.message.body.get_field(tag::ATTACHMENT_POINT, &mut fld.0)?;
144        Ok(fld.value())
145    }
146
147
148    /// Returns true if `AttachmentPoint` is present, Tag 1457.
149    pub fn has_attachment_point(&self) -> bool {
150        self.message.body.has(tag::ATTACHMENT_POINT)
151    }
152
153
154
155
156    /// Sets `CFICode`, Tag 461.
157    pub fn set_cfi_code(&mut self, v: String) {
158        self.message.body.set_field(tag::CFI_CODE, FIXString::from(v));
159    }
160
161    /// Gets `CFICode`, Tag 461.
162    pub fn get_cfi_code(&self) -> Result<String, MessageRejectErrorEnum> {
163        let mut fld = field::CFICodeField::new(String::new());
164        self.message.body.get_field(tag::CFI_CODE, &mut fld.0)?;
165        Ok(fld.value().to_string())
166    }
167
168
169    /// Returns true if `CFICode` is present, Tag 461.
170    pub fn has_cfi_code(&self) -> bool {
171        self.message.body.has(tag::CFI_CODE)
172    }
173
174
175
176
177    /// Sets `CPProgram`, Tag 875.
178    pub fn set_cp_program(&mut self, v: isize) {
179        self.message.body.set_field(tag::CP_PROGRAM, fixer::fix_int::FIXInt::from(v));
180    }
181
182    /// Gets `CPProgram`, Tag 875.
183    pub fn get_cp_program(&self) -> Result<isize, MessageRejectErrorEnum> {
184        let mut fld = field::CPProgramField::new(0);
185        self.message.body.get_field(tag::CP_PROGRAM, &mut fld.0)?;
186        Ok(fld.value())
187    }
188
189
190    /// Returns true if `CPProgram` is present, Tag 875.
191    pub fn has_cp_program(&self) -> bool {
192        self.message.body.has(tag::CP_PROGRAM)
193    }
194
195
196
197
198    /// Sets `CPRegType`, Tag 876.
199    pub fn set_cp_reg_type(&mut self, v: String) {
200        self.message.body.set_field(tag::CP_REG_TYPE, FIXString::from(v));
201    }
202
203    /// Gets `CPRegType`, Tag 876.
204    pub fn get_cp_reg_type(&self) -> Result<String, MessageRejectErrorEnum> {
205        let mut fld = field::CPRegTypeField::new(String::new());
206        self.message.body.get_field(tag::CP_REG_TYPE, &mut fld.0)?;
207        Ok(fld.value().to_string())
208    }
209
210
211    /// Returns true if `CPRegType` is present, Tag 876.
212    pub fn has_cp_reg_type(&self) -> bool {
213        self.message.body.has(tag::CP_REG_TYPE)
214    }
215
216
217
218
219    /// Sets `CapPrice`, Tag 1199.
220    pub fn set_cap_price(&mut self, val: Decimal, scale: i32) {
221        self.message.body.set_field(tag::CAP_PRICE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
222    }
223
224    /// Gets `CapPrice`, Tag 1199.
225    pub fn get_cap_price(&self) -> Result<Decimal, MessageRejectErrorEnum> {
226        let mut fld = field::CapPriceField::new(Decimal::ZERO, 0);
227        self.message.body.get_field(tag::CAP_PRICE, &mut fld.0)?;
228        Ok(fld.value())
229    }
230
231
232    /// Returns true if `CapPrice` is present, Tag 1199.
233    pub fn has_cap_price(&self) -> bool {
234        self.message.body.has(tag::CAP_PRICE)
235    }
236
237
238
239
240    /// Sets `ClearingBusinessDate`, Tag 715.
241    pub fn set_clearing_business_date(&mut self, v: String) {
242        self.message.body.set_field(tag::CLEARING_BUSINESS_DATE, FIXString::from(v));
243    }
244
245    /// Gets `ClearingBusinessDate`, Tag 715.
246    pub fn get_clearing_business_date(&self) -> Result<String, MessageRejectErrorEnum> {
247        let mut fld = field::ClearingBusinessDateField::new(String::new());
248        self.message.body.get_field(tag::CLEARING_BUSINESS_DATE, &mut fld.0)?;
249        Ok(fld.value().to_string())
250    }
251
252
253    /// Returns true if `ClearingBusinessDate` is present, Tag 715.
254    pub fn has_clearing_business_date(&self) -> bool {
255        self.message.body.has(tag::CLEARING_BUSINESS_DATE)
256    }
257
258
259
260
261    /// Sets `ContIntRptID`, Tag 977.
262    pub fn set_cont_int_rpt_id(&mut self, v: String) {
263        self.message.body.set_field(tag::CONT_INT_RPT_ID, FIXString::from(v));
264    }
265
266    /// Gets `ContIntRptID`, Tag 977.
267    pub fn get_cont_int_rpt_id(&self) -> Result<String, MessageRejectErrorEnum> {
268        let mut fld = field::ContIntRptIDField::new(String::new());
269        self.message.body.get_field(tag::CONT_INT_RPT_ID, &mut fld.0)?;
270        Ok(fld.value().to_string())
271    }
272
273
274    /// Returns true if `ContIntRptID` is present, Tag 977.
275    pub fn has_cont_int_rpt_id(&self) -> bool {
276        self.message.body.has(tag::CONT_INT_RPT_ID)
277    }
278
279
280
281
282    /// Sets `ContractMultiplier`, Tag 231.
283    pub fn set_contract_multiplier(&mut self, val: Decimal, scale: i32) {
284        self.message.body.set_field(tag::CONTRACT_MULTIPLIER, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
285    }
286
287    /// Gets `ContractMultiplier`, Tag 231.
288    pub fn get_contract_multiplier(&self) -> Result<Decimal, MessageRejectErrorEnum> {
289        let mut fld = field::ContractMultiplierField::new(Decimal::ZERO, 0);
290        self.message.body.get_field(tag::CONTRACT_MULTIPLIER, &mut fld.0)?;
291        Ok(fld.value())
292    }
293
294
295    /// Returns true if `ContractMultiplier` is present, Tag 231.
296    pub fn has_contract_multiplier(&self) -> bool {
297        self.message.body.has(tag::CONTRACT_MULTIPLIER)
298    }
299
300
301
302
303    /// Sets `ContractMultiplierUnit`, Tag 1435.
304    pub fn set_contract_multiplier_unit(&mut self, v: isize) {
305        self.message.body.set_field(tag::CONTRACT_MULTIPLIER_UNIT, fixer::fix_int::FIXInt::from(v));
306    }
307
308    /// Gets `ContractMultiplierUnit`, Tag 1435.
309    pub fn get_contract_multiplier_unit(&self) -> Result<isize, MessageRejectErrorEnum> {
310        let mut fld = field::ContractMultiplierUnitField::new(0);
311        self.message.body.get_field(tag::CONTRACT_MULTIPLIER_UNIT, &mut fld.0)?;
312        Ok(fld.value())
313    }
314
315
316    /// Returns true if `ContractMultiplierUnit` is present, Tag 1435.
317    pub fn has_contract_multiplier_unit(&self) -> bool {
318        self.message.body.has(tag::CONTRACT_MULTIPLIER_UNIT)
319    }
320
321
322
323
324    /// Sets `ContractSettlMonth`, Tag 667.
325    pub fn set_contract_settl_month(&mut self, v: String) {
326        self.message.body.set_field(tag::CONTRACT_SETTL_MONTH, FIXString::from(v));
327    }
328
329    /// Gets `ContractSettlMonth`, Tag 667.
330    pub fn get_contract_settl_month(&self) -> Result<String, MessageRejectErrorEnum> {
331        let mut fld = field::ContractSettlMonthField::new(String::new());
332        self.message.body.get_field(tag::CONTRACT_SETTL_MONTH, &mut fld.0)?;
333        Ok(fld.value().to_string())
334    }
335
336
337    /// Returns true if `ContractSettlMonth` is present, Tag 667.
338    pub fn has_contract_settl_month(&self) -> bool {
339        self.message.body.has(tag::CONTRACT_SETTL_MONTH)
340    }
341
342
343
344
345    /// Sets `CountryOfIssue`, Tag 470.
346    pub fn set_country_of_issue(&mut self, v: String) {
347        self.message.body.set_field(tag::COUNTRY_OF_ISSUE, FIXString::from(v));
348    }
349
350    /// Gets `CountryOfIssue`, Tag 470.
351    pub fn get_country_of_issue(&self) -> Result<String, MessageRejectErrorEnum> {
352        let mut fld = field::CountryOfIssueField::new(String::new());
353        self.message.body.get_field(tag::COUNTRY_OF_ISSUE, &mut fld.0)?;
354        Ok(fld.value().to_string())
355    }
356
357
358    /// Returns true if `CountryOfIssue` is present, Tag 470.
359    pub fn has_country_of_issue(&self) -> bool {
360        self.message.body.has(tag::COUNTRY_OF_ISSUE)
361    }
362
363
364
365
366    /// Sets `CouponPaymentDate`, Tag 224.
367    pub fn set_coupon_payment_date(&mut self, v: String) {
368        self.message.body.set_field(tag::COUPON_PAYMENT_DATE, FIXString::from(v));
369    }
370
371    /// Gets `CouponPaymentDate`, Tag 224.
372    pub fn get_coupon_payment_date(&self) -> Result<String, MessageRejectErrorEnum> {
373        let mut fld = field::CouponPaymentDateField::new(String::new());
374        self.message.body.get_field(tag::COUPON_PAYMENT_DATE, &mut fld.0)?;
375        Ok(fld.value().to_string())
376    }
377
378
379    /// Returns true if `CouponPaymentDate` is present, Tag 224.
380    pub fn has_coupon_payment_date(&self) -> bool {
381        self.message.body.has(tag::COUPON_PAYMENT_DATE)
382    }
383
384
385
386
387    /// Sets `CouponRate`, Tag 223.
388    pub fn set_coupon_rate(&mut self, val: Decimal, scale: i32) {
389        self.message.body.set_field(tag::COUPON_RATE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
390    }
391
392    /// Gets `CouponRate`, Tag 223.
393    pub fn get_coupon_rate(&self) -> Result<Decimal, MessageRejectErrorEnum> {
394        let mut fld = field::CouponRateField::new(Decimal::ZERO, 0);
395        self.message.body.get_field(tag::COUPON_RATE, &mut fld.0)?;
396        Ok(fld.value())
397    }
398
399
400    /// Returns true if `CouponRate` is present, Tag 223.
401    pub fn has_coupon_rate(&self) -> bool {
402        self.message.body.has(tag::COUPON_RATE)
403    }
404
405
406
407
408    /// Sets `CreditRating`, Tag 255.
409    pub fn set_credit_rating(&mut self, v: String) {
410        self.message.body.set_field(tag::CREDIT_RATING, FIXString::from(v));
411    }
412
413    /// Gets `CreditRating`, Tag 255.
414    pub fn get_credit_rating(&self) -> Result<String, MessageRejectErrorEnum> {
415        let mut fld = field::CreditRatingField::new(String::new());
416        self.message.body.get_field(tag::CREDIT_RATING, &mut fld.0)?;
417        Ok(fld.value().to_string())
418    }
419
420
421    /// Returns true if `CreditRating` is present, Tag 255.
422    pub fn has_credit_rating(&self) -> bool {
423        self.message.body.has(tag::CREDIT_RATING)
424    }
425
426
427
428
429    /// Sets `DatedDate`, Tag 873.
430    pub fn set_dated_date(&mut self, v: String) {
431        self.message.body.set_field(tag::DATED_DATE, FIXString::from(v));
432    }
433
434    /// Gets `DatedDate`, Tag 873.
435    pub fn get_dated_date(&self) -> Result<String, MessageRejectErrorEnum> {
436        let mut fld = field::DatedDateField::new(String::new());
437        self.message.body.get_field(tag::DATED_DATE, &mut fld.0)?;
438        Ok(fld.value().to_string())
439    }
440
441
442    /// Returns true if `DatedDate` is present, Tag 873.
443    pub fn has_dated_date(&self) -> bool {
444        self.message.body.has(tag::DATED_DATE)
445    }
446
447
448
449
450    /// Sets `DetachmentPoint`, Tag 1458.
451    pub fn set_detachment_point(&mut self, val: Decimal, scale: i32) {
452        self.message.body.set_field(tag::DETACHMENT_POINT, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
453    }
454
455    /// Gets `DetachmentPoint`, Tag 1458.
456    pub fn get_detachment_point(&self) -> Result<Decimal, MessageRejectErrorEnum> {
457        let mut fld = field::DetachmentPointField::new(Decimal::ZERO, 0);
458        self.message.body.get_field(tag::DETACHMENT_POINT, &mut fld.0)?;
459        Ok(fld.value())
460    }
461
462
463    /// Returns true if `DetachmentPoint` is present, Tag 1458.
464    pub fn has_detachment_point(&self) -> bool {
465        self.message.body.has(tag::DETACHMENT_POINT)
466    }
467
468
469
470
471    /// Sets `EncodedIssuer`, Tag 349.
472    pub fn set_encoded_issuer(&mut self, v: String) {
473        self.message.body.set_field(tag::ENCODED_ISSUER, FIXString::from(v));
474    }
475
476    /// Gets `EncodedIssuer`, Tag 349.
477    pub fn get_encoded_issuer(&self) -> Result<String, MessageRejectErrorEnum> {
478        let mut fld = field::EncodedIssuerField::new(String::new());
479        self.message.body.get_field(tag::ENCODED_ISSUER, &mut fld.0)?;
480        Ok(fld.value().to_string())
481    }
482
483
484    /// Returns true if `EncodedIssuer` is present, Tag 349.
485    pub fn has_encoded_issuer(&self) -> bool {
486        self.message.body.has(tag::ENCODED_ISSUER)
487    }
488
489
490
491
492    /// Sets `EncodedIssuerLen`, Tag 348.
493    pub fn set_encoded_issuer_len(&mut self, v: isize) {
494        self.message.body.set_field(tag::ENCODED_ISSUER_LEN, fixer::fix_int::FIXInt::from(v));
495    }
496
497    /// Gets `EncodedIssuerLen`, Tag 348.
498    pub fn get_encoded_issuer_len(&self) -> Result<isize, MessageRejectErrorEnum> {
499        let mut fld = field::EncodedIssuerLenField::new(0);
500        self.message.body.get_field(tag::ENCODED_ISSUER_LEN, &mut fld.0)?;
501        Ok(fld.value())
502    }
503
504
505    /// Returns true if `EncodedIssuerLen` is present, Tag 348.
506    pub fn has_encoded_issuer_len(&self) -> bool {
507        self.message.body.has(tag::ENCODED_ISSUER_LEN)
508    }
509
510
511
512
513    /// Sets `EncodedSecurityDesc`, Tag 351.
514    pub fn set_encoded_security_desc(&mut self, v: String) {
515        self.message.body.set_field(tag::ENCODED_SECURITY_DESC, FIXString::from(v));
516    }
517
518    /// Gets `EncodedSecurityDesc`, Tag 351.
519    pub fn get_encoded_security_desc(&self) -> Result<String, MessageRejectErrorEnum> {
520        let mut fld = field::EncodedSecurityDescField::new(String::new());
521        self.message.body.get_field(tag::ENCODED_SECURITY_DESC, &mut fld.0)?;
522        Ok(fld.value().to_string())
523    }
524
525
526    /// Returns true if `EncodedSecurityDesc` is present, Tag 351.
527    pub fn has_encoded_security_desc(&self) -> bool {
528        self.message.body.has(tag::ENCODED_SECURITY_DESC)
529    }
530
531
532
533
534    /// Sets `EncodedSecurityDescLen`, Tag 350.
535    pub fn set_encoded_security_desc_len(&mut self, v: isize) {
536        self.message.body.set_field(tag::ENCODED_SECURITY_DESC_LEN, fixer::fix_int::FIXInt::from(v));
537    }
538
539    /// Gets `EncodedSecurityDescLen`, Tag 350.
540    pub fn get_encoded_security_desc_len(&self) -> Result<isize, MessageRejectErrorEnum> {
541        let mut fld = field::EncodedSecurityDescLenField::new(0);
542        self.message.body.get_field(tag::ENCODED_SECURITY_DESC_LEN, &mut fld.0)?;
543        Ok(fld.value())
544    }
545
546
547    /// Returns true if `EncodedSecurityDescLen` is present, Tag 350.
548    pub fn has_encoded_security_desc_len(&self) -> bool {
549        self.message.body.has(tag::ENCODED_SECURITY_DESC_LEN)
550    }
551
552
553
554
555    /// Sets `EncodedText`, Tag 355.
556    pub fn set_encoded_text(&mut self, v: String) {
557        self.message.body.set_field(tag::ENCODED_TEXT, FIXString::from(v));
558    }
559
560    /// Gets `EncodedText`, Tag 355.
561    pub fn get_encoded_text(&self) -> Result<String, MessageRejectErrorEnum> {
562        let mut fld = field::EncodedTextField::new(String::new());
563        self.message.body.get_field(tag::ENCODED_TEXT, &mut fld.0)?;
564        Ok(fld.value().to_string())
565    }
566
567
568    /// Returns true if `EncodedText` is present, Tag 355.
569    pub fn has_encoded_text(&self) -> bool {
570        self.message.body.has(tag::ENCODED_TEXT)
571    }
572
573
574
575
576    /// Sets `EncodedTextLen`, Tag 354.
577    pub fn set_encoded_text_len(&mut self, v: isize) {
578        self.message.body.set_field(tag::ENCODED_TEXT_LEN, fixer::fix_int::FIXInt::from(v));
579    }
580
581    /// Gets `EncodedTextLen`, Tag 354.
582    pub fn get_encoded_text_len(&self) -> Result<isize, MessageRejectErrorEnum> {
583        let mut fld = field::EncodedTextLenField::new(0);
584        self.message.body.get_field(tag::ENCODED_TEXT_LEN, &mut fld.0)?;
585        Ok(fld.value())
586    }
587
588
589    /// Returns true if `EncodedTextLen` is present, Tag 354.
590    pub fn has_encoded_text_len(&self) -> bool {
591        self.message.body.has(tag::ENCODED_TEXT_LEN)
592    }
593
594
595
596
597    /// Sets `ExerciseStyle`, Tag 1194.
598    pub fn set_exercise_style(&mut self, v: isize) {
599        self.message.body.set_field(tag::EXERCISE_STYLE, fixer::fix_int::FIXInt::from(v));
600    }
601
602    /// Gets `ExerciseStyle`, Tag 1194.
603    pub fn get_exercise_style(&self) -> Result<isize, MessageRejectErrorEnum> {
604        let mut fld = field::ExerciseStyleField::new(0);
605        self.message.body.get_field(tag::EXERCISE_STYLE, &mut fld.0)?;
606        Ok(fld.value())
607    }
608
609
610    /// Returns true if `ExerciseStyle` is present, Tag 1194.
611    pub fn has_exercise_style(&self) -> bool {
612        self.message.body.has(tag::EXERCISE_STYLE)
613    }
614
615
616
617
618    /// Sets `Factor`, Tag 228.
619    pub fn set_factor(&mut self, val: Decimal, scale: i32) {
620        self.message.body.set_field(tag::FACTOR, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
621    }
622
623    /// Gets `Factor`, Tag 228.
624    pub fn get_factor(&self) -> Result<Decimal, MessageRejectErrorEnum> {
625        let mut fld = field::FactorField::new(Decimal::ZERO, 0);
626        self.message.body.get_field(tag::FACTOR, &mut fld.0)?;
627        Ok(fld.value())
628    }
629
630
631    /// Returns true if `Factor` is present, Tag 228.
632    pub fn has_factor(&self) -> bool {
633        self.message.body.has(tag::FACTOR)
634    }
635
636
637
638
639    /// Sets `FlexProductEligibilityIndicator`, Tag 1242.
640    pub fn set_flex_product_eligibility_indicator(&mut self, v: bool) {
641        self.message.body.set_field(tag::FLEX_PRODUCT_ELIGIBILITY_INDICATOR, fixer::fix_boolean::FIXBoolean::from(v));
642    }
643
644    /// Gets `FlexProductEligibilityIndicator`, Tag 1242.
645    pub fn get_flex_product_eligibility_indicator(&self) -> Result<bool, MessageRejectErrorEnum> {
646        let mut fld = field::FlexProductEligibilityIndicatorField::new(false);
647        self.message.body.get_field(tag::FLEX_PRODUCT_ELIGIBILITY_INDICATOR, &mut fld.0)?;
648        Ok(fld.value())
649    }
650
651
652    /// Returns true if `FlexProductEligibilityIndicator` is present, Tag 1242.
653    pub fn has_flex_product_eligibility_indicator(&self) -> bool {
654        self.message.body.has(tag::FLEX_PRODUCT_ELIGIBILITY_INDICATOR)
655    }
656
657
658
659
660    /// Sets `FlexibleIndicator`, Tag 1244.
661    pub fn set_flexible_indicator(&mut self, v: bool) {
662        self.message.body.set_field(tag::FLEXIBLE_INDICATOR, fixer::fix_boolean::FIXBoolean::from(v));
663    }
664
665    /// Gets `FlexibleIndicator`, Tag 1244.
666    pub fn get_flexible_indicator(&self) -> Result<bool, MessageRejectErrorEnum> {
667        let mut fld = field::FlexibleIndicatorField::new(false);
668        self.message.body.get_field(tag::FLEXIBLE_INDICATOR, &mut fld.0)?;
669        Ok(fld.value())
670    }
671
672
673    /// Returns true if `FlexibleIndicator` is present, Tag 1244.
674    pub fn has_flexible_indicator(&self) -> bool {
675        self.message.body.has(tag::FLEXIBLE_INDICATOR)
676    }
677
678
679
680
681    /// Sets `FloorPrice`, Tag 1200.
682    pub fn set_floor_price(&mut self, val: Decimal, scale: i32) {
683        self.message.body.set_field(tag::FLOOR_PRICE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
684    }
685
686    /// Gets `FloorPrice`, Tag 1200.
687    pub fn get_floor_price(&self) -> Result<Decimal, MessageRejectErrorEnum> {
688        let mut fld = field::FloorPriceField::new(Decimal::ZERO, 0);
689        self.message.body.get_field(tag::FLOOR_PRICE, &mut fld.0)?;
690        Ok(fld.value())
691    }
692
693
694    /// Returns true if `FloorPrice` is present, Tag 1200.
695    pub fn has_floor_price(&self) -> bool {
696        self.message.body.has(tag::FLOOR_PRICE)
697    }
698
699
700
701
702    /// Sets `FlowScheduleType`, Tag 1439.
703    pub fn set_flow_schedule_type(&mut self, v: isize) {
704        self.message.body.set_field(tag::FLOW_SCHEDULE_TYPE, fixer::fix_int::FIXInt::from(v));
705    }
706
707    /// Gets `FlowScheduleType`, Tag 1439.
708    pub fn get_flow_schedule_type(&self) -> Result<isize, MessageRejectErrorEnum> {
709        let mut fld = field::FlowScheduleTypeField::new(0);
710        self.message.body.get_field(tag::FLOW_SCHEDULE_TYPE, &mut fld.0)?;
711        Ok(fld.value())
712    }
713
714
715    /// Returns true if `FlowScheduleType` is present, Tag 1439.
716    pub fn has_flow_schedule_type(&self) -> bool {
717        self.message.body.has(tag::FLOW_SCHEDULE_TYPE)
718    }
719
720
721
722
723    /// Sets `InputSource`, Tag 979.
724    pub fn set_input_source(&mut self, v: String) {
725        self.message.body.set_field(tag::INPUT_SOURCE, FIXString::from(v));
726    }
727
728    /// Gets `InputSource`, Tag 979.
729    pub fn get_input_source(&self) -> Result<String, MessageRejectErrorEnum> {
730        let mut fld = field::InputSourceField::new(String::new());
731        self.message.body.get_field(tag::INPUT_SOURCE, &mut fld.0)?;
732        Ok(fld.value().to_string())
733    }
734
735
736    /// Returns true if `InputSource` is present, Tag 979.
737    pub fn has_input_source(&self) -> bool {
738        self.message.body.has(tag::INPUT_SOURCE)
739    }
740
741
742
743
744    /// Sets `InstrRegistry`, Tag 543.
745    pub fn set_instr_registry(&mut self, v: String) {
746        self.message.body.set_field(tag::INSTR_REGISTRY, FIXString::from(v));
747    }
748
749    /// Gets `InstrRegistry`, Tag 543.
750    pub fn get_instr_registry(&self) -> Result<String, MessageRejectErrorEnum> {
751        let mut fld = field::InstrRegistryField::new(String::new());
752        self.message.body.get_field(tag::INSTR_REGISTRY, &mut fld.0)?;
753        Ok(fld.value().to_string())
754    }
755
756
757    /// Returns true if `InstrRegistry` is present, Tag 543.
758    pub fn has_instr_registry(&self) -> bool {
759        self.message.body.has(tag::INSTR_REGISTRY)
760    }
761
762
763
764
765    /// Sets `InstrmtAssignmentMethod`, Tag 1049.
766    pub fn set_instrmt_assignment_method(&mut self, v: String) {
767        self.message.body.set_field(tag::INSTRMT_ASSIGNMENT_METHOD, FIXString::from(v));
768    }
769
770    /// Gets `InstrmtAssignmentMethod`, Tag 1049.
771    pub fn get_instrmt_assignment_method(&self) -> Result<String, MessageRejectErrorEnum> {
772        let mut fld = field::InstrmtAssignmentMethodField::new(String::new());
773        self.message.body.get_field(tag::INSTRMT_ASSIGNMENT_METHOD, &mut fld.0)?;
774        Ok(fld.value().to_string())
775    }
776
777
778    /// Returns true if `InstrmtAssignmentMethod` is present, Tag 1049.
779    pub fn has_instrmt_assignment_method(&self) -> bool {
780        self.message.body.has(tag::INSTRMT_ASSIGNMENT_METHOD)
781    }
782
783
784
785
786    /// Sets `InterestAccrualDate`, Tag 874.
787    pub fn set_interest_accrual_date(&mut self, v: String) {
788        self.message.body.set_field(tag::INTEREST_ACCRUAL_DATE, FIXString::from(v));
789    }
790
791    /// Gets `InterestAccrualDate`, Tag 874.
792    pub fn get_interest_accrual_date(&self) -> Result<String, MessageRejectErrorEnum> {
793        let mut fld = field::InterestAccrualDateField::new(String::new());
794        self.message.body.get_field(tag::INTEREST_ACCRUAL_DATE, &mut fld.0)?;
795        Ok(fld.value().to_string())
796    }
797
798
799    /// Returns true if `InterestAccrualDate` is present, Tag 874.
800    pub fn has_interest_accrual_date(&self) -> bool {
801        self.message.body.has(tag::INTEREST_ACCRUAL_DATE)
802    }
803
804
805
806
807    /// Sets `IssueDate`, Tag 225.
808    pub fn set_issue_date(&mut self, v: String) {
809        self.message.body.set_field(tag::ISSUE_DATE, FIXString::from(v));
810    }
811
812    /// Gets `IssueDate`, Tag 225.
813    pub fn get_issue_date(&self) -> Result<String, MessageRejectErrorEnum> {
814        let mut fld = field::IssueDateField::new(String::new());
815        self.message.body.get_field(tag::ISSUE_DATE, &mut fld.0)?;
816        Ok(fld.value().to_string())
817    }
818
819
820    /// Returns true if `IssueDate` is present, Tag 225.
821    pub fn has_issue_date(&self) -> bool {
822        self.message.body.has(tag::ISSUE_DATE)
823    }
824
825
826
827
828    /// Sets `Issuer`, Tag 106.
829    pub fn set_issuer(&mut self, v: String) {
830        self.message.body.set_field(tag::ISSUER, FIXString::from(v));
831    }
832
833    /// Gets `Issuer`, Tag 106.
834    pub fn get_issuer(&self) -> Result<String, MessageRejectErrorEnum> {
835        let mut fld = field::IssuerField::new(String::new());
836        self.message.body.get_field(tag::ISSUER, &mut fld.0)?;
837        Ok(fld.value().to_string())
838    }
839
840
841    /// Returns true if `Issuer` is present, Tag 106.
842    pub fn has_issuer(&self) -> bool {
843        self.message.body.has(tag::ISSUER)
844    }
845
846
847
848
849    /// Sets `LateIndicator`, Tag 978.
850    pub fn set_late_indicator(&mut self, v: bool) {
851        self.message.body.set_field(tag::LATE_INDICATOR, fixer::fix_boolean::FIXBoolean::from(v));
852    }
853
854    /// Gets `LateIndicator`, Tag 978.
855    pub fn get_late_indicator(&self) -> Result<bool, MessageRejectErrorEnum> {
856        let mut fld = field::LateIndicatorField::new(false);
857        self.message.body.get_field(tag::LATE_INDICATOR, &mut fld.0)?;
858        Ok(fld.value())
859    }
860
861
862    /// Returns true if `LateIndicator` is present, Tag 978.
863    pub fn has_late_indicator(&self) -> bool {
864        self.message.body.has(tag::LATE_INDICATOR)
865    }
866
867
868
869
870    /// Sets `ListMethod`, Tag 1198.
871    pub fn set_list_method(&mut self, v: isize) {
872        self.message.body.set_field(tag::LIST_METHOD, fixer::fix_int::FIXInt::from(v));
873    }
874
875    /// Gets `ListMethod`, Tag 1198.
876    pub fn get_list_method(&self) -> Result<isize, MessageRejectErrorEnum> {
877        let mut fld = field::ListMethodField::new(0);
878        self.message.body.get_field(tag::LIST_METHOD, &mut fld.0)?;
879        Ok(fld.value())
880    }
881
882
883    /// Returns true if `ListMethod` is present, Tag 1198.
884    pub fn has_list_method(&self) -> bool {
885        self.message.body.has(tag::LIST_METHOD)
886    }
887
888
889
890
891    /// Sets `LocaleOfIssue`, Tag 472.
892    pub fn set_locale_of_issue(&mut self, v: String) {
893        self.message.body.set_field(tag::LOCALE_OF_ISSUE, FIXString::from(v));
894    }
895
896    /// Gets `LocaleOfIssue`, Tag 472.
897    pub fn get_locale_of_issue(&self) -> Result<String, MessageRejectErrorEnum> {
898        let mut fld = field::LocaleOfIssueField::new(String::new());
899        self.message.body.get_field(tag::LOCALE_OF_ISSUE, &mut fld.0)?;
900        Ok(fld.value().to_string())
901    }
902
903
904    /// Returns true if `LocaleOfIssue` is present, Tag 472.
905    pub fn has_locale_of_issue(&self) -> bool {
906        self.message.body.has(tag::LOCALE_OF_ISSUE)
907    }
908
909
910
911
912    /// Sets `MaturityDate`, Tag 541.
913    pub fn set_maturity_date(&mut self, v: String) {
914        self.message.body.set_field(tag::MATURITY_DATE, FIXString::from(v));
915    }
916
917    /// Gets `MaturityDate`, Tag 541.
918    pub fn get_maturity_date(&self) -> Result<String, MessageRejectErrorEnum> {
919        let mut fld = field::MaturityDateField::new(String::new());
920        self.message.body.get_field(tag::MATURITY_DATE, &mut fld.0)?;
921        Ok(fld.value().to_string())
922    }
923
924
925    /// Returns true if `MaturityDate` is present, Tag 541.
926    pub fn has_maturity_date(&self) -> bool {
927        self.message.body.has(tag::MATURITY_DATE)
928    }
929
930
931
932
933    /// Sets `MaturityMonthYear`, Tag 200.
934    pub fn set_maturity_month_year(&mut self, v: String) {
935        self.message.body.set_field(tag::MATURITY_MONTH_YEAR, FIXString::from(v));
936    }
937
938    /// Gets `MaturityMonthYear`, Tag 200.
939    pub fn get_maturity_month_year(&self) -> Result<String, MessageRejectErrorEnum> {
940        let mut fld = field::MaturityMonthYearField::new(String::new());
941        self.message.body.get_field(tag::MATURITY_MONTH_YEAR, &mut fld.0)?;
942        Ok(fld.value().to_string())
943    }
944
945
946    /// Returns true if `MaturityMonthYear` is present, Tag 200.
947    pub fn has_maturity_month_year(&self) -> bool {
948        self.message.body.has(tag::MATURITY_MONTH_YEAR)
949    }
950
951
952
953
954    /// Sets `MaturityTime`, Tag 1079.
955    pub fn set_maturity_time(&mut self, v: String) {
956        self.message.body.set_field(tag::MATURITY_TIME, FIXString::from(v));
957    }
958
959    /// Gets `MaturityTime`, Tag 1079.
960    pub fn get_maturity_time(&self) -> Result<String, MessageRejectErrorEnum> {
961        let mut fld = field::MaturityTimeField::new(String::new());
962        self.message.body.get_field(tag::MATURITY_TIME, &mut fld.0)?;
963        Ok(fld.value().to_string())
964    }
965
966
967    /// Returns true if `MaturityTime` is present, Tag 1079.
968    pub fn has_maturity_time(&self) -> bool {
969        self.message.body.has(tag::MATURITY_TIME)
970    }
971
972
973
974
975    /// Sets `MinPriceIncrement`, Tag 969.
976    pub fn set_min_price_increment(&mut self, val: Decimal, scale: i32) {
977        self.message.body.set_field(tag::MIN_PRICE_INCREMENT, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
978    }
979
980    /// Gets `MinPriceIncrement`, Tag 969.
981    pub fn get_min_price_increment(&self) -> Result<Decimal, MessageRejectErrorEnum> {
982        let mut fld = field::MinPriceIncrementField::new(Decimal::ZERO, 0);
983        self.message.body.get_field(tag::MIN_PRICE_INCREMENT, &mut fld.0)?;
984        Ok(fld.value())
985    }
986
987
988    /// Returns true if `MinPriceIncrement` is present, Tag 969.
989    pub fn has_min_price_increment(&self) -> bool {
990        self.message.body.has(tag::MIN_PRICE_INCREMENT)
991    }
992
993
994
995
996    /// Sets `MinPriceIncrementAmount`, Tag 1146.
997    pub fn set_min_price_increment_amount(&mut self, val: Decimal, scale: i32) {
998        self.message.body.set_field(tag::MIN_PRICE_INCREMENT_AMOUNT, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
999    }
1000
1001    /// Gets `MinPriceIncrementAmount`, Tag 1146.
1002    pub fn get_min_price_increment_amount(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1003        let mut fld = field::MinPriceIncrementAmountField::new(Decimal::ZERO, 0);
1004        self.message.body.get_field(tag::MIN_PRICE_INCREMENT_AMOUNT, &mut fld.0)?;
1005        Ok(fld.value())
1006    }
1007
1008
1009    /// Returns true if `MinPriceIncrementAmount` is present, Tag 1146.
1010    pub fn has_min_price_increment_amount(&self) -> bool {
1011        self.message.body.has(tag::MIN_PRICE_INCREMENT_AMOUNT)
1012    }
1013
1014
1015
1016
1017    /// Sets `NTPositionLimit`, Tag 971.
1018    pub fn set_nt_position_limit(&mut self, v: isize) {
1019        self.message.body.set_field(tag::NT_POSITION_LIMIT, fixer::fix_int::FIXInt::from(v));
1020    }
1021
1022    /// Gets `NTPositionLimit`, Tag 971.
1023    pub fn get_nt_position_limit(&self) -> Result<isize, MessageRejectErrorEnum> {
1024        let mut fld = field::NTPositionLimitField::new(0);
1025        self.message.body.get_field(tag::NT_POSITION_LIMIT, &mut fld.0)?;
1026        Ok(fld.value())
1027    }
1028
1029
1030    /// Returns true if `NTPositionLimit` is present, Tag 971.
1031    pub fn has_nt_position_limit(&self) -> bool {
1032        self.message.body.has(tag::NT_POSITION_LIMIT)
1033    }
1034
1035
1036
1037
1038    /// Sets `NoComplexEvents`, Tag 1483.
1039    pub fn set_no_complex_events(&mut self, v: isize) {
1040        self.message.body.set_field(tag::NO_COMPLEX_EVENTS, fixer::fix_int::FIXInt::from(v));
1041    }
1042
1043    /// Gets `NoComplexEvents`, Tag 1483.
1044    pub fn get_no_complex_events(&self) -> Result<isize, MessageRejectErrorEnum> {
1045        let mut fld = field::NoComplexEventsField::new(0);
1046        self.message.body.get_field(tag::NO_COMPLEX_EVENTS, &mut fld.0)?;
1047        Ok(fld.value())
1048    }
1049
1050
1051    /// Returns true if `NoComplexEvents` is present, Tag 1483.
1052    pub fn has_no_complex_events(&self) -> bool {
1053        self.message.body.has(tag::NO_COMPLEX_EVENTS)
1054    }
1055
1056
1057
1058
1059    /// Sets `NoEvents`, Tag 864.
1060    pub fn set_no_events(&mut self, v: isize) {
1061        self.message.body.set_field(tag::NO_EVENTS, fixer::fix_int::FIXInt::from(v));
1062    }
1063
1064    /// Gets `NoEvents`, Tag 864.
1065    pub fn get_no_events(&self) -> Result<isize, MessageRejectErrorEnum> {
1066        let mut fld = field::NoEventsField::new(0);
1067        self.message.body.get_field(tag::NO_EVENTS, &mut fld.0)?;
1068        Ok(fld.value())
1069    }
1070
1071
1072    /// Returns true if `NoEvents` is present, Tag 864.
1073    pub fn has_no_events(&self) -> bool {
1074        self.message.body.has(tag::NO_EVENTS)
1075    }
1076
1077
1078
1079
1080    /// Sets `NoExpiration`, Tag 981.
1081    pub fn set_no_expiration(&mut self, v: isize) {
1082        self.message.body.set_field(tag::NO_EXPIRATION, fixer::fix_int::FIXInt::from(v));
1083    }
1084
1085    /// Gets `NoExpiration`, Tag 981.
1086    pub fn get_no_expiration(&self) -> Result<isize, MessageRejectErrorEnum> {
1087        let mut fld = field::NoExpirationField::new(0);
1088        self.message.body.get_field(tag::NO_EXPIRATION, &mut fld.0)?;
1089        Ok(fld.value())
1090    }
1091
1092
1093    /// Returns true if `NoExpiration` is present, Tag 981.
1094    pub fn has_no_expiration(&self) -> bool {
1095        self.message.body.has(tag::NO_EXPIRATION)
1096    }
1097
1098
1099
1100
1101    /// Sets `NoInstrumentParties`, Tag 1018.
1102    pub fn set_no_instrument_parties(&mut self, v: isize) {
1103        self.message.body.set_field(tag::NO_INSTRUMENT_PARTIES, fixer::fix_int::FIXInt::from(v));
1104    }
1105
1106    /// Gets `NoInstrumentParties`, Tag 1018.
1107    pub fn get_no_instrument_parties(&self) -> Result<isize, MessageRejectErrorEnum> {
1108        let mut fld = field::NoInstrumentPartiesField::new(0);
1109        self.message.body.get_field(tag::NO_INSTRUMENT_PARTIES, &mut fld.0)?;
1110        Ok(fld.value())
1111    }
1112
1113
1114    /// Returns true if `NoInstrumentParties` is present, Tag 1018.
1115    pub fn has_no_instrument_parties(&self) -> bool {
1116        self.message.body.has(tag::NO_INSTRUMENT_PARTIES)
1117    }
1118
1119
1120
1121
1122    /// Sets `NoPartyIDs`, Tag 453.
1123    pub fn set_no_party_i_ds(&mut self, v: isize) {
1124        self.message.body.set_field(tag::NO_PARTY_I_DS, fixer::fix_int::FIXInt::from(v));
1125    }
1126
1127    /// Gets `NoPartyIDs`, Tag 453.
1128    pub fn get_no_party_i_ds(&self) -> Result<isize, MessageRejectErrorEnum> {
1129        let mut fld = field::NoPartyIDsField::new(0);
1130        self.message.body.get_field(tag::NO_PARTY_I_DS, &mut fld.0)?;
1131        Ok(fld.value())
1132    }
1133
1134
1135    /// Returns true if `NoPartyIDs` is present, Tag 453.
1136    pub fn has_no_party_i_ds(&self) -> bool {
1137        self.message.body.has(tag::NO_PARTY_I_DS)
1138    }
1139
1140
1141
1142
1143    /// Sets `NoSecurityAltID`, Tag 454.
1144    pub fn set_no_security_alt_id(&mut self, v: isize) {
1145        self.message.body.set_field(tag::NO_SECURITY_ALT_ID, fixer::fix_int::FIXInt::from(v));
1146    }
1147
1148    /// Gets `NoSecurityAltID`, Tag 454.
1149    pub fn get_no_security_alt_id(&self) -> Result<isize, MessageRejectErrorEnum> {
1150        let mut fld = field::NoSecurityAltIDField::new(0);
1151        self.message.body.get_field(tag::NO_SECURITY_ALT_ID, &mut fld.0)?;
1152        Ok(fld.value())
1153    }
1154
1155
1156    /// Returns true if `NoSecurityAltID` is present, Tag 454.
1157    pub fn has_no_security_alt_id(&self) -> bool {
1158        self.message.body.has(tag::NO_SECURITY_ALT_ID)
1159    }
1160
1161
1162
1163
1164    /// Sets `NoUnderlyings`, Tag 711.
1165    pub fn set_no_underlyings(&mut self, v: isize) {
1166        self.message.body.set_field(tag::NO_UNDERLYINGS, fixer::fix_int::FIXInt::from(v));
1167    }
1168
1169    /// Gets `NoUnderlyings`, Tag 711.
1170    pub fn get_no_underlyings(&self) -> Result<isize, MessageRejectErrorEnum> {
1171        let mut fld = field::NoUnderlyingsField::new(0);
1172        self.message.body.get_field(tag::NO_UNDERLYINGS, &mut fld.0)?;
1173        Ok(fld.value())
1174    }
1175
1176
1177    /// Returns true if `NoUnderlyings` is present, Tag 711.
1178    pub fn has_no_underlyings(&self) -> bool {
1179        self.message.body.has(tag::NO_UNDERLYINGS)
1180    }
1181
1182
1183
1184
1185    /// Sets `NotionalPercentageOutstanding`, Tag 1451.
1186    pub fn set_notional_percentage_outstanding(&mut self, val: Decimal, scale: i32) {
1187        self.message.body.set_field(tag::NOTIONAL_PERCENTAGE_OUTSTANDING, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1188    }
1189
1190    /// Gets `NotionalPercentageOutstanding`, Tag 1451.
1191    pub fn get_notional_percentage_outstanding(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1192        let mut fld = field::NotionalPercentageOutstandingField::new(Decimal::ZERO, 0);
1193        self.message.body.get_field(tag::NOTIONAL_PERCENTAGE_OUTSTANDING, &mut fld.0)?;
1194        Ok(fld.value())
1195    }
1196
1197
1198    /// Returns true if `NotionalPercentageOutstanding` is present, Tag 1451.
1199    pub fn has_notional_percentage_outstanding(&self) -> bool {
1200        self.message.body.has(tag::NOTIONAL_PERCENTAGE_OUTSTANDING)
1201    }
1202
1203
1204
1205
1206    /// Sets `OptAttribute`, Tag 206.
1207    pub fn set_opt_attribute(&mut self, v: String) {
1208        self.message.body.set_field(tag::OPT_ATTRIBUTE, FIXString::from(v));
1209    }
1210
1211    /// Gets `OptAttribute`, Tag 206.
1212    pub fn get_opt_attribute(&self) -> Result<String, MessageRejectErrorEnum> {
1213        let mut fld = field::OptAttributeField::new(String::new());
1214        self.message.body.get_field(tag::OPT_ATTRIBUTE, &mut fld.0)?;
1215        Ok(fld.value().to_string())
1216    }
1217
1218
1219    /// Returns true if `OptAttribute` is present, Tag 206.
1220    pub fn has_opt_attribute(&self) -> bool {
1221        self.message.body.has(tag::OPT_ATTRIBUTE)
1222    }
1223
1224
1225
1226
1227    /// Sets `OptPayoutAmount`, Tag 1195.
1228    pub fn set_opt_payout_amount(&mut self, val: Decimal, scale: i32) {
1229        self.message.body.set_field(tag::OPT_PAYOUT_AMOUNT, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1230    }
1231
1232    /// Gets `OptPayoutAmount`, Tag 1195.
1233    pub fn get_opt_payout_amount(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1234        let mut fld = field::OptPayoutAmountField::new(Decimal::ZERO, 0);
1235        self.message.body.get_field(tag::OPT_PAYOUT_AMOUNT, &mut fld.0)?;
1236        Ok(fld.value())
1237    }
1238
1239
1240    /// Returns true if `OptPayoutAmount` is present, Tag 1195.
1241    pub fn has_opt_payout_amount(&self) -> bool {
1242        self.message.body.has(tag::OPT_PAYOUT_AMOUNT)
1243    }
1244
1245
1246
1247
1248    /// Sets `OptPayoutType`, Tag 1482.
1249    pub fn set_opt_payout_type(&mut self, v: isize) {
1250        self.message.body.set_field(tag::OPT_PAYOUT_TYPE, fixer::fix_int::FIXInt::from(v));
1251    }
1252
1253    /// Gets `OptPayoutType`, Tag 1482.
1254    pub fn get_opt_payout_type(&self) -> Result<isize, MessageRejectErrorEnum> {
1255        let mut fld = field::OptPayoutTypeField::new(0);
1256        self.message.body.get_field(tag::OPT_PAYOUT_TYPE, &mut fld.0)?;
1257        Ok(fld.value())
1258    }
1259
1260
1261    /// Returns true if `OptPayoutType` is present, Tag 1482.
1262    pub fn has_opt_payout_type(&self) -> bool {
1263        self.message.body.has(tag::OPT_PAYOUT_TYPE)
1264    }
1265
1266
1267
1268
1269    /// Sets `OriginalNotionalPercentageOutstanding`, Tag 1452.
1270    pub fn set_original_notional_percentage_outstanding(&mut self, val: Decimal, scale: i32) {
1271        self.message.body.set_field(tag::ORIGINAL_NOTIONAL_PERCENTAGE_OUTSTANDING, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1272    }
1273
1274    /// Gets `OriginalNotionalPercentageOutstanding`, Tag 1452.
1275    pub fn get_original_notional_percentage_outstanding(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1276        let mut fld = field::OriginalNotionalPercentageOutstandingField::new(Decimal::ZERO, 0);
1277        self.message.body.get_field(tag::ORIGINAL_NOTIONAL_PERCENTAGE_OUTSTANDING, &mut fld.0)?;
1278        Ok(fld.value())
1279    }
1280
1281
1282    /// Returns true if `OriginalNotionalPercentageOutstanding` is present, Tag 1452.
1283    pub fn has_original_notional_percentage_outstanding(&self) -> bool {
1284        self.message.body.has(tag::ORIGINAL_NOTIONAL_PERCENTAGE_OUTSTANDING)
1285    }
1286
1287
1288
1289
1290    /// Sets `Pool`, Tag 691.
1291    pub fn set_pool(&mut self, v: String) {
1292        self.message.body.set_field(tag::POOL, FIXString::from(v));
1293    }
1294
1295    /// Gets `Pool`, Tag 691.
1296    pub fn get_pool(&self) -> Result<String, MessageRejectErrorEnum> {
1297        let mut fld = field::PoolField::new(String::new());
1298        self.message.body.get_field(tag::POOL, &mut fld.0)?;
1299        Ok(fld.value().to_string())
1300    }
1301
1302
1303    /// Returns true if `Pool` is present, Tag 691.
1304    pub fn has_pool(&self) -> bool {
1305        self.message.body.has(tag::POOL)
1306    }
1307
1308
1309
1310
1311    /// Sets `PositionLimit`, Tag 970.
1312    pub fn set_position_limit(&mut self, v: isize) {
1313        self.message.body.set_field(tag::POSITION_LIMIT, fixer::fix_int::FIXInt::from(v));
1314    }
1315
1316    /// Gets `PositionLimit`, Tag 970.
1317    pub fn get_position_limit(&self) -> Result<isize, MessageRejectErrorEnum> {
1318        let mut fld = field::PositionLimitField::new(0);
1319        self.message.body.get_field(tag::POSITION_LIMIT, &mut fld.0)?;
1320        Ok(fld.value())
1321    }
1322
1323
1324    /// Returns true if `PositionLimit` is present, Tag 970.
1325    pub fn has_position_limit(&self) -> bool {
1326        self.message.body.has(tag::POSITION_LIMIT)
1327    }
1328
1329
1330
1331
1332    /// Sets `PriceQuoteMethod`, Tag 1196.
1333    pub fn set_price_quote_method(&mut self, v: String) {
1334        self.message.body.set_field(tag::PRICE_QUOTE_METHOD, FIXString::from(v));
1335    }
1336
1337    /// Gets `PriceQuoteMethod`, Tag 1196.
1338    pub fn get_price_quote_method(&self) -> Result<String, MessageRejectErrorEnum> {
1339        let mut fld = field::PriceQuoteMethodField::new(String::new());
1340        self.message.body.get_field(tag::PRICE_QUOTE_METHOD, &mut fld.0)?;
1341        Ok(fld.value().to_string())
1342    }
1343
1344
1345    /// Returns true if `PriceQuoteMethod` is present, Tag 1196.
1346    pub fn has_price_quote_method(&self) -> bool {
1347        self.message.body.has(tag::PRICE_QUOTE_METHOD)
1348    }
1349
1350
1351
1352
1353    /// Sets `PriceUnitOfMeasure`, Tag 1191.
1354    pub fn set_price_unit_of_measure(&mut self, v: String) {
1355        self.message.body.set_field(tag::PRICE_UNIT_OF_MEASURE, FIXString::from(v));
1356    }
1357
1358    /// Gets `PriceUnitOfMeasure`, Tag 1191.
1359    pub fn get_price_unit_of_measure(&self) -> Result<String, MessageRejectErrorEnum> {
1360        let mut fld = field::PriceUnitOfMeasureField::new(String::new());
1361        self.message.body.get_field(tag::PRICE_UNIT_OF_MEASURE, &mut fld.0)?;
1362        Ok(fld.value().to_string())
1363    }
1364
1365
1366    /// Returns true if `PriceUnitOfMeasure` is present, Tag 1191.
1367    pub fn has_price_unit_of_measure(&self) -> bool {
1368        self.message.body.has(tag::PRICE_UNIT_OF_MEASURE)
1369    }
1370
1371
1372
1373
1374    /// Sets `PriceUnitOfMeasureQty`, Tag 1192.
1375    pub fn set_price_unit_of_measure_qty(&mut self, val: Decimal, scale: i32) {
1376        self.message.body.set_field(tag::PRICE_UNIT_OF_MEASURE_QTY, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1377    }
1378
1379    /// Gets `PriceUnitOfMeasureQty`, Tag 1192.
1380    pub fn get_price_unit_of_measure_qty(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1381        let mut fld = field::PriceUnitOfMeasureQtyField::new(Decimal::ZERO, 0);
1382        self.message.body.get_field(tag::PRICE_UNIT_OF_MEASURE_QTY, &mut fld.0)?;
1383        Ok(fld.value())
1384    }
1385
1386
1387    /// Returns true if `PriceUnitOfMeasureQty` is present, Tag 1192.
1388    pub fn has_price_unit_of_measure_qty(&self) -> bool {
1389        self.message.body.has(tag::PRICE_UNIT_OF_MEASURE_QTY)
1390    }
1391
1392
1393
1394
1395    /// Sets `Product`, Tag 460.
1396    pub fn set_product(&mut self, v: isize) {
1397        self.message.body.set_field(tag::PRODUCT, fixer::fix_int::FIXInt::from(v));
1398    }
1399
1400    /// Gets `Product`, Tag 460.
1401    pub fn get_product(&self) -> Result<isize, MessageRejectErrorEnum> {
1402        let mut fld = field::ProductField::new(0);
1403        self.message.body.get_field(tag::PRODUCT, &mut fld.0)?;
1404        Ok(fld.value())
1405    }
1406
1407
1408    /// Returns true if `Product` is present, Tag 460.
1409    pub fn has_product(&self) -> bool {
1410        self.message.body.has(tag::PRODUCT)
1411    }
1412
1413
1414
1415
1416    /// Sets `ProductComplex`, Tag 1227.
1417    pub fn set_product_complex(&mut self, v: String) {
1418        self.message.body.set_field(tag::PRODUCT_COMPLEX, FIXString::from(v));
1419    }
1420
1421    /// Gets `ProductComplex`, Tag 1227.
1422    pub fn get_product_complex(&self) -> Result<String, MessageRejectErrorEnum> {
1423        let mut fld = field::ProductComplexField::new(String::new());
1424        self.message.body.get_field(tag::PRODUCT_COMPLEX, &mut fld.0)?;
1425        Ok(fld.value().to_string())
1426    }
1427
1428
1429    /// Returns true if `ProductComplex` is present, Tag 1227.
1430    pub fn has_product_complex(&self) -> bool {
1431        self.message.body.has(tag::PRODUCT_COMPLEX)
1432    }
1433
1434
1435
1436
1437    /// Sets `PutOrCall`, Tag 201.
1438    pub fn set_put_or_call(&mut self, v: isize) {
1439        self.message.body.set_field(tag::PUT_OR_CALL, fixer::fix_int::FIXInt::from(v));
1440    }
1441
1442    /// Gets `PutOrCall`, Tag 201.
1443    pub fn get_put_or_call(&self) -> Result<isize, MessageRejectErrorEnum> {
1444        let mut fld = field::PutOrCallField::new(0);
1445        self.message.body.get_field(tag::PUT_OR_CALL, &mut fld.0)?;
1446        Ok(fld.value())
1447    }
1448
1449
1450    /// Returns true if `PutOrCall` is present, Tag 201.
1451    pub fn has_put_or_call(&self) -> bool {
1452        self.message.body.has(tag::PUT_OR_CALL)
1453    }
1454
1455
1456
1457
1458    /// Sets `RedemptionDate`, Tag 240.
1459    pub fn set_redemption_date(&mut self, v: String) {
1460        self.message.body.set_field(tag::REDEMPTION_DATE, FIXString::from(v));
1461    }
1462
1463    /// Gets `RedemptionDate`, Tag 240.
1464    pub fn get_redemption_date(&self) -> Result<String, MessageRejectErrorEnum> {
1465        let mut fld = field::RedemptionDateField::new(String::new());
1466        self.message.body.get_field(tag::REDEMPTION_DATE, &mut fld.0)?;
1467        Ok(fld.value().to_string())
1468    }
1469
1470
1471    /// Returns true if `RedemptionDate` is present, Tag 240.
1472    pub fn has_redemption_date(&self) -> bool {
1473        self.message.body.has(tag::REDEMPTION_DATE)
1474    }
1475
1476
1477
1478
1479    /// Sets `RepoCollateralSecurityType`, Tag 239.
1480    pub fn set_repo_collateral_security_type(&mut self, v: isize) {
1481        self.message.body.set_field(tag::REPO_COLLATERAL_SECURITY_TYPE, fixer::fix_int::FIXInt::from(v));
1482    }
1483
1484    /// Gets `RepoCollateralSecurityType`, Tag 239.
1485    pub fn get_repo_collateral_security_type(&self) -> Result<isize, MessageRejectErrorEnum> {
1486        let mut fld = field::RepoCollateralSecurityTypeField::new(0);
1487        self.message.body.get_field(tag::REPO_COLLATERAL_SECURITY_TYPE, &mut fld.0)?;
1488        Ok(fld.value())
1489    }
1490
1491
1492    /// Returns true if `RepoCollateralSecurityType` is present, Tag 239.
1493    pub fn has_repo_collateral_security_type(&self) -> bool {
1494        self.message.body.has(tag::REPO_COLLATERAL_SECURITY_TYPE)
1495    }
1496
1497
1498
1499
1500    /// Sets `RepurchaseRate`, Tag 227.
1501    pub fn set_repurchase_rate(&mut self, val: Decimal, scale: i32) {
1502        self.message.body.set_field(tag::REPURCHASE_RATE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1503    }
1504
1505    /// Gets `RepurchaseRate`, Tag 227.
1506    pub fn get_repurchase_rate(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1507        let mut fld = field::RepurchaseRateField::new(Decimal::ZERO, 0);
1508        self.message.body.get_field(tag::REPURCHASE_RATE, &mut fld.0)?;
1509        Ok(fld.value())
1510    }
1511
1512
1513    /// Returns true if `RepurchaseRate` is present, Tag 227.
1514    pub fn has_repurchase_rate(&self) -> bool {
1515        self.message.body.has(tag::REPURCHASE_RATE)
1516    }
1517
1518
1519
1520
1521    /// Sets `RepurchaseTerm`, Tag 226.
1522    pub fn set_repurchase_term(&mut self, v: isize) {
1523        self.message.body.set_field(tag::REPURCHASE_TERM, fixer::fix_int::FIXInt::from(v));
1524    }
1525
1526    /// Gets `RepurchaseTerm`, Tag 226.
1527    pub fn get_repurchase_term(&self) -> Result<isize, MessageRejectErrorEnum> {
1528        let mut fld = field::RepurchaseTermField::new(0);
1529        self.message.body.get_field(tag::REPURCHASE_TERM, &mut fld.0)?;
1530        Ok(fld.value())
1531    }
1532
1533
1534    /// Returns true if `RepurchaseTerm` is present, Tag 226.
1535    pub fn has_repurchase_term(&self) -> bool {
1536        self.message.body.has(tag::REPURCHASE_TERM)
1537    }
1538
1539
1540
1541
1542    /// Sets `RestructuringType`, Tag 1449.
1543    pub fn set_restructuring_type(&mut self, v: String) {
1544        self.message.body.set_field(tag::RESTRUCTURING_TYPE, FIXString::from(v));
1545    }
1546
1547    /// Gets `RestructuringType`, Tag 1449.
1548    pub fn get_restructuring_type(&self) -> Result<String, MessageRejectErrorEnum> {
1549        let mut fld = field::RestructuringTypeField::new(String::new());
1550        self.message.body.get_field(tag::RESTRUCTURING_TYPE, &mut fld.0)?;
1551        Ok(fld.value().to_string())
1552    }
1553
1554
1555    /// Returns true if `RestructuringType` is present, Tag 1449.
1556    pub fn has_restructuring_type(&self) -> bool {
1557        self.message.body.has(tag::RESTRUCTURING_TYPE)
1558    }
1559
1560
1561
1562
1563    /// Sets `SecurityDesc`, Tag 107.
1564    pub fn set_security_desc(&mut self, v: String) {
1565        self.message.body.set_field(tag::SECURITY_DESC, FIXString::from(v));
1566    }
1567
1568    /// Gets `SecurityDesc`, Tag 107.
1569    pub fn get_security_desc(&self) -> Result<String, MessageRejectErrorEnum> {
1570        let mut fld = field::SecurityDescField::new(String::new());
1571        self.message.body.get_field(tag::SECURITY_DESC, &mut fld.0)?;
1572        Ok(fld.value().to_string())
1573    }
1574
1575
1576    /// Returns true if `SecurityDesc` is present, Tag 107.
1577    pub fn has_security_desc(&self) -> bool {
1578        self.message.body.has(tag::SECURITY_DESC)
1579    }
1580
1581
1582
1583
1584    /// Sets `SecurityExchange`, Tag 207.
1585    pub fn set_security_exchange(&mut self, v: String) {
1586        self.message.body.set_field(tag::SECURITY_EXCHANGE, FIXString::from(v));
1587    }
1588
1589    /// Gets `SecurityExchange`, Tag 207.
1590    pub fn get_security_exchange(&self) -> Result<String, MessageRejectErrorEnum> {
1591        let mut fld = field::SecurityExchangeField::new(String::new());
1592        self.message.body.get_field(tag::SECURITY_EXCHANGE, &mut fld.0)?;
1593        Ok(fld.value().to_string())
1594    }
1595
1596
1597    /// Returns true if `SecurityExchange` is present, Tag 207.
1598    pub fn has_security_exchange(&self) -> bool {
1599        self.message.body.has(tag::SECURITY_EXCHANGE)
1600    }
1601
1602
1603
1604
1605    /// Sets `SecurityGroup`, Tag 1151.
1606    pub fn set_security_group(&mut self, v: String) {
1607        self.message.body.set_field(tag::SECURITY_GROUP, FIXString::from(v));
1608    }
1609
1610    /// Gets `SecurityGroup`, Tag 1151.
1611    pub fn get_security_group(&self) -> Result<String, MessageRejectErrorEnum> {
1612        let mut fld = field::SecurityGroupField::new(String::new());
1613        self.message.body.get_field(tag::SECURITY_GROUP, &mut fld.0)?;
1614        Ok(fld.value().to_string())
1615    }
1616
1617
1618    /// Returns true if `SecurityGroup` is present, Tag 1151.
1619    pub fn has_security_group(&self) -> bool {
1620        self.message.body.has(tag::SECURITY_GROUP)
1621    }
1622
1623
1624
1625
1626    /// Sets `SecurityID`, Tag 48.
1627    pub fn set_security_id(&mut self, v: String) {
1628        self.message.body.set_field(tag::SECURITY_ID, FIXString::from(v));
1629    }
1630
1631    /// Gets `SecurityID`, Tag 48.
1632    pub fn get_security_id(&self) -> Result<String, MessageRejectErrorEnum> {
1633        let mut fld = field::SecurityIDField::new(String::new());
1634        self.message.body.get_field(tag::SECURITY_ID, &mut fld.0)?;
1635        Ok(fld.value().to_string())
1636    }
1637
1638
1639    /// Returns true if `SecurityID` is present, Tag 48.
1640    pub fn has_security_id(&self) -> bool {
1641        self.message.body.has(tag::SECURITY_ID)
1642    }
1643
1644
1645
1646
1647    /// Sets `SecurityIDSource`, Tag 22.
1648    pub fn set_security_id_source(&mut self, v: String) {
1649        self.message.body.set_field(tag::SECURITY_ID_SOURCE, FIXString::from(v));
1650    }
1651
1652    /// Gets `SecurityIDSource`, Tag 22.
1653    pub fn get_security_id_source(&self) -> Result<String, MessageRejectErrorEnum> {
1654        let mut fld = field::SecurityIDSourceField::new(String::new());
1655        self.message.body.get_field(tag::SECURITY_ID_SOURCE, &mut fld.0)?;
1656        Ok(fld.value().to_string())
1657    }
1658
1659
1660    /// Returns true if `SecurityIDSource` is present, Tag 22.
1661    pub fn has_security_id_source(&self) -> bool {
1662        self.message.body.has(tag::SECURITY_ID_SOURCE)
1663    }
1664
1665
1666
1667
1668    /// Sets `SecurityStatus`, Tag 965.
1669    pub fn set_security_status(&mut self, v: String) {
1670        self.message.body.set_field(tag::SECURITY_STATUS, FIXString::from(v));
1671    }
1672
1673    /// Gets `SecurityStatus`, Tag 965.
1674    pub fn get_security_status(&self) -> Result<String, MessageRejectErrorEnum> {
1675        let mut fld = field::SecurityStatusField::new(String::new());
1676        self.message.body.get_field(tag::SECURITY_STATUS, &mut fld.0)?;
1677        Ok(fld.value().to_string())
1678    }
1679
1680
1681    /// Returns true if `SecurityStatus` is present, Tag 965.
1682    pub fn has_security_status(&self) -> bool {
1683        self.message.body.has(tag::SECURITY_STATUS)
1684    }
1685
1686
1687
1688
1689    /// Sets `SecuritySubType`, Tag 762.
1690    pub fn set_security_sub_type(&mut self, v: String) {
1691        self.message.body.set_field(tag::SECURITY_SUB_TYPE, FIXString::from(v));
1692    }
1693
1694    /// Gets `SecuritySubType`, Tag 762.
1695    pub fn get_security_sub_type(&self) -> Result<String, MessageRejectErrorEnum> {
1696        let mut fld = field::SecuritySubTypeField::new(String::new());
1697        self.message.body.get_field(tag::SECURITY_SUB_TYPE, &mut fld.0)?;
1698        Ok(fld.value().to_string())
1699    }
1700
1701
1702    /// Returns true if `SecuritySubType` is present, Tag 762.
1703    pub fn has_security_sub_type(&self) -> bool {
1704        self.message.body.has(tag::SECURITY_SUB_TYPE)
1705    }
1706
1707
1708
1709
1710    /// Sets `SecurityType`, Tag 167.
1711    pub fn set_security_type(&mut self, v: String) {
1712        self.message.body.set_field(tag::SECURITY_TYPE, FIXString::from(v));
1713    }
1714
1715    /// Gets `SecurityType`, Tag 167.
1716    pub fn get_security_type(&self) -> Result<String, MessageRejectErrorEnum> {
1717        let mut fld = field::SecurityTypeField::new(String::new());
1718        self.message.body.get_field(tag::SECURITY_TYPE, &mut fld.0)?;
1719        Ok(fld.value().to_string())
1720    }
1721
1722
1723    /// Returns true if `SecurityType` is present, Tag 167.
1724    pub fn has_security_type(&self) -> bool {
1725        self.message.body.has(tag::SECURITY_TYPE)
1726    }
1727
1728
1729
1730
1731    /// Sets `SecurityXML`, Tag 1185.
1732    pub fn set_security_xml(&mut self, v: String) {
1733        self.message.body.set_field(tag::SECURITY_XML, FIXString::from(v));
1734    }
1735
1736    /// Gets `SecurityXML`, Tag 1185.
1737    pub fn get_security_xml(&self) -> Result<String, MessageRejectErrorEnum> {
1738        let mut fld = field::SecurityXMLField::new(String::new());
1739        self.message.body.get_field(tag::SECURITY_XML, &mut fld.0)?;
1740        Ok(fld.value().to_string())
1741    }
1742
1743
1744    /// Returns true if `SecurityXML` is present, Tag 1185.
1745    pub fn has_security_xml(&self) -> bool {
1746        self.message.body.has(tag::SECURITY_XML)
1747    }
1748
1749
1750
1751
1752    /// Sets `SecurityXMLLen`, Tag 1184.
1753    pub fn set_security_xml_len(&mut self, v: isize) {
1754        self.message.body.set_field(tag::SECURITY_XML_LEN, fixer::fix_int::FIXInt::from(v));
1755    }
1756
1757    /// Gets `SecurityXMLLen`, Tag 1184.
1758    pub fn get_security_xml_len(&self) -> Result<isize, MessageRejectErrorEnum> {
1759        let mut fld = field::SecurityXMLLenField::new(0);
1760        self.message.body.get_field(tag::SECURITY_XML_LEN, &mut fld.0)?;
1761        Ok(fld.value())
1762    }
1763
1764
1765    /// Returns true if `SecurityXMLLen` is present, Tag 1184.
1766    pub fn has_security_xml_len(&self) -> bool {
1767        self.message.body.has(tag::SECURITY_XML_LEN)
1768    }
1769
1770
1771
1772
1773    /// Sets `SecurityXMLSchema`, Tag 1186.
1774    pub fn set_security_xml_schema(&mut self, v: String) {
1775        self.message.body.set_field(tag::SECURITY_XML_SCHEMA, FIXString::from(v));
1776    }
1777
1778    /// Gets `SecurityXMLSchema`, Tag 1186.
1779    pub fn get_security_xml_schema(&self) -> Result<String, MessageRejectErrorEnum> {
1780        let mut fld = field::SecurityXMLSchemaField::new(String::new());
1781        self.message.body.get_field(tag::SECURITY_XML_SCHEMA, &mut fld.0)?;
1782        Ok(fld.value().to_string())
1783    }
1784
1785
1786    /// Returns true if `SecurityXMLSchema` is present, Tag 1186.
1787    pub fn has_security_xml_schema(&self) -> bool {
1788        self.message.body.has(tag::SECURITY_XML_SCHEMA)
1789    }
1790
1791
1792
1793
1794    /// Sets `Seniority`, Tag 1450.
1795    pub fn set_seniority(&mut self, v: String) {
1796        self.message.body.set_field(tag::SENIORITY, FIXString::from(v));
1797    }
1798
1799    /// Gets `Seniority`, Tag 1450.
1800    pub fn get_seniority(&self) -> Result<String, MessageRejectErrorEnum> {
1801        let mut fld = field::SeniorityField::new(String::new());
1802        self.message.body.get_field(tag::SENIORITY, &mut fld.0)?;
1803        Ok(fld.value().to_string())
1804    }
1805
1806
1807    /// Returns true if `Seniority` is present, Tag 1450.
1808    pub fn has_seniority(&self) -> bool {
1809        self.message.body.has(tag::SENIORITY)
1810    }
1811
1812
1813
1814
1815    /// Sets `SettlMethod`, Tag 1193.
1816    pub fn set_settl_method(&mut self, v: String) {
1817        self.message.body.set_field(tag::SETTL_METHOD, FIXString::from(v));
1818    }
1819
1820    /// Gets `SettlMethod`, Tag 1193.
1821    pub fn get_settl_method(&self) -> Result<String, MessageRejectErrorEnum> {
1822        let mut fld = field::SettlMethodField::new(String::new());
1823        self.message.body.get_field(tag::SETTL_METHOD, &mut fld.0)?;
1824        Ok(fld.value().to_string())
1825    }
1826
1827
1828    /// Returns true if `SettlMethod` is present, Tag 1193.
1829    pub fn has_settl_method(&self) -> bool {
1830        self.message.body.has(tag::SETTL_METHOD)
1831    }
1832
1833
1834
1835
1836    /// Sets `SettleOnOpenFlag`, Tag 966.
1837    pub fn set_settle_on_open_flag(&mut self, v: String) {
1838        self.message.body.set_field(tag::SETTLE_ON_OPEN_FLAG, FIXString::from(v));
1839    }
1840
1841    /// Gets `SettleOnOpenFlag`, Tag 966.
1842    pub fn get_settle_on_open_flag(&self) -> Result<String, MessageRejectErrorEnum> {
1843        let mut fld = field::SettleOnOpenFlagField::new(String::new());
1844        self.message.body.get_field(tag::SETTLE_ON_OPEN_FLAG, &mut fld.0)?;
1845        Ok(fld.value().to_string())
1846    }
1847
1848
1849    /// Returns true if `SettleOnOpenFlag` is present, Tag 966.
1850    pub fn has_settle_on_open_flag(&self) -> bool {
1851        self.message.body.has(tag::SETTLE_ON_OPEN_FLAG)
1852    }
1853
1854
1855
1856
1857    /// Sets `StateOrProvinceOfIssue`, Tag 471.
1858    pub fn set_state_or_province_of_issue(&mut self, v: String) {
1859        self.message.body.set_field(tag::STATE_OR_PROVINCE_OF_ISSUE, FIXString::from(v));
1860    }
1861
1862    /// Gets `StateOrProvinceOfIssue`, Tag 471.
1863    pub fn get_state_or_province_of_issue(&self) -> Result<String, MessageRejectErrorEnum> {
1864        let mut fld = field::StateOrProvinceOfIssueField::new(String::new());
1865        self.message.body.get_field(tag::STATE_OR_PROVINCE_OF_ISSUE, &mut fld.0)?;
1866        Ok(fld.value().to_string())
1867    }
1868
1869
1870    /// Returns true if `StateOrProvinceOfIssue` is present, Tag 471.
1871    pub fn has_state_or_province_of_issue(&self) -> bool {
1872        self.message.body.has(tag::STATE_OR_PROVINCE_OF_ISSUE)
1873    }
1874
1875
1876
1877
1878    /// Sets `StrikeCurrency`, Tag 947.
1879    pub fn set_strike_currency(&mut self, v: String) {
1880        self.message.body.set_field(tag::STRIKE_CURRENCY, FIXString::from(v));
1881    }
1882
1883    /// Gets `StrikeCurrency`, Tag 947.
1884    pub fn get_strike_currency(&self) -> Result<String, MessageRejectErrorEnum> {
1885        let mut fld = field::StrikeCurrencyField::new(String::new());
1886        self.message.body.get_field(tag::STRIKE_CURRENCY, &mut fld.0)?;
1887        Ok(fld.value().to_string())
1888    }
1889
1890
1891    /// Returns true if `StrikeCurrency` is present, Tag 947.
1892    pub fn has_strike_currency(&self) -> bool {
1893        self.message.body.has(tag::STRIKE_CURRENCY)
1894    }
1895
1896
1897
1898
1899    /// Sets `StrikeMultiplier`, Tag 967.
1900    pub fn set_strike_multiplier(&mut self, val: Decimal, scale: i32) {
1901        self.message.body.set_field(tag::STRIKE_MULTIPLIER, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1902    }
1903
1904    /// Gets `StrikeMultiplier`, Tag 967.
1905    pub fn get_strike_multiplier(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1906        let mut fld = field::StrikeMultiplierField::new(Decimal::ZERO, 0);
1907        self.message.body.get_field(tag::STRIKE_MULTIPLIER, &mut fld.0)?;
1908        Ok(fld.value())
1909    }
1910
1911
1912    /// Returns true if `StrikeMultiplier` is present, Tag 967.
1913    pub fn has_strike_multiplier(&self) -> bool {
1914        self.message.body.has(tag::STRIKE_MULTIPLIER)
1915    }
1916
1917
1918
1919
1920    /// Sets `StrikePrice`, Tag 202.
1921    pub fn set_strike_price(&mut self, val: Decimal, scale: i32) {
1922        self.message.body.set_field(tag::STRIKE_PRICE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1923    }
1924
1925    /// Gets `StrikePrice`, Tag 202.
1926    pub fn get_strike_price(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1927        let mut fld = field::StrikePriceField::new(Decimal::ZERO, 0);
1928        self.message.body.get_field(tag::STRIKE_PRICE, &mut fld.0)?;
1929        Ok(fld.value())
1930    }
1931
1932
1933    /// Returns true if `StrikePrice` is present, Tag 202.
1934    pub fn has_strike_price(&self) -> bool {
1935        self.message.body.has(tag::STRIKE_PRICE)
1936    }
1937
1938
1939
1940
1941    /// Sets `StrikePriceBoundaryMethod`, Tag 1479.
1942    pub fn set_strike_price_boundary_method(&mut self, v: isize) {
1943        self.message.body.set_field(tag::STRIKE_PRICE_BOUNDARY_METHOD, fixer::fix_int::FIXInt::from(v));
1944    }
1945
1946    /// Gets `StrikePriceBoundaryMethod`, Tag 1479.
1947    pub fn get_strike_price_boundary_method(&self) -> Result<isize, MessageRejectErrorEnum> {
1948        let mut fld = field::StrikePriceBoundaryMethodField::new(0);
1949        self.message.body.get_field(tag::STRIKE_PRICE_BOUNDARY_METHOD, &mut fld.0)?;
1950        Ok(fld.value())
1951    }
1952
1953
1954    /// Returns true if `StrikePriceBoundaryMethod` is present, Tag 1479.
1955    pub fn has_strike_price_boundary_method(&self) -> bool {
1956        self.message.body.has(tag::STRIKE_PRICE_BOUNDARY_METHOD)
1957    }
1958
1959
1960
1961
1962    /// Sets `StrikePriceBoundaryPrecision`, Tag 1480.
1963    pub fn set_strike_price_boundary_precision(&mut self, val: Decimal, scale: i32) {
1964        self.message.body.set_field(tag::STRIKE_PRICE_BOUNDARY_PRECISION, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1965    }
1966
1967    /// Gets `StrikePriceBoundaryPrecision`, Tag 1480.
1968    pub fn get_strike_price_boundary_precision(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1969        let mut fld = field::StrikePriceBoundaryPrecisionField::new(Decimal::ZERO, 0);
1970        self.message.body.get_field(tag::STRIKE_PRICE_BOUNDARY_PRECISION, &mut fld.0)?;
1971        Ok(fld.value())
1972    }
1973
1974
1975    /// Returns true if `StrikePriceBoundaryPrecision` is present, Tag 1480.
1976    pub fn has_strike_price_boundary_precision(&self) -> bool {
1977        self.message.body.has(tag::STRIKE_PRICE_BOUNDARY_PRECISION)
1978    }
1979
1980
1981
1982
1983    /// Sets `StrikePriceDeterminationMethod`, Tag 1478.
1984    pub fn set_strike_price_determination_method(&mut self, v: isize) {
1985        self.message.body.set_field(tag::STRIKE_PRICE_DETERMINATION_METHOD, fixer::fix_int::FIXInt::from(v));
1986    }
1987
1988    /// Gets `StrikePriceDeterminationMethod`, Tag 1478.
1989    pub fn get_strike_price_determination_method(&self) -> Result<isize, MessageRejectErrorEnum> {
1990        let mut fld = field::StrikePriceDeterminationMethodField::new(0);
1991        self.message.body.get_field(tag::STRIKE_PRICE_DETERMINATION_METHOD, &mut fld.0)?;
1992        Ok(fld.value())
1993    }
1994
1995
1996    /// Returns true if `StrikePriceDeterminationMethod` is present, Tag 1478.
1997    pub fn has_strike_price_determination_method(&self) -> bool {
1998        self.message.body.has(tag::STRIKE_PRICE_DETERMINATION_METHOD)
1999    }
2000
2001
2002
2003
2004    /// Sets `StrikeValue`, Tag 968.
2005    pub fn set_strike_value(&mut self, val: Decimal, scale: i32) {
2006        self.message.body.set_field(tag::STRIKE_VALUE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
2007    }
2008
2009    /// Gets `StrikeValue`, Tag 968.
2010    pub fn get_strike_value(&self) -> Result<Decimal, MessageRejectErrorEnum> {
2011        let mut fld = field::StrikeValueField::new(Decimal::ZERO, 0);
2012        self.message.body.get_field(tag::STRIKE_VALUE, &mut fld.0)?;
2013        Ok(fld.value())
2014    }
2015
2016
2017    /// Returns true if `StrikeValue` is present, Tag 968.
2018    pub fn has_strike_value(&self) -> bool {
2019        self.message.body.has(tag::STRIKE_VALUE)
2020    }
2021
2022
2023
2024
2025    /// Sets `Symbol`, Tag 55.
2026    pub fn set_symbol(&mut self, v: String) {
2027        self.message.body.set_field(tag::SYMBOL, FIXString::from(v));
2028    }
2029
2030    /// Gets `Symbol`, Tag 55.
2031    pub fn get_symbol(&self) -> Result<String, MessageRejectErrorEnum> {
2032        let mut fld = field::SymbolField::new(String::new());
2033        self.message.body.get_field(tag::SYMBOL, &mut fld.0)?;
2034        Ok(fld.value().to_string())
2035    }
2036
2037
2038    /// Returns true if `Symbol` is present, Tag 55.
2039    pub fn has_symbol(&self) -> bool {
2040        self.message.body.has(tag::SYMBOL)
2041    }
2042
2043
2044
2045
2046    /// Sets `SymbolSfx`, Tag 65.
2047    pub fn set_symbol_sfx(&mut self, v: String) {
2048        self.message.body.set_field(tag::SYMBOL_SFX, FIXString::from(v));
2049    }
2050
2051    /// Gets `SymbolSfx`, Tag 65.
2052    pub fn get_symbol_sfx(&self) -> Result<String, MessageRejectErrorEnum> {
2053        let mut fld = field::SymbolSfxField::new(String::new());
2054        self.message.body.get_field(tag::SYMBOL_SFX, &mut fld.0)?;
2055        Ok(fld.value().to_string())
2056    }
2057
2058
2059    /// Returns true if `SymbolSfx` is present, Tag 65.
2060    pub fn has_symbol_sfx(&self) -> bool {
2061        self.message.body.has(tag::SYMBOL_SFX)
2062    }
2063
2064
2065
2066
2067    /// Sets `Text`, Tag 58.
2068    pub fn set_text(&mut self, v: String) {
2069        self.message.body.set_field(tag::TEXT, FIXString::from(v));
2070    }
2071
2072    /// Gets `Text`, Tag 58.
2073    pub fn get_text(&self) -> Result<String, MessageRejectErrorEnum> {
2074        let mut fld = field::TextField::new(String::new());
2075        self.message.body.get_field(tag::TEXT, &mut fld.0)?;
2076        Ok(fld.value().to_string())
2077    }
2078
2079
2080    /// Returns true if `Text` is present, Tag 58.
2081    pub fn has_text(&self) -> bool {
2082        self.message.body.has(tag::TEXT)
2083    }
2084
2085
2086
2087
2088    /// Sets `TimeUnit`, Tag 997.
2089    pub fn set_time_unit(&mut self, v: String) {
2090        self.message.body.set_field(tag::TIME_UNIT, FIXString::from(v));
2091    }
2092
2093    /// Gets `TimeUnit`, Tag 997.
2094    pub fn get_time_unit(&self) -> Result<String, MessageRejectErrorEnum> {
2095        let mut fld = field::TimeUnitField::new(String::new());
2096        self.message.body.get_field(tag::TIME_UNIT, &mut fld.0)?;
2097        Ok(fld.value().to_string())
2098    }
2099
2100
2101    /// Returns true if `TimeUnit` is present, Tag 997.
2102    pub fn has_time_unit(&self) -> bool {
2103        self.message.body.has(tag::TIME_UNIT)
2104    }
2105
2106
2107
2108
2109    /// Sets `TransactTime`, Tag 60.
2110    pub fn set_transact_time(&mut self, v: Timestamp) {
2111        self.message.body.set_field(tag::TRANSACT_TIME, fixer::fix_utc_timestamp::FIXUTCTimestamp {
2112            time: v,
2113            precision: fixer::fix_utc_timestamp::TimestampPrecision::Millis,
2114        });
2115    }
2116
2117    /// Gets `TransactTime`, Tag 60.
2118    pub fn get_transact_time(&self) -> Result<Timestamp, MessageRejectErrorEnum> {
2119        let mut fld = field::TransactTimeField::new(Timestamp::UNIX_EPOCH);
2120        self.message.body.get_field(tag::TRANSACT_TIME, &mut fld.0)?;
2121        Ok(fld.value())
2122    }
2123
2124
2125    /// Returns true if `TransactTime` is present, Tag 60.
2126    pub fn has_transact_time(&self) -> bool {
2127        self.message.body.has(tag::TRANSACT_TIME)
2128    }
2129
2130
2131
2132
2133    /// Sets `UnderlyingPriceDeterminationMethod`, Tag 1481.
2134    pub fn set_underlying_price_determination_method(&mut self, v: isize) {
2135        self.message.body.set_field(tag::UNDERLYING_PRICE_DETERMINATION_METHOD, fixer::fix_int::FIXInt::from(v));
2136    }
2137
2138    /// Gets `UnderlyingPriceDeterminationMethod`, Tag 1481.
2139    pub fn get_underlying_price_determination_method(&self) -> Result<isize, MessageRejectErrorEnum> {
2140        let mut fld = field::UnderlyingPriceDeterminationMethodField::new(0);
2141        self.message.body.get_field(tag::UNDERLYING_PRICE_DETERMINATION_METHOD, &mut fld.0)?;
2142        Ok(fld.value())
2143    }
2144
2145
2146    /// Returns true if `UnderlyingPriceDeterminationMethod` is present, Tag 1481.
2147    pub fn has_underlying_price_determination_method(&self) -> bool {
2148        self.message.body.has(tag::UNDERLYING_PRICE_DETERMINATION_METHOD)
2149    }
2150
2151
2152
2153
2154    /// Sets `UnitOfMeasure`, Tag 996.
2155    pub fn set_unit_of_measure(&mut self, v: String) {
2156        self.message.body.set_field(tag::UNIT_OF_MEASURE, FIXString::from(v));
2157    }
2158
2159    /// Gets `UnitOfMeasure`, Tag 996.
2160    pub fn get_unit_of_measure(&self) -> Result<String, MessageRejectErrorEnum> {
2161        let mut fld = field::UnitOfMeasureField::new(String::new());
2162        self.message.body.get_field(tag::UNIT_OF_MEASURE, &mut fld.0)?;
2163        Ok(fld.value().to_string())
2164    }
2165
2166
2167    /// Returns true if `UnitOfMeasure` is present, Tag 996.
2168    pub fn has_unit_of_measure(&self) -> bool {
2169        self.message.body.has(tag::UNIT_OF_MEASURE)
2170    }
2171
2172
2173
2174
2175    /// Sets `UnitOfMeasureQty`, Tag 1147.
2176    pub fn set_unit_of_measure_qty(&mut self, val: Decimal, scale: i32) {
2177        self.message.body.set_field(tag::UNIT_OF_MEASURE_QTY, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
2178    }
2179
2180    /// Gets `UnitOfMeasureQty`, Tag 1147.
2181    pub fn get_unit_of_measure_qty(&self) -> Result<Decimal, MessageRejectErrorEnum> {
2182        let mut fld = field::UnitOfMeasureQtyField::new(Decimal::ZERO, 0);
2183        self.message.body.get_field(tag::UNIT_OF_MEASURE_QTY, &mut fld.0)?;
2184        Ok(fld.value())
2185    }
2186
2187
2188    /// Returns true if `UnitOfMeasureQty` is present, Tag 1147.
2189    pub fn has_unit_of_measure_qty(&self) -> bool {
2190        self.message.body.has(tag::UNIT_OF_MEASURE_QTY)
2191    }
2192
2193
2194
2195
2196    /// Sets `ValuationMethod`, Tag 1197.
2197    pub fn set_valuation_method(&mut self, v: String) {
2198        self.message.body.set_field(tag::VALUATION_METHOD, FIXString::from(v));
2199    }
2200
2201    /// Gets `ValuationMethod`, Tag 1197.
2202    pub fn get_valuation_method(&self) -> Result<String, MessageRejectErrorEnum> {
2203        let mut fld = field::ValuationMethodField::new(String::new());
2204        self.message.body.get_field(tag::VALUATION_METHOD, &mut fld.0)?;
2205        Ok(fld.value().to_string())
2206    }
2207
2208
2209    /// Returns true if `ValuationMethod` is present, Tag 1197.
2210    pub fn has_valuation_method(&self) -> bool {
2211        self.message.body.has(tag::VALUATION_METHOD)
2212    }
2213
2214
2215}
2216
2217/// `RouteOut` is the callback type for routing `ContraryIntentionReport` messages.
2218pub type RouteOut = fn(msg: ContraryIntentionReport, session_id: SessionID) -> Result<(), MessageRejectErrorEnum>;
2219
2220/// Route type returned by the `route` function.
2221pub type Route = (&'static str, &'static str, Box<dyn Fn(&Message, SessionID) -> Result<(), MessageRejectErrorEnum> + Send>);
2222
2223/// Returns the begin string, message type, and route function for `ContraryIntentionReport`.
2224pub fn route(router: RouteOut) -> Route {
2225    let r = move |msg: &Message, session_id: SessionID| -> Result<(), MessageRejectErrorEnum> {
2226        router(ContraryIntentionReport::from_message(msg.clone()), session_id)
2227    };
2228    ("9", "BO", Box::new(r))
2229}
fixer_fix/fix50sp2/contrary_intention_report.rs

fixer_fix/fix50sp2/
contrary_intention_report.rs
