Skip to main content

fixer_fix/fix43/
order_cancel_replace_request.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/// `OrderCancelReplaceRequest` is the `fix43` `OrderCancelReplaceRequest` type, `MsgType` = G.
21pub struct OrderCancelReplaceRequest {
22    pub message: Message,
23}
24
25impl OrderCancelReplaceRequest {
26    /// Creates a new `OrderCancelReplaceRequest` with required fields.
27    pub fn new(orig_cl_ord_id: field::OrigClOrdIDField, cl_ord_id: field::ClOrdIDField, handl_inst: field::HandlInstField, side: field::SideField, transact_time: field::TransactTimeField, ord_type: field::OrdTypeField) -> Self {
28        let mut msg = Message::new();
29        msg.header.set_field(tag::MSG_TYPE, FIXString::from("G".to_string()));
30
31        msg.body.set_field(tag::ORIG_CL_ORD_ID, orig_cl_ord_id.0);
32
33        msg.body.set_field(tag::CL_ORD_ID, cl_ord_id.0);
34
35        msg.body.set_field(tag::HANDL_INST, handl_inst.0);
36
37        msg.body.set_field(tag::SIDE, side.0);
38
39        msg.body.set_field(tag::TRANSACT_TIME, transact_time.0);
40
41        msg.body.set_field(tag::ORD_TYPE, ord_type.0);
42
43        Self { message: msg }
44    }
45
46    /// Creates a `OrderCancelReplaceRequest` from an existing `Message`.
47    pub fn from_message(msg: Message) -> Self {
48        Self { message: msg }
49    }
50
51    /// Returns the underlying `Message`.
52    pub fn to_message(self) -> Message {
53        self.message
54    }
55
56
57
58
59    /// Sets `Account`, Tag 1.
60    pub fn set_account(&mut self, v: String) {
61        self.message.body.set_field(tag::ACCOUNT, FIXString::from(v));
62    }
63
64    /// Gets `Account`, Tag 1.
65    pub fn get_account(&self) -> Result<String, MessageRejectErrorEnum> {
66        let mut fld = field::AccountField::new(String::new());
67        self.message.body.get_field(tag::ACCOUNT, &mut fld.0)?;
68        Ok(fld.value().to_string())
69    }
70
71
72    /// Returns true if `Account` is present, Tag 1.
73    pub fn has_account(&self) -> bool {
74        self.message.body.has(tag::ACCOUNT)
75    }
76
77
78
79
80    /// Sets `AccountType`, Tag 581.
81    pub fn set_account_type(&mut self, v: isize) {
82        self.message.body.set_field(tag::ACCOUNT_TYPE, fixer::fix_int::FIXInt::from(v));
83    }
84
85    /// Gets `AccountType`, Tag 581.
86    pub fn get_account_type(&self) -> Result<isize, MessageRejectErrorEnum> {
87        let mut fld = field::AccountTypeField::new(0);
88        self.message.body.get_field(tag::ACCOUNT_TYPE, &mut fld.0)?;
89        Ok(fld.value())
90    }
91
92
93    /// Returns true if `AccountType` is present, Tag 581.
94    pub fn has_account_type(&self) -> bool {
95        self.message.body.has(tag::ACCOUNT_TYPE)
96    }
97
98
99
100
101    /// Sets `AccruedInterestAmt`, Tag 159.
102    pub fn set_accrued_interest_amt(&mut self, val: Decimal, scale: i32) {
103        self.message.body.set_field(tag::ACCRUED_INTEREST_AMT, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
104    }
105
106    /// Gets `AccruedInterestAmt`, Tag 159.
107    pub fn get_accrued_interest_amt(&self) -> Result<Decimal, MessageRejectErrorEnum> {
108        let mut fld = field::AccruedInterestAmtField::new(Decimal::ZERO, 0);
109        self.message.body.get_field(tag::ACCRUED_INTEREST_AMT, &mut fld.0)?;
110        Ok(fld.value())
111    }
112
113
114    /// Returns true if `AccruedInterestAmt` is present, Tag 159.
115    pub fn has_accrued_interest_amt(&self) -> bool {
116        self.message.body.has(tag::ACCRUED_INTEREST_AMT)
117    }
118
119
120
121
122    /// Sets `AccruedInterestRate`, Tag 158.
123    pub fn set_accrued_interest_rate(&mut self, val: Decimal, scale: i32) {
124        self.message.body.set_field(tag::ACCRUED_INTEREST_RATE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
125    }
126
127    /// Gets `AccruedInterestRate`, Tag 158.
128    pub fn get_accrued_interest_rate(&self) -> Result<Decimal, MessageRejectErrorEnum> {
129        let mut fld = field::AccruedInterestRateField::new(Decimal::ZERO, 0);
130        self.message.body.get_field(tag::ACCRUED_INTEREST_RATE, &mut fld.0)?;
131        Ok(fld.value())
132    }
133
134
135    /// Returns true if `AccruedInterestRate` is present, Tag 158.
136    pub fn has_accrued_interest_rate(&self) -> bool {
137        self.message.body.has(tag::ACCRUED_INTEREST_RATE)
138    }
139
140
141
142
143    /// Sets `BenchmarkCurveCurrency`, Tag 220.
144    pub fn set_benchmark_curve_currency(&mut self, v: String) {
145        self.message.body.set_field(tag::BENCHMARK_CURVE_CURRENCY, FIXString::from(v));
146    }
147
148    /// Gets `BenchmarkCurveCurrency`, Tag 220.
149    pub fn get_benchmark_curve_currency(&self) -> Result<String, MessageRejectErrorEnum> {
150        let mut fld = field::BenchmarkCurveCurrencyField::new(String::new());
151        self.message.body.get_field(tag::BENCHMARK_CURVE_CURRENCY, &mut fld.0)?;
152        Ok(fld.value().to_string())
153    }
154
155
156    /// Returns true if `BenchmarkCurveCurrency` is present, Tag 220.
157    pub fn has_benchmark_curve_currency(&self) -> bool {
158        self.message.body.has(tag::BENCHMARK_CURVE_CURRENCY)
159    }
160
161
162
163
164    /// Sets `BenchmarkCurveName`, Tag 221.
165    pub fn set_benchmark_curve_name(&mut self, v: String) {
166        self.message.body.set_field(tag::BENCHMARK_CURVE_NAME, FIXString::from(v));
167    }
168
169    /// Gets `BenchmarkCurveName`, Tag 221.
170    pub fn get_benchmark_curve_name(&self) -> Result<String, MessageRejectErrorEnum> {
171        let mut fld = field::BenchmarkCurveNameField::new(String::new());
172        self.message.body.get_field(tag::BENCHMARK_CURVE_NAME, &mut fld.0)?;
173        Ok(fld.value().to_string())
174    }
175
176
177    /// Returns true if `BenchmarkCurveName` is present, Tag 221.
178    pub fn has_benchmark_curve_name(&self) -> bool {
179        self.message.body.has(tag::BENCHMARK_CURVE_NAME)
180    }
181
182
183
184
185    /// Sets `BenchmarkCurvePoint`, Tag 222.
186    pub fn set_benchmark_curve_point(&mut self, v: String) {
187        self.message.body.set_field(tag::BENCHMARK_CURVE_POINT, FIXString::from(v));
188    }
189
190    /// Gets `BenchmarkCurvePoint`, Tag 222.
191    pub fn get_benchmark_curve_point(&self) -> Result<String, MessageRejectErrorEnum> {
192        let mut fld = field::BenchmarkCurvePointField::new(String::new());
193        self.message.body.get_field(tag::BENCHMARK_CURVE_POINT, &mut fld.0)?;
194        Ok(fld.value().to_string())
195    }
196
197
198    /// Returns true if `BenchmarkCurvePoint` is present, Tag 222.
199    pub fn has_benchmark_curve_point(&self) -> bool {
200        self.message.body.has(tag::BENCHMARK_CURVE_POINT)
201    }
202
203
204
205
206    /// Sets `BookingUnit`, Tag 590.
207    pub fn set_booking_unit(&mut self, v: String) {
208        self.message.body.set_field(tag::BOOKING_UNIT, FIXString::from(v));
209    }
210
211    /// Gets `BookingUnit`, Tag 590.
212    pub fn get_booking_unit(&self) -> Result<String, MessageRejectErrorEnum> {
213        let mut fld = field::BookingUnitField::new(String::new());
214        self.message.body.get_field(tag::BOOKING_UNIT, &mut fld.0)?;
215        Ok(fld.value().to_string())
216    }
217
218
219    /// Returns true if `BookingUnit` is present, Tag 590.
220    pub fn has_booking_unit(&self) -> bool {
221        self.message.body.has(tag::BOOKING_UNIT)
222    }
223
224
225
226
227    /// Sets `CFICode`, Tag 461.
228    pub fn set_cfi_code(&mut self, v: String) {
229        self.message.body.set_field(tag::CFI_CODE, FIXString::from(v));
230    }
231
232    /// Gets `CFICode`, Tag 461.
233    pub fn get_cfi_code(&self) -> Result<String, MessageRejectErrorEnum> {
234        let mut fld = field::CFICodeField::new(String::new());
235        self.message.body.get_field(tag::CFI_CODE, &mut fld.0)?;
236        Ok(fld.value().to_string())
237    }
238
239
240    /// Returns true if `CFICode` is present, Tag 461.
241    pub fn has_cfi_code(&self) -> bool {
242        self.message.body.has(tag::CFI_CODE)
243    }
244
245
246
247
248    /// Sets `CancellationRights`, Tag 480.
249    pub fn set_cancellation_rights(&mut self, v: String) {
250        self.message.body.set_field(tag::CANCELLATION_RIGHTS, FIXString::from(v));
251    }
252
253    /// Gets `CancellationRights`, Tag 480.
254    pub fn get_cancellation_rights(&self) -> Result<String, MessageRejectErrorEnum> {
255        let mut fld = field::CancellationRightsField::new(String::new());
256        self.message.body.get_field(tag::CANCELLATION_RIGHTS, &mut fld.0)?;
257        Ok(fld.value().to_string())
258    }
259
260
261    /// Returns true if `CancellationRights` is present, Tag 480.
262    pub fn has_cancellation_rights(&self) -> bool {
263        self.message.body.has(tag::CANCELLATION_RIGHTS)
264    }
265
266
267
268
269    /// Sets `CashMargin`, Tag 544.
270    pub fn set_cash_margin(&mut self, v: String) {
271        self.message.body.set_field(tag::CASH_MARGIN, FIXString::from(v));
272    }
273
274    /// Gets `CashMargin`, Tag 544.
275    pub fn get_cash_margin(&self) -> Result<String, MessageRejectErrorEnum> {
276        let mut fld = field::CashMarginField::new(String::new());
277        self.message.body.get_field(tag::CASH_MARGIN, &mut fld.0)?;
278        Ok(fld.value().to_string())
279    }
280
281
282    /// Returns true if `CashMargin` is present, Tag 544.
283    pub fn has_cash_margin(&self) -> bool {
284        self.message.body.has(tag::CASH_MARGIN)
285    }
286
287
288
289
290    /// Sets `CashOrderQty`, Tag 152.
291    pub fn set_cash_order_qty(&mut self, val: Decimal, scale: i32) {
292        self.message.body.set_field(tag::CASH_ORDER_QTY, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
293    }
294
295    /// Gets `CashOrderQty`, Tag 152.
296    pub fn get_cash_order_qty(&self) -> Result<Decimal, MessageRejectErrorEnum> {
297        let mut fld = field::CashOrderQtyField::new(Decimal::ZERO, 0);
298        self.message.body.get_field(tag::CASH_ORDER_QTY, &mut fld.0)?;
299        Ok(fld.value())
300    }
301
302
303    /// Returns true if `CashOrderQty` is present, Tag 152.
304    pub fn has_cash_order_qty(&self) -> bool {
305        self.message.body.has(tag::CASH_ORDER_QTY)
306    }
307
308
309
310
311    /// Sets `ClOrdID`, Tag 11.
312    pub fn set_cl_ord_id(&mut self, v: String) {
313        self.message.body.set_field(tag::CL_ORD_ID, FIXString::from(v));
314    }
315
316    /// Gets `ClOrdID`, Tag 11.
317    pub fn get_cl_ord_id(&self) -> Result<String, MessageRejectErrorEnum> {
318        let mut fld = field::ClOrdIDField::new(String::new());
319        self.message.body.get_field(tag::CL_ORD_ID, &mut fld.0)?;
320        Ok(fld.value().to_string())
321    }
322
323
324    /// Returns true if `ClOrdID` is present, Tag 11.
325    pub fn has_cl_ord_id(&self) -> bool {
326        self.message.body.has(tag::CL_ORD_ID)
327    }
328
329
330
331
332    /// Sets `ClOrdLinkID`, Tag 583.
333    pub fn set_cl_ord_link_id(&mut self, v: String) {
334        self.message.body.set_field(tag::CL_ORD_LINK_ID, FIXString::from(v));
335    }
336
337    /// Gets `ClOrdLinkID`, Tag 583.
338    pub fn get_cl_ord_link_id(&self) -> Result<String, MessageRejectErrorEnum> {
339        let mut fld = field::ClOrdLinkIDField::new(String::new());
340        self.message.body.get_field(tag::CL_ORD_LINK_ID, &mut fld.0)?;
341        Ok(fld.value().to_string())
342    }
343
344
345    /// Returns true if `ClOrdLinkID` is present, Tag 583.
346    pub fn has_cl_ord_link_id(&self) -> bool {
347        self.message.body.has(tag::CL_ORD_LINK_ID)
348    }
349
350
351
352
353    /// Sets `ClearingFeeIndicator`, Tag 635.
354    pub fn set_clearing_fee_indicator(&mut self, v: String) {
355        self.message.body.set_field(tag::CLEARING_FEE_INDICATOR, FIXString::from(v));
356    }
357
358    /// Gets `ClearingFeeIndicator`, Tag 635.
359    pub fn get_clearing_fee_indicator(&self) -> Result<String, MessageRejectErrorEnum> {
360        let mut fld = field::ClearingFeeIndicatorField::new(String::new());
361        self.message.body.get_field(tag::CLEARING_FEE_INDICATOR, &mut fld.0)?;
362        Ok(fld.value().to_string())
363    }
364
365
366    /// Returns true if `ClearingFeeIndicator` is present, Tag 635.
367    pub fn has_clearing_fee_indicator(&self) -> bool {
368        self.message.body.has(tag::CLEARING_FEE_INDICATOR)
369    }
370
371
372
373
374    /// Sets `CommCurrency`, Tag 479.
375    pub fn set_comm_currency(&mut self, v: String) {
376        self.message.body.set_field(tag::COMM_CURRENCY, FIXString::from(v));
377    }
378
379    /// Gets `CommCurrency`, Tag 479.
380    pub fn get_comm_currency(&self) -> Result<String, MessageRejectErrorEnum> {
381        let mut fld = field::CommCurrencyField::new(String::new());
382        self.message.body.get_field(tag::COMM_CURRENCY, &mut fld.0)?;
383        Ok(fld.value().to_string())
384    }
385
386
387    /// Returns true if `CommCurrency` is present, Tag 479.
388    pub fn has_comm_currency(&self) -> bool {
389        self.message.body.has(tag::COMM_CURRENCY)
390    }
391
392
393
394
395    /// Sets `CommType`, Tag 13.
396    pub fn set_comm_type(&mut self, v: String) {
397        self.message.body.set_field(tag::COMM_TYPE, FIXString::from(v));
398    }
399
400    /// Gets `CommType`, Tag 13.
401    pub fn get_comm_type(&self) -> Result<String, MessageRejectErrorEnum> {
402        let mut fld = field::CommTypeField::new(String::new());
403        self.message.body.get_field(tag::COMM_TYPE, &mut fld.0)?;
404        Ok(fld.value().to_string())
405    }
406
407
408    /// Returns true if `CommType` is present, Tag 13.
409    pub fn has_comm_type(&self) -> bool {
410        self.message.body.has(tag::COMM_TYPE)
411    }
412
413
414
415
416    /// Sets `Commission`, Tag 12.
417    pub fn set_commission(&mut self, val: Decimal, scale: i32) {
418        self.message.body.set_field(tag::COMMISSION, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
419    }
420
421    /// Gets `Commission`, Tag 12.
422    pub fn get_commission(&self) -> Result<Decimal, MessageRejectErrorEnum> {
423        let mut fld = field::CommissionField::new(Decimal::ZERO, 0);
424        self.message.body.get_field(tag::COMMISSION, &mut fld.0)?;
425        Ok(fld.value())
426    }
427
428
429    /// Returns true if `Commission` is present, Tag 12.
430    pub fn has_commission(&self) -> bool {
431        self.message.body.has(tag::COMMISSION)
432    }
433
434
435
436
437    /// Sets `ComplianceID`, Tag 376.
438    pub fn set_compliance_id(&mut self, v: String) {
439        self.message.body.set_field(tag::COMPLIANCE_ID, FIXString::from(v));
440    }
441
442    /// Gets `ComplianceID`, Tag 376.
443    pub fn get_compliance_id(&self) -> Result<String, MessageRejectErrorEnum> {
444        let mut fld = field::ComplianceIDField::new(String::new());
445        self.message.body.get_field(tag::COMPLIANCE_ID, &mut fld.0)?;
446        Ok(fld.value().to_string())
447    }
448
449
450    /// Returns true if `ComplianceID` is present, Tag 376.
451    pub fn has_compliance_id(&self) -> bool {
452        self.message.body.has(tag::COMPLIANCE_ID)
453    }
454
455
456
457
458    /// Sets `ContractMultiplier`, Tag 231.
459    pub fn set_contract_multiplier(&mut self, val: Decimal, scale: i32) {
460        self.message.body.set_field(tag::CONTRACT_MULTIPLIER, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
461    }
462
463    /// Gets `ContractMultiplier`, Tag 231.
464    pub fn get_contract_multiplier(&self) -> Result<Decimal, MessageRejectErrorEnum> {
465        let mut fld = field::ContractMultiplierField::new(Decimal::ZERO, 0);
466        self.message.body.get_field(tag::CONTRACT_MULTIPLIER, &mut fld.0)?;
467        Ok(fld.value())
468    }
469
470
471    /// Returns true if `ContractMultiplier` is present, Tag 231.
472    pub fn has_contract_multiplier(&self) -> bool {
473        self.message.body.has(tag::CONTRACT_MULTIPLIER)
474    }
475
476
477
478
479    /// Sets `CountryOfIssue`, Tag 470.
480    pub fn set_country_of_issue(&mut self, v: String) {
481        self.message.body.set_field(tag::COUNTRY_OF_ISSUE, FIXString::from(v));
482    }
483
484    /// Gets `CountryOfIssue`, Tag 470.
485    pub fn get_country_of_issue(&self) -> Result<String, MessageRejectErrorEnum> {
486        let mut fld = field::CountryOfIssueField::new(String::new());
487        self.message.body.get_field(tag::COUNTRY_OF_ISSUE, &mut fld.0)?;
488        Ok(fld.value().to_string())
489    }
490
491
492    /// Returns true if `CountryOfIssue` is present, Tag 470.
493    pub fn has_country_of_issue(&self) -> bool {
494        self.message.body.has(tag::COUNTRY_OF_ISSUE)
495    }
496
497
498
499
500    /// Sets `CouponPaymentDate`, Tag 224.
501    pub fn set_coupon_payment_date(&mut self, v: String) {
502        self.message.body.set_field(tag::COUPON_PAYMENT_DATE, FIXString::from(v));
503    }
504
505    /// Gets `CouponPaymentDate`, Tag 224.
506    pub fn get_coupon_payment_date(&self) -> Result<String, MessageRejectErrorEnum> {
507        let mut fld = field::CouponPaymentDateField::new(String::new());
508        self.message.body.get_field(tag::COUPON_PAYMENT_DATE, &mut fld.0)?;
509        Ok(fld.value().to_string())
510    }
511
512
513    /// Returns true if `CouponPaymentDate` is present, Tag 224.
514    pub fn has_coupon_payment_date(&self) -> bool {
515        self.message.body.has(tag::COUPON_PAYMENT_DATE)
516    }
517
518
519
520
521    /// Sets `CouponRate`, Tag 223.
522    pub fn set_coupon_rate(&mut self, val: Decimal, scale: i32) {
523        self.message.body.set_field(tag::COUPON_RATE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
524    }
525
526    /// Gets `CouponRate`, Tag 223.
527    pub fn get_coupon_rate(&self) -> Result<Decimal, MessageRejectErrorEnum> {
528        let mut fld = field::CouponRateField::new(Decimal::ZERO, 0);
529        self.message.body.get_field(tag::COUPON_RATE, &mut fld.0)?;
530        Ok(fld.value())
531    }
532
533
534    /// Returns true if `CouponRate` is present, Tag 223.
535    pub fn has_coupon_rate(&self) -> bool {
536        self.message.body.has(tag::COUPON_RATE)
537    }
538
539
540
541
542    /// Sets `CoveredOrUncovered`, Tag 203.
543    pub fn set_covered_or_uncovered(&mut self, v: isize) {
544        self.message.body.set_field(tag::COVERED_OR_UNCOVERED, fixer::fix_int::FIXInt::from(v));
545    }
546
547    /// Gets `CoveredOrUncovered`, Tag 203.
548    pub fn get_covered_or_uncovered(&self) -> Result<isize, MessageRejectErrorEnum> {
549        let mut fld = field::CoveredOrUncoveredField::new(0);
550        self.message.body.get_field(tag::COVERED_OR_UNCOVERED, &mut fld.0)?;
551        Ok(fld.value())
552    }
553
554
555    /// Returns true if `CoveredOrUncovered` is present, Tag 203.
556    pub fn has_covered_or_uncovered(&self) -> bool {
557        self.message.body.has(tag::COVERED_OR_UNCOVERED)
558    }
559
560
561
562
563    /// Sets `CreditRating`, Tag 255.
564    pub fn set_credit_rating(&mut self, v: String) {
565        self.message.body.set_field(tag::CREDIT_RATING, FIXString::from(v));
566    }
567
568    /// Gets `CreditRating`, Tag 255.
569    pub fn get_credit_rating(&self) -> Result<String, MessageRejectErrorEnum> {
570        let mut fld = field::CreditRatingField::new(String::new());
571        self.message.body.get_field(tag::CREDIT_RATING, &mut fld.0)?;
572        Ok(fld.value().to_string())
573    }
574
575
576    /// Returns true if `CreditRating` is present, Tag 255.
577    pub fn has_credit_rating(&self) -> bool {
578        self.message.body.has(tag::CREDIT_RATING)
579    }
580
581
582
583
584    /// Sets `Currency`, Tag 15.
585    pub fn set_currency(&mut self, v: String) {
586        self.message.body.set_field(tag::CURRENCY, FIXString::from(v));
587    }
588
589    /// Gets `Currency`, Tag 15.
590    pub fn get_currency(&self) -> Result<String, MessageRejectErrorEnum> {
591        let mut fld = field::CurrencyField::new(String::new());
592        self.message.body.get_field(tag::CURRENCY, &mut fld.0)?;
593        Ok(fld.value().to_string())
594    }
595
596
597    /// Returns true if `Currency` is present, Tag 15.
598    pub fn has_currency(&self) -> bool {
599        self.message.body.has(tag::CURRENCY)
600    }
601
602
603
604
605    /// Sets `CustOrderCapacity`, Tag 582.
606    pub fn set_cust_order_capacity(&mut self, v: isize) {
607        self.message.body.set_field(tag::CUST_ORDER_CAPACITY, fixer::fix_int::FIXInt::from(v));
608    }
609
610    /// Gets `CustOrderCapacity`, Tag 582.
611    pub fn get_cust_order_capacity(&self) -> Result<isize, MessageRejectErrorEnum> {
612        let mut fld = field::CustOrderCapacityField::new(0);
613        self.message.body.get_field(tag::CUST_ORDER_CAPACITY, &mut fld.0)?;
614        Ok(fld.value())
615    }
616
617
618    /// Returns true if `CustOrderCapacity` is present, Tag 582.
619    pub fn has_cust_order_capacity(&self) -> bool {
620        self.message.body.has(tag::CUST_ORDER_CAPACITY)
621    }
622
623
624
625
626    /// Sets `DayBookingInst`, Tag 589.
627    pub fn set_day_booking_inst(&mut self, v: String) {
628        self.message.body.set_field(tag::DAY_BOOKING_INST, FIXString::from(v));
629    }
630
631    /// Gets `DayBookingInst`, Tag 589.
632    pub fn get_day_booking_inst(&self) -> Result<String, MessageRejectErrorEnum> {
633        let mut fld = field::DayBookingInstField::new(String::new());
634        self.message.body.get_field(tag::DAY_BOOKING_INST, &mut fld.0)?;
635        Ok(fld.value().to_string())
636    }
637
638
639    /// Returns true if `DayBookingInst` is present, Tag 589.
640    pub fn has_day_booking_inst(&self) -> bool {
641        self.message.body.has(tag::DAY_BOOKING_INST)
642    }
643
644
645
646
647    /// Sets `Designation`, Tag 494.
648    pub fn set_designation(&mut self, v: String) {
649        self.message.body.set_field(tag::DESIGNATION, FIXString::from(v));
650    }
651
652    /// Gets `Designation`, Tag 494.
653    pub fn get_designation(&self) -> Result<String, MessageRejectErrorEnum> {
654        let mut fld = field::DesignationField::new(String::new());
655        self.message.body.get_field(tag::DESIGNATION, &mut fld.0)?;
656        Ok(fld.value().to_string())
657    }
658
659
660    /// Returns true if `Designation` is present, Tag 494.
661    pub fn has_designation(&self) -> bool {
662        self.message.body.has(tag::DESIGNATION)
663    }
664
665
666
667
668    /// Sets `DiscretionInst`, Tag 388.
669    pub fn set_discretion_inst(&mut self, v: String) {
670        self.message.body.set_field(tag::DISCRETION_INST, FIXString::from(v));
671    }
672
673    /// Gets `DiscretionInst`, Tag 388.
674    pub fn get_discretion_inst(&self) -> Result<String, MessageRejectErrorEnum> {
675        let mut fld = field::DiscretionInstField::new(String::new());
676        self.message.body.get_field(tag::DISCRETION_INST, &mut fld.0)?;
677        Ok(fld.value().to_string())
678    }
679
680
681    /// Returns true if `DiscretionInst` is present, Tag 388.
682    pub fn has_discretion_inst(&self) -> bool {
683        self.message.body.has(tag::DISCRETION_INST)
684    }
685
686
687
688
689    /// Sets `DiscretionOffset`, Tag 389.
690    pub fn set_discretion_offset(&mut self, val: Decimal, scale: i32) {
691        self.message.body.set_field(tag::DISCRETION_OFFSET, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
692    }
693
694    /// Gets `DiscretionOffset`, Tag 389.
695    pub fn get_discretion_offset(&self) -> Result<Decimal, MessageRejectErrorEnum> {
696        let mut fld = field::DiscretionOffsetField::new(Decimal::ZERO, 0);
697        self.message.body.get_field(tag::DISCRETION_OFFSET, &mut fld.0)?;
698        Ok(fld.value())
699    }
700
701
702    /// Returns true if `DiscretionOffset` is present, Tag 389.
703    pub fn has_discretion_offset(&self) -> bool {
704        self.message.body.has(tag::DISCRETION_OFFSET)
705    }
706
707
708
709
710    /// Sets `EffectiveTime`, Tag 168.
711    pub fn set_effective_time(&mut self, v: Timestamp) {
712        self.message.body.set_field(tag::EFFECTIVE_TIME, fixer::fix_utc_timestamp::FIXUTCTimestamp {
713            time: v,
714            precision: fixer::fix_utc_timestamp::TimestampPrecision::Millis,
715        });
716    }
717
718    /// Gets `EffectiveTime`, Tag 168.
719    pub fn get_effective_time(&self) -> Result<Timestamp, MessageRejectErrorEnum> {
720        let mut fld = field::EffectiveTimeField::new(Timestamp::UNIX_EPOCH);
721        self.message.body.get_field(tag::EFFECTIVE_TIME, &mut fld.0)?;
722        Ok(fld.value())
723    }
724
725
726    /// Returns true if `EffectiveTime` is present, Tag 168.
727    pub fn has_effective_time(&self) -> bool {
728        self.message.body.has(tag::EFFECTIVE_TIME)
729    }
730
731
732
733
734    /// Sets `EncodedIssuer`, Tag 349.
735    pub fn set_encoded_issuer(&mut self, v: String) {
736        self.message.body.set_field(tag::ENCODED_ISSUER, FIXString::from(v));
737    }
738
739    /// Gets `EncodedIssuer`, Tag 349.
740    pub fn get_encoded_issuer(&self) -> Result<String, MessageRejectErrorEnum> {
741        let mut fld = field::EncodedIssuerField::new(String::new());
742        self.message.body.get_field(tag::ENCODED_ISSUER, &mut fld.0)?;
743        Ok(fld.value().to_string())
744    }
745
746
747    /// Returns true if `EncodedIssuer` is present, Tag 349.
748    pub fn has_encoded_issuer(&self) -> bool {
749        self.message.body.has(tag::ENCODED_ISSUER)
750    }
751
752
753
754
755    /// Sets `EncodedIssuerLen`, Tag 348.
756    pub fn set_encoded_issuer_len(&mut self, v: isize) {
757        self.message.body.set_field(tag::ENCODED_ISSUER_LEN, fixer::fix_int::FIXInt::from(v));
758    }
759
760    /// Gets `EncodedIssuerLen`, Tag 348.
761    pub fn get_encoded_issuer_len(&self) -> Result<isize, MessageRejectErrorEnum> {
762        let mut fld = field::EncodedIssuerLenField::new(0);
763        self.message.body.get_field(tag::ENCODED_ISSUER_LEN, &mut fld.0)?;
764        Ok(fld.value())
765    }
766
767
768    /// Returns true if `EncodedIssuerLen` is present, Tag 348.
769    pub fn has_encoded_issuer_len(&self) -> bool {
770        self.message.body.has(tag::ENCODED_ISSUER_LEN)
771    }
772
773
774
775
776    /// Sets `EncodedSecurityDesc`, Tag 351.
777    pub fn set_encoded_security_desc(&mut self, v: String) {
778        self.message.body.set_field(tag::ENCODED_SECURITY_DESC, FIXString::from(v));
779    }
780
781    /// Gets `EncodedSecurityDesc`, Tag 351.
782    pub fn get_encoded_security_desc(&self) -> Result<String, MessageRejectErrorEnum> {
783        let mut fld = field::EncodedSecurityDescField::new(String::new());
784        self.message.body.get_field(tag::ENCODED_SECURITY_DESC, &mut fld.0)?;
785        Ok(fld.value().to_string())
786    }
787
788
789    /// Returns true if `EncodedSecurityDesc` is present, Tag 351.
790    pub fn has_encoded_security_desc(&self) -> bool {
791        self.message.body.has(tag::ENCODED_SECURITY_DESC)
792    }
793
794
795
796
797    /// Sets `EncodedSecurityDescLen`, Tag 350.
798    pub fn set_encoded_security_desc_len(&mut self, v: isize) {
799        self.message.body.set_field(tag::ENCODED_SECURITY_DESC_LEN, fixer::fix_int::FIXInt::from(v));
800    }
801
802    /// Gets `EncodedSecurityDescLen`, Tag 350.
803    pub fn get_encoded_security_desc_len(&self) -> Result<isize, MessageRejectErrorEnum> {
804        let mut fld = field::EncodedSecurityDescLenField::new(0);
805        self.message.body.get_field(tag::ENCODED_SECURITY_DESC_LEN, &mut fld.0)?;
806        Ok(fld.value())
807    }
808
809
810    /// Returns true if `EncodedSecurityDescLen` is present, Tag 350.
811    pub fn has_encoded_security_desc_len(&self) -> bool {
812        self.message.body.has(tag::ENCODED_SECURITY_DESC_LEN)
813    }
814
815
816
817
818    /// Sets `EncodedText`, Tag 355.
819    pub fn set_encoded_text(&mut self, v: String) {
820        self.message.body.set_field(tag::ENCODED_TEXT, FIXString::from(v));
821    }
822
823    /// Gets `EncodedText`, Tag 355.
824    pub fn get_encoded_text(&self) -> Result<String, MessageRejectErrorEnum> {
825        let mut fld = field::EncodedTextField::new(String::new());
826        self.message.body.get_field(tag::ENCODED_TEXT, &mut fld.0)?;
827        Ok(fld.value().to_string())
828    }
829
830
831    /// Returns true if `EncodedText` is present, Tag 355.
832    pub fn has_encoded_text(&self) -> bool {
833        self.message.body.has(tag::ENCODED_TEXT)
834    }
835
836
837
838
839    /// Sets `EncodedTextLen`, Tag 354.
840    pub fn set_encoded_text_len(&mut self, v: isize) {
841        self.message.body.set_field(tag::ENCODED_TEXT_LEN, fixer::fix_int::FIXInt::from(v));
842    }
843
844    /// Gets `EncodedTextLen`, Tag 354.
845    pub fn get_encoded_text_len(&self) -> Result<isize, MessageRejectErrorEnum> {
846        let mut fld = field::EncodedTextLenField::new(0);
847        self.message.body.get_field(tag::ENCODED_TEXT_LEN, &mut fld.0)?;
848        Ok(fld.value())
849    }
850
851
852    /// Returns true if `EncodedTextLen` is present, Tag 354.
853    pub fn has_encoded_text_len(&self) -> bool {
854        self.message.body.has(tag::ENCODED_TEXT_LEN)
855    }
856
857
858
859
860    /// Sets `ExDestination`, Tag 100.
861    pub fn set_ex_destination(&mut self, v: String) {
862        self.message.body.set_field(tag::EX_DESTINATION, FIXString::from(v));
863    }
864
865    /// Gets `ExDestination`, Tag 100.
866    pub fn get_ex_destination(&self) -> Result<String, MessageRejectErrorEnum> {
867        let mut fld = field::ExDestinationField::new(String::new());
868        self.message.body.get_field(tag::EX_DESTINATION, &mut fld.0)?;
869        Ok(fld.value().to_string())
870    }
871
872
873    /// Returns true if `ExDestination` is present, Tag 100.
874    pub fn has_ex_destination(&self) -> bool {
875        self.message.body.has(tag::EX_DESTINATION)
876    }
877
878
879
880
881    /// Sets `ExecInst`, Tag 18.
882    pub fn set_exec_inst(&mut self, v: String) {
883        self.message.body.set_field(tag::EXEC_INST, FIXString::from(v));
884    }
885
886    /// Gets `ExecInst`, Tag 18.
887    pub fn get_exec_inst(&self) -> Result<String, MessageRejectErrorEnum> {
888        let mut fld = field::ExecInstField::new(String::new());
889        self.message.body.get_field(tag::EXEC_INST, &mut fld.0)?;
890        Ok(fld.value().to_string())
891    }
892
893
894    /// Returns true if `ExecInst` is present, Tag 18.
895    pub fn has_exec_inst(&self) -> bool {
896        self.message.body.has(tag::EXEC_INST)
897    }
898
899
900
901
902    /// Sets `ExpireDate`, Tag 432.
903    pub fn set_expire_date(&mut self, v: String) {
904        self.message.body.set_field(tag::EXPIRE_DATE, FIXString::from(v));
905    }
906
907    /// Gets `ExpireDate`, Tag 432.
908    pub fn get_expire_date(&self) -> Result<String, MessageRejectErrorEnum> {
909        let mut fld = field::ExpireDateField::new(String::new());
910        self.message.body.get_field(tag::EXPIRE_DATE, &mut fld.0)?;
911        Ok(fld.value().to_string())
912    }
913
914
915    /// Returns true if `ExpireDate` is present, Tag 432.
916    pub fn has_expire_date(&self) -> bool {
917        self.message.body.has(tag::EXPIRE_DATE)
918    }
919
920
921
922
923    /// Sets `ExpireTime`, Tag 126.
924    pub fn set_expire_time(&mut self, v: Timestamp) {
925        self.message.body.set_field(tag::EXPIRE_TIME, fixer::fix_utc_timestamp::FIXUTCTimestamp {
926            time: v,
927            precision: fixer::fix_utc_timestamp::TimestampPrecision::Millis,
928        });
929    }
930
931    /// Gets `ExpireTime`, Tag 126.
932    pub fn get_expire_time(&self) -> Result<Timestamp, MessageRejectErrorEnum> {
933        let mut fld = field::ExpireTimeField::new(Timestamp::UNIX_EPOCH);
934        self.message.body.get_field(tag::EXPIRE_TIME, &mut fld.0)?;
935        Ok(fld.value())
936    }
937
938
939    /// Returns true if `ExpireTime` is present, Tag 126.
940    pub fn has_expire_time(&self) -> bool {
941        self.message.body.has(tag::EXPIRE_TIME)
942    }
943
944
945
946
947    /// Sets `Factor`, Tag 228.
948    pub fn set_factor(&mut self, val: Decimal, scale: i32) {
949        self.message.body.set_field(tag::FACTOR, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
950    }
951
952    /// Gets `Factor`, Tag 228.
953    pub fn get_factor(&self) -> Result<Decimal, MessageRejectErrorEnum> {
954        let mut fld = field::FactorField::new(Decimal::ZERO, 0);
955        self.message.body.get_field(tag::FACTOR, &mut fld.0)?;
956        Ok(fld.value())
957    }
958
959
960    /// Returns true if `Factor` is present, Tag 228.
961    pub fn has_factor(&self) -> bool {
962        self.message.body.has(tag::FACTOR)
963    }
964
965
966
967
968    /// Sets `ForexReq`, Tag 121.
969    pub fn set_forex_req(&mut self, v: bool) {
970        self.message.body.set_field(tag::FOREX_REQ, fixer::fix_boolean::FIXBoolean::from(v));
971    }
972
973    /// Gets `ForexReq`, Tag 121.
974    pub fn get_forex_req(&self) -> Result<bool, MessageRejectErrorEnum> {
975        let mut fld = field::ForexReqField::new(false);
976        self.message.body.get_field(tag::FOREX_REQ, &mut fld.0)?;
977        Ok(fld.value())
978    }
979
980
981    /// Returns true if `ForexReq` is present, Tag 121.
982    pub fn has_forex_req(&self) -> bool {
983        self.message.body.has(tag::FOREX_REQ)
984    }
985
986
987
988
989    /// Sets `FundRenewWaiv`, Tag 497.
990    pub fn set_fund_renew_waiv(&mut self, v: String) {
991        self.message.body.set_field(tag::FUND_RENEW_WAIV, FIXString::from(v));
992    }
993
994    /// Gets `FundRenewWaiv`, Tag 497.
995    pub fn get_fund_renew_waiv(&self) -> Result<String, MessageRejectErrorEnum> {
996        let mut fld = field::FundRenewWaivField::new(String::new());
997        self.message.body.get_field(tag::FUND_RENEW_WAIV, &mut fld.0)?;
998        Ok(fld.value().to_string())
999    }
1000
1001
1002    /// Returns true if `FundRenewWaiv` is present, Tag 497.
1003    pub fn has_fund_renew_waiv(&self) -> bool {
1004        self.message.body.has(tag::FUND_RENEW_WAIV)
1005    }
1006
1007
1008
1009
1010    /// Sets `FutSettDate`, Tag 64.
1011    pub fn set_fut_sett_date(&mut self, v: String) {
1012        self.message.body.set_field(tag::FUT_SETT_DATE, FIXString::from(v));
1013    }
1014
1015    /// Gets `FutSettDate`, Tag 64.
1016    pub fn get_fut_sett_date(&self) -> Result<String, MessageRejectErrorEnum> {
1017        let mut fld = field::FutSettDateField::new(String::new());
1018        self.message.body.get_field(tag::FUT_SETT_DATE, &mut fld.0)?;
1019        Ok(fld.value().to_string())
1020    }
1021
1022
1023    /// Returns true if `FutSettDate` is present, Tag 64.
1024    pub fn has_fut_sett_date(&self) -> bool {
1025        self.message.body.has(tag::FUT_SETT_DATE)
1026    }
1027
1028
1029
1030
1031    /// Sets `FutSettDate2`, Tag 193.
1032    pub fn set_fut_sett_date2(&mut self, v: String) {
1033        self.message.body.set_field(tag::FUT_SETT_DATE2, FIXString::from(v));
1034    }
1035
1036    /// Gets `FutSettDate2`, Tag 193.
1037    pub fn get_fut_sett_date2(&self) -> Result<String, MessageRejectErrorEnum> {
1038        let mut fld = field::FutSettDate2Field::new(String::new());
1039        self.message.body.get_field(tag::FUT_SETT_DATE2, &mut fld.0)?;
1040        Ok(fld.value().to_string())
1041    }
1042
1043
1044    /// Returns true if `FutSettDate2` is present, Tag 193.
1045    pub fn has_fut_sett_date2(&self) -> bool {
1046        self.message.body.has(tag::FUT_SETT_DATE2)
1047    }
1048
1049
1050
1051
1052    /// Sets `GTBookingInst`, Tag 427.
1053    pub fn set_gt_booking_inst(&mut self, v: isize) {
1054        self.message.body.set_field(tag::GT_BOOKING_INST, fixer::fix_int::FIXInt::from(v));
1055    }
1056
1057    /// Gets `GTBookingInst`, Tag 427.
1058    pub fn get_gt_booking_inst(&self) -> Result<isize, MessageRejectErrorEnum> {
1059        let mut fld = field::GTBookingInstField::new(0);
1060        self.message.body.get_field(tag::GT_BOOKING_INST, &mut fld.0)?;
1061        Ok(fld.value())
1062    }
1063
1064
1065    /// Returns true if `GTBookingInst` is present, Tag 427.
1066    pub fn has_gt_booking_inst(&self) -> bool {
1067        self.message.body.has(tag::GT_BOOKING_INST)
1068    }
1069
1070
1071
1072
1073    /// Sets `HandlInst`, Tag 21.
1074    pub fn set_handl_inst(&mut self, v: String) {
1075        self.message.body.set_field(tag::HANDL_INST, FIXString::from(v));
1076    }
1077
1078    /// Gets `HandlInst`, Tag 21.
1079    pub fn get_handl_inst(&self) -> Result<String, MessageRejectErrorEnum> {
1080        let mut fld = field::HandlInstField::new(String::new());
1081        self.message.body.get_field(tag::HANDL_INST, &mut fld.0)?;
1082        Ok(fld.value().to_string())
1083    }
1084
1085
1086    /// Returns true if `HandlInst` is present, Tag 21.
1087    pub fn has_handl_inst(&self) -> bool {
1088        self.message.body.has(tag::HANDL_INST)
1089    }
1090
1091
1092
1093
1094    /// Sets `InstrRegistry`, Tag 543.
1095    pub fn set_instr_registry(&mut self, v: String) {
1096        self.message.body.set_field(tag::INSTR_REGISTRY, FIXString::from(v));
1097    }
1098
1099    /// Gets `InstrRegistry`, Tag 543.
1100    pub fn get_instr_registry(&self) -> Result<String, MessageRejectErrorEnum> {
1101        let mut fld = field::InstrRegistryField::new(String::new());
1102        self.message.body.get_field(tag::INSTR_REGISTRY, &mut fld.0)?;
1103        Ok(fld.value().to_string())
1104    }
1105
1106
1107    /// Returns true if `InstrRegistry` is present, Tag 543.
1108    pub fn has_instr_registry(&self) -> bool {
1109        self.message.body.has(tag::INSTR_REGISTRY)
1110    }
1111
1112
1113
1114
1115    /// Sets `IssueDate`, Tag 225.
1116    pub fn set_issue_date(&mut self, v: String) {
1117        self.message.body.set_field(tag::ISSUE_DATE, FIXString::from(v));
1118    }
1119
1120    /// Gets `IssueDate`, Tag 225.
1121    pub fn get_issue_date(&self) -> Result<String, MessageRejectErrorEnum> {
1122        let mut fld = field::IssueDateField::new(String::new());
1123        self.message.body.get_field(tag::ISSUE_DATE, &mut fld.0)?;
1124        Ok(fld.value().to_string())
1125    }
1126
1127
1128    /// Returns true if `IssueDate` is present, Tag 225.
1129    pub fn has_issue_date(&self) -> bool {
1130        self.message.body.has(tag::ISSUE_DATE)
1131    }
1132
1133
1134
1135
1136    /// Sets `Issuer`, Tag 106.
1137    pub fn set_issuer(&mut self, v: String) {
1138        self.message.body.set_field(tag::ISSUER, FIXString::from(v));
1139    }
1140
1141    /// Gets `Issuer`, Tag 106.
1142    pub fn get_issuer(&self) -> Result<String, MessageRejectErrorEnum> {
1143        let mut fld = field::IssuerField::new(String::new());
1144        self.message.body.get_field(tag::ISSUER, &mut fld.0)?;
1145        Ok(fld.value().to_string())
1146    }
1147
1148
1149    /// Returns true if `Issuer` is present, Tag 106.
1150    pub fn has_issuer(&self) -> bool {
1151        self.message.body.has(tag::ISSUER)
1152    }
1153
1154
1155
1156
1157    /// Sets `ListID`, Tag 66.
1158    pub fn set_list_id(&mut self, v: String) {
1159        self.message.body.set_field(tag::LIST_ID, FIXString::from(v));
1160    }
1161
1162    /// Gets `ListID`, Tag 66.
1163    pub fn get_list_id(&self) -> Result<String, MessageRejectErrorEnum> {
1164        let mut fld = field::ListIDField::new(String::new());
1165        self.message.body.get_field(tag::LIST_ID, &mut fld.0)?;
1166        Ok(fld.value().to_string())
1167    }
1168
1169
1170    /// Returns true if `ListID` is present, Tag 66.
1171    pub fn has_list_id(&self) -> bool {
1172        self.message.body.has(tag::LIST_ID)
1173    }
1174
1175
1176
1177
1178    /// Sets `LocaleOfIssue`, Tag 472.
1179    pub fn set_locale_of_issue(&mut self, v: String) {
1180        self.message.body.set_field(tag::LOCALE_OF_ISSUE, FIXString::from(v));
1181    }
1182
1183    /// Gets `LocaleOfIssue`, Tag 472.
1184    pub fn get_locale_of_issue(&self) -> Result<String, MessageRejectErrorEnum> {
1185        let mut fld = field::LocaleOfIssueField::new(String::new());
1186        self.message.body.get_field(tag::LOCALE_OF_ISSUE, &mut fld.0)?;
1187        Ok(fld.value().to_string())
1188    }
1189
1190
1191    /// Returns true if `LocaleOfIssue` is present, Tag 472.
1192    pub fn has_locale_of_issue(&self) -> bool {
1193        self.message.body.has(tag::LOCALE_OF_ISSUE)
1194    }
1195
1196
1197
1198
1199    /// Sets `LocateReqd`, Tag 114.
1200    pub fn set_locate_reqd(&mut self, v: bool) {
1201        self.message.body.set_field(tag::LOCATE_REQD, fixer::fix_boolean::FIXBoolean::from(v));
1202    }
1203
1204    /// Gets `LocateReqd`, Tag 114.
1205    pub fn get_locate_reqd(&self) -> Result<bool, MessageRejectErrorEnum> {
1206        let mut fld = field::LocateReqdField::new(false);
1207        self.message.body.get_field(tag::LOCATE_REQD, &mut fld.0)?;
1208        Ok(fld.value())
1209    }
1210
1211
1212    /// Returns true if `LocateReqd` is present, Tag 114.
1213    pub fn has_locate_reqd(&self) -> bool {
1214        self.message.body.has(tag::LOCATE_REQD)
1215    }
1216
1217
1218
1219
1220    /// Sets `MaturityDate`, Tag 541.
1221    pub fn set_maturity_date(&mut self, v: String) {
1222        self.message.body.set_field(tag::MATURITY_DATE, FIXString::from(v));
1223    }
1224
1225    /// Gets `MaturityDate`, Tag 541.
1226    pub fn get_maturity_date(&self) -> Result<String, MessageRejectErrorEnum> {
1227        let mut fld = field::MaturityDateField::new(String::new());
1228        self.message.body.get_field(tag::MATURITY_DATE, &mut fld.0)?;
1229        Ok(fld.value().to_string())
1230    }
1231
1232
1233    /// Returns true if `MaturityDate` is present, Tag 541.
1234    pub fn has_maturity_date(&self) -> bool {
1235        self.message.body.has(tag::MATURITY_DATE)
1236    }
1237
1238
1239
1240
1241    /// Sets `MaturityMonthYear`, Tag 200.
1242    pub fn set_maturity_month_year(&mut self, v: String) {
1243        self.message.body.set_field(tag::MATURITY_MONTH_YEAR, FIXString::from(v));
1244    }
1245
1246    /// Gets `MaturityMonthYear`, Tag 200.
1247    pub fn get_maturity_month_year(&self) -> Result<String, MessageRejectErrorEnum> {
1248        let mut fld = field::MaturityMonthYearField::new(String::new());
1249        self.message.body.get_field(tag::MATURITY_MONTH_YEAR, &mut fld.0)?;
1250        Ok(fld.value().to_string())
1251    }
1252
1253
1254    /// Returns true if `MaturityMonthYear` is present, Tag 200.
1255    pub fn has_maturity_month_year(&self) -> bool {
1256        self.message.body.has(tag::MATURITY_MONTH_YEAR)
1257    }
1258
1259
1260
1261
1262    /// Sets `MaxFloor`, Tag 111.
1263    pub fn set_max_floor(&mut self, val: Decimal, scale: i32) {
1264        self.message.body.set_field(tag::MAX_FLOOR, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1265    }
1266
1267    /// Gets `MaxFloor`, Tag 111.
1268    pub fn get_max_floor(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1269        let mut fld = field::MaxFloorField::new(Decimal::ZERO, 0);
1270        self.message.body.get_field(tag::MAX_FLOOR, &mut fld.0)?;
1271        Ok(fld.value())
1272    }
1273
1274
1275    /// Returns true if `MaxFloor` is present, Tag 111.
1276    pub fn has_max_floor(&self) -> bool {
1277        self.message.body.has(tag::MAX_FLOOR)
1278    }
1279
1280
1281
1282
1283    /// Sets `MaxShow`, Tag 210.
1284    pub fn set_max_show(&mut self, val: Decimal, scale: i32) {
1285        self.message.body.set_field(tag::MAX_SHOW, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1286    }
1287
1288    /// Gets `MaxShow`, Tag 210.
1289    pub fn get_max_show(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1290        let mut fld = field::MaxShowField::new(Decimal::ZERO, 0);
1291        self.message.body.get_field(tag::MAX_SHOW, &mut fld.0)?;
1292        Ok(fld.value())
1293    }
1294
1295
1296    /// Returns true if `MaxShow` is present, Tag 210.
1297    pub fn has_max_show(&self) -> bool {
1298        self.message.body.has(tag::MAX_SHOW)
1299    }
1300
1301
1302
1303
1304    /// Sets `MinQty`, Tag 110.
1305    pub fn set_min_qty(&mut self, val: Decimal, scale: i32) {
1306        self.message.body.set_field(tag::MIN_QTY, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1307    }
1308
1309    /// Gets `MinQty`, Tag 110.
1310    pub fn get_min_qty(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1311        let mut fld = field::MinQtyField::new(Decimal::ZERO, 0);
1312        self.message.body.get_field(tag::MIN_QTY, &mut fld.0)?;
1313        Ok(fld.value())
1314    }
1315
1316
1317    /// Returns true if `MinQty` is present, Tag 110.
1318    pub fn has_min_qty(&self) -> bool {
1319        self.message.body.has(tag::MIN_QTY)
1320    }
1321
1322
1323
1324
1325    /// Sets `MoneyLaunderingStatus`, Tag 481.
1326    pub fn set_money_laundering_status(&mut self, v: String) {
1327        self.message.body.set_field(tag::MONEY_LAUNDERING_STATUS, FIXString::from(v));
1328    }
1329
1330    /// Gets `MoneyLaunderingStatus`, Tag 481.
1331    pub fn get_money_laundering_status(&self) -> Result<String, MessageRejectErrorEnum> {
1332        let mut fld = field::MoneyLaunderingStatusField::new(String::new());
1333        self.message.body.get_field(tag::MONEY_LAUNDERING_STATUS, &mut fld.0)?;
1334        Ok(fld.value().to_string())
1335    }
1336
1337
1338    /// Returns true if `MoneyLaunderingStatus` is present, Tag 481.
1339    pub fn has_money_laundering_status(&self) -> bool {
1340        self.message.body.has(tag::MONEY_LAUNDERING_STATUS)
1341    }
1342
1343
1344
1345
1346    /// Sets `NetMoney`, Tag 118.
1347    pub fn set_net_money(&mut self, val: Decimal, scale: i32) {
1348        self.message.body.set_field(tag::NET_MONEY, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1349    }
1350
1351    /// Gets `NetMoney`, Tag 118.
1352    pub fn get_net_money(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1353        let mut fld = field::NetMoneyField::new(Decimal::ZERO, 0);
1354        self.message.body.get_field(tag::NET_MONEY, &mut fld.0)?;
1355        Ok(fld.value())
1356    }
1357
1358
1359    /// Returns true if `NetMoney` is present, Tag 118.
1360    pub fn has_net_money(&self) -> bool {
1361        self.message.body.has(tag::NET_MONEY)
1362    }
1363
1364
1365
1366
1367    /// Sets `NoAllocs`, Tag 78.
1368    pub fn set_no_allocs(&mut self, v: isize) {
1369        self.message.body.set_field(tag::NO_ALLOCS, fixer::fix_int::FIXInt::from(v));
1370    }
1371
1372    /// Gets `NoAllocs`, Tag 78.
1373    pub fn get_no_allocs(&self) -> Result<isize, MessageRejectErrorEnum> {
1374        let mut fld = field::NoAllocsField::new(0);
1375        self.message.body.get_field(tag::NO_ALLOCS, &mut fld.0)?;
1376        Ok(fld.value())
1377    }
1378
1379
1380    /// Returns true if `NoAllocs` is present, Tag 78.
1381    pub fn has_no_allocs(&self) -> bool {
1382        self.message.body.has(tag::NO_ALLOCS)
1383    }
1384
1385
1386
1387
1388    /// Sets `NoPartyIDs`, Tag 453.
1389    pub fn set_no_party_i_ds(&mut self, v: isize) {
1390        self.message.body.set_field(tag::NO_PARTY_I_DS, fixer::fix_int::FIXInt::from(v));
1391    }
1392
1393    /// Gets `NoPartyIDs`, Tag 453.
1394    pub fn get_no_party_i_ds(&self) -> Result<isize, MessageRejectErrorEnum> {
1395        let mut fld = field::NoPartyIDsField::new(0);
1396        self.message.body.get_field(tag::NO_PARTY_I_DS, &mut fld.0)?;
1397        Ok(fld.value())
1398    }
1399
1400
1401    /// Returns true if `NoPartyIDs` is present, Tag 453.
1402    pub fn has_no_party_i_ds(&self) -> bool {
1403        self.message.body.has(tag::NO_PARTY_I_DS)
1404    }
1405
1406
1407
1408
1409    /// Sets `NoSecurityAltID`, Tag 454.
1410    pub fn set_no_security_alt_id(&mut self, v: isize) {
1411        self.message.body.set_field(tag::NO_SECURITY_ALT_ID, fixer::fix_int::FIXInt::from(v));
1412    }
1413
1414    /// Gets `NoSecurityAltID`, Tag 454.
1415    pub fn get_no_security_alt_id(&self) -> Result<isize, MessageRejectErrorEnum> {
1416        let mut fld = field::NoSecurityAltIDField::new(0);
1417        self.message.body.get_field(tag::NO_SECURITY_ALT_ID, &mut fld.0)?;
1418        Ok(fld.value())
1419    }
1420
1421
1422    /// Returns true if `NoSecurityAltID` is present, Tag 454.
1423    pub fn has_no_security_alt_id(&self) -> bool {
1424        self.message.body.has(tag::NO_SECURITY_ALT_ID)
1425    }
1426
1427
1428
1429
1430    /// Sets `NoTradingSessions`, Tag 386.
1431    pub fn set_no_trading_sessions(&mut self, v: isize) {
1432        self.message.body.set_field(tag::NO_TRADING_SESSIONS, fixer::fix_int::FIXInt::from(v));
1433    }
1434
1435    /// Gets `NoTradingSessions`, Tag 386.
1436    pub fn get_no_trading_sessions(&self) -> Result<isize, MessageRejectErrorEnum> {
1437        let mut fld = field::NoTradingSessionsField::new(0);
1438        self.message.body.get_field(tag::NO_TRADING_SESSIONS, &mut fld.0)?;
1439        Ok(fld.value())
1440    }
1441
1442
1443    /// Returns true if `NoTradingSessions` is present, Tag 386.
1444    pub fn has_no_trading_sessions(&self) -> bool {
1445        self.message.body.has(tag::NO_TRADING_SESSIONS)
1446    }
1447
1448
1449
1450
1451    /// Sets `OptAttribute`, Tag 206.
1452    pub fn set_opt_attribute(&mut self, v: String) {
1453        self.message.body.set_field(tag::OPT_ATTRIBUTE, FIXString::from(v));
1454    }
1455
1456    /// Gets `OptAttribute`, Tag 206.
1457    pub fn get_opt_attribute(&self) -> Result<String, MessageRejectErrorEnum> {
1458        let mut fld = field::OptAttributeField::new(String::new());
1459        self.message.body.get_field(tag::OPT_ATTRIBUTE, &mut fld.0)?;
1460        Ok(fld.value().to_string())
1461    }
1462
1463
1464    /// Returns true if `OptAttribute` is present, Tag 206.
1465    pub fn has_opt_attribute(&self) -> bool {
1466        self.message.body.has(tag::OPT_ATTRIBUTE)
1467    }
1468
1469
1470
1471
1472    /// Sets `OrdType`, Tag 40.
1473    pub fn set_ord_type(&mut self, v: String) {
1474        self.message.body.set_field(tag::ORD_TYPE, FIXString::from(v));
1475    }
1476
1477    /// Gets `OrdType`, Tag 40.
1478    pub fn get_ord_type(&self) -> Result<String, MessageRejectErrorEnum> {
1479        let mut fld = field::OrdTypeField::new(String::new());
1480        self.message.body.get_field(tag::ORD_TYPE, &mut fld.0)?;
1481        Ok(fld.value().to_string())
1482    }
1483
1484
1485    /// Returns true if `OrdType` is present, Tag 40.
1486    pub fn has_ord_type(&self) -> bool {
1487        self.message.body.has(tag::ORD_TYPE)
1488    }
1489
1490
1491
1492
1493    /// Sets `OrderCapacity`, Tag 528.
1494    pub fn set_order_capacity(&mut self, v: String) {
1495        self.message.body.set_field(tag::ORDER_CAPACITY, FIXString::from(v));
1496    }
1497
1498    /// Gets `OrderCapacity`, Tag 528.
1499    pub fn get_order_capacity(&self) -> Result<String, MessageRejectErrorEnum> {
1500        let mut fld = field::OrderCapacityField::new(String::new());
1501        self.message.body.get_field(tag::ORDER_CAPACITY, &mut fld.0)?;
1502        Ok(fld.value().to_string())
1503    }
1504
1505
1506    /// Returns true if `OrderCapacity` is present, Tag 528.
1507    pub fn has_order_capacity(&self) -> bool {
1508        self.message.body.has(tag::ORDER_CAPACITY)
1509    }
1510
1511
1512
1513
1514    /// Sets `OrderID`, Tag 37.
1515    pub fn set_order_id(&mut self, v: String) {
1516        self.message.body.set_field(tag::ORDER_ID, FIXString::from(v));
1517    }
1518
1519    /// Gets `OrderID`, Tag 37.
1520    pub fn get_order_id(&self) -> Result<String, MessageRejectErrorEnum> {
1521        let mut fld = field::OrderIDField::new(String::new());
1522        self.message.body.get_field(tag::ORDER_ID, &mut fld.0)?;
1523        Ok(fld.value().to_string())
1524    }
1525
1526
1527    /// Returns true if `OrderID` is present, Tag 37.
1528    pub fn has_order_id(&self) -> bool {
1529        self.message.body.has(tag::ORDER_ID)
1530    }
1531
1532
1533
1534
1535    /// Sets `OrderPercent`, Tag 516.
1536    pub fn set_order_percent(&mut self, val: Decimal, scale: i32) {
1537        self.message.body.set_field(tag::ORDER_PERCENT, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1538    }
1539
1540    /// Gets `OrderPercent`, Tag 516.
1541    pub fn get_order_percent(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1542        let mut fld = field::OrderPercentField::new(Decimal::ZERO, 0);
1543        self.message.body.get_field(tag::ORDER_PERCENT, &mut fld.0)?;
1544        Ok(fld.value())
1545    }
1546
1547
1548    /// Returns true if `OrderPercent` is present, Tag 516.
1549    pub fn has_order_percent(&self) -> bool {
1550        self.message.body.has(tag::ORDER_PERCENT)
1551    }
1552
1553
1554
1555
1556    /// Sets `OrderQty`, Tag 38.
1557    pub fn set_order_qty(&mut self, val: Decimal, scale: i32) {
1558        self.message.body.set_field(tag::ORDER_QTY, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1559    }
1560
1561    /// Gets `OrderQty`, Tag 38.
1562    pub fn get_order_qty(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1563        let mut fld = field::OrderQtyField::new(Decimal::ZERO, 0);
1564        self.message.body.get_field(tag::ORDER_QTY, &mut fld.0)?;
1565        Ok(fld.value())
1566    }
1567
1568
1569    /// Returns true if `OrderQty` is present, Tag 38.
1570    pub fn has_order_qty(&self) -> bool {
1571        self.message.body.has(tag::ORDER_QTY)
1572    }
1573
1574
1575
1576
1577    /// Sets `OrderQty2`, Tag 192.
1578    pub fn set_order_qty2(&mut self, val: Decimal, scale: i32) {
1579        self.message.body.set_field(tag::ORDER_QTY2, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1580    }
1581
1582    /// Gets `OrderQty2`, Tag 192.
1583    pub fn get_order_qty2(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1584        let mut fld = field::OrderQty2Field::new(Decimal::ZERO, 0);
1585        self.message.body.get_field(tag::ORDER_QTY2, &mut fld.0)?;
1586        Ok(fld.value())
1587    }
1588
1589
1590    /// Returns true if `OrderQty2` is present, Tag 192.
1591    pub fn has_order_qty2(&self) -> bool {
1592        self.message.body.has(tag::ORDER_QTY2)
1593    }
1594
1595
1596
1597
1598    /// Sets `OrderRestrictions`, Tag 529.
1599    pub fn set_order_restrictions(&mut self, v: String) {
1600        self.message.body.set_field(tag::ORDER_RESTRICTIONS, FIXString::from(v));
1601    }
1602
1603    /// Gets `OrderRestrictions`, Tag 529.
1604    pub fn get_order_restrictions(&self) -> Result<String, MessageRejectErrorEnum> {
1605        let mut fld = field::OrderRestrictionsField::new(String::new());
1606        self.message.body.get_field(tag::ORDER_RESTRICTIONS, &mut fld.0)?;
1607        Ok(fld.value().to_string())
1608    }
1609
1610
1611    /// Returns true if `OrderRestrictions` is present, Tag 529.
1612    pub fn has_order_restrictions(&self) -> bool {
1613        self.message.body.has(tag::ORDER_RESTRICTIONS)
1614    }
1615
1616
1617
1618
1619    /// Sets `OrigClOrdID`, Tag 41.
1620    pub fn set_orig_cl_ord_id(&mut self, v: String) {
1621        self.message.body.set_field(tag::ORIG_CL_ORD_ID, FIXString::from(v));
1622    }
1623
1624    /// Gets `OrigClOrdID`, Tag 41.
1625    pub fn get_orig_cl_ord_id(&self) -> Result<String, MessageRejectErrorEnum> {
1626        let mut fld = field::OrigClOrdIDField::new(String::new());
1627        self.message.body.get_field(tag::ORIG_CL_ORD_ID, &mut fld.0)?;
1628        Ok(fld.value().to_string())
1629    }
1630
1631
1632    /// Returns true if `OrigClOrdID` is present, Tag 41.
1633    pub fn has_orig_cl_ord_id(&self) -> bool {
1634        self.message.body.has(tag::ORIG_CL_ORD_ID)
1635    }
1636
1637
1638
1639
1640    /// Sets `OrigOrdModTime`, Tag 586.
1641    pub fn set_orig_ord_mod_time(&mut self, v: Timestamp) {
1642        self.message.body.set_field(tag::ORIG_ORD_MOD_TIME, fixer::fix_utc_timestamp::FIXUTCTimestamp {
1643            time: v,
1644            precision: fixer::fix_utc_timestamp::TimestampPrecision::Millis,
1645        });
1646    }
1647
1648    /// Gets `OrigOrdModTime`, Tag 586.
1649    pub fn get_orig_ord_mod_time(&self) -> Result<Timestamp, MessageRejectErrorEnum> {
1650        let mut fld = field::OrigOrdModTimeField::new(Timestamp::UNIX_EPOCH);
1651        self.message.body.get_field(tag::ORIG_ORD_MOD_TIME, &mut fld.0)?;
1652        Ok(fld.value())
1653    }
1654
1655
1656    /// Returns true if `OrigOrdModTime` is present, Tag 586.
1657    pub fn has_orig_ord_mod_time(&self) -> bool {
1658        self.message.body.has(tag::ORIG_ORD_MOD_TIME)
1659    }
1660
1661
1662
1663
1664    /// Sets `PegDifference`, Tag 211.
1665    pub fn set_peg_difference(&mut self, val: Decimal, scale: i32) {
1666        self.message.body.set_field(tag::PEG_DIFFERENCE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1667    }
1668
1669    /// Gets `PegDifference`, Tag 211.
1670    pub fn get_peg_difference(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1671        let mut fld = field::PegDifferenceField::new(Decimal::ZERO, 0);
1672        self.message.body.get_field(tag::PEG_DIFFERENCE, &mut fld.0)?;
1673        Ok(fld.value())
1674    }
1675
1676
1677    /// Returns true if `PegDifference` is present, Tag 211.
1678    pub fn has_peg_difference(&self) -> bool {
1679        self.message.body.has(tag::PEG_DIFFERENCE)
1680    }
1681
1682
1683
1684
1685    /// Sets `PositionEffect`, Tag 77.
1686    pub fn set_position_effect(&mut self, v: String) {
1687        self.message.body.set_field(tag::POSITION_EFFECT, FIXString::from(v));
1688    }
1689
1690    /// Gets `PositionEffect`, Tag 77.
1691    pub fn get_position_effect(&self) -> Result<String, MessageRejectErrorEnum> {
1692        let mut fld = field::PositionEffectField::new(String::new());
1693        self.message.body.get_field(tag::POSITION_EFFECT, &mut fld.0)?;
1694        Ok(fld.value().to_string())
1695    }
1696
1697
1698    /// Returns true if `PositionEffect` is present, Tag 77.
1699    pub fn has_position_effect(&self) -> bool {
1700        self.message.body.has(tag::POSITION_EFFECT)
1701    }
1702
1703
1704
1705
1706    /// Sets `PreallocMethod`, Tag 591.
1707    pub fn set_prealloc_method(&mut self, v: String) {
1708        self.message.body.set_field(tag::PREALLOC_METHOD, FIXString::from(v));
1709    }
1710
1711    /// Gets `PreallocMethod`, Tag 591.
1712    pub fn get_prealloc_method(&self) -> Result<String, MessageRejectErrorEnum> {
1713        let mut fld = field::PreallocMethodField::new(String::new());
1714        self.message.body.get_field(tag::PREALLOC_METHOD, &mut fld.0)?;
1715        Ok(fld.value().to_string())
1716    }
1717
1718
1719    /// Returns true if `PreallocMethod` is present, Tag 591.
1720    pub fn has_prealloc_method(&self) -> bool {
1721        self.message.body.has(tag::PREALLOC_METHOD)
1722    }
1723
1724
1725
1726
1727    /// Sets `Price`, Tag 44.
1728    pub fn set_price(&mut self, val: Decimal, scale: i32) {
1729        self.message.body.set_field(tag::PRICE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1730    }
1731
1732    /// Gets `Price`, Tag 44.
1733    pub fn get_price(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1734        let mut fld = field::PriceField::new(Decimal::ZERO, 0);
1735        self.message.body.get_field(tag::PRICE, &mut fld.0)?;
1736        Ok(fld.value())
1737    }
1738
1739
1740    /// Returns true if `Price` is present, Tag 44.
1741    pub fn has_price(&self) -> bool {
1742        self.message.body.has(tag::PRICE)
1743    }
1744
1745
1746
1747
1748    /// Sets `Price2`, Tag 640.
1749    pub fn set_price2(&mut self, val: Decimal, scale: i32) {
1750        self.message.body.set_field(tag::PRICE2, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1751    }
1752
1753    /// Gets `Price2`, Tag 640.
1754    pub fn get_price2(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1755        let mut fld = field::Price2Field::new(Decimal::ZERO, 0);
1756        self.message.body.get_field(tag::PRICE2, &mut fld.0)?;
1757        Ok(fld.value())
1758    }
1759
1760
1761    /// Returns true if `Price2` is present, Tag 640.
1762    pub fn has_price2(&self) -> bool {
1763        self.message.body.has(tag::PRICE2)
1764    }
1765
1766
1767
1768
1769    /// Sets `PriceType`, Tag 423.
1770    pub fn set_price_type(&mut self, v: isize) {
1771        self.message.body.set_field(tag::PRICE_TYPE, fixer::fix_int::FIXInt::from(v));
1772    }
1773
1774    /// Gets `PriceType`, Tag 423.
1775    pub fn get_price_type(&self) -> Result<isize, MessageRejectErrorEnum> {
1776        let mut fld = field::PriceTypeField::new(0);
1777        self.message.body.get_field(tag::PRICE_TYPE, &mut fld.0)?;
1778        Ok(fld.value())
1779    }
1780
1781
1782    /// Returns true if `PriceType` is present, Tag 423.
1783    pub fn has_price_type(&self) -> bool {
1784        self.message.body.has(tag::PRICE_TYPE)
1785    }
1786
1787
1788
1789
1790    /// Sets `Product`, Tag 460.
1791    pub fn set_product(&mut self, v: isize) {
1792        self.message.body.set_field(tag::PRODUCT, fixer::fix_int::FIXInt::from(v));
1793    }
1794
1795    /// Gets `Product`, Tag 460.
1796    pub fn get_product(&self) -> Result<isize, MessageRejectErrorEnum> {
1797        let mut fld = field::ProductField::new(0);
1798        self.message.body.get_field(tag::PRODUCT, &mut fld.0)?;
1799        Ok(fld.value())
1800    }
1801
1802
1803    /// Returns true if `Product` is present, Tag 460.
1804    pub fn has_product(&self) -> bool {
1805        self.message.body.has(tag::PRODUCT)
1806    }
1807
1808
1809
1810
1811    /// Sets `QuantityType`, Tag 465.
1812    pub fn set_quantity_type(&mut self, v: isize) {
1813        self.message.body.set_field(tag::QUANTITY_TYPE, fixer::fix_int::FIXInt::from(v));
1814    }
1815
1816    /// Gets `QuantityType`, Tag 465.
1817    pub fn get_quantity_type(&self) -> Result<isize, MessageRejectErrorEnum> {
1818        let mut fld = field::QuantityTypeField::new(0);
1819        self.message.body.get_field(tag::QUANTITY_TYPE, &mut fld.0)?;
1820        Ok(fld.value())
1821    }
1822
1823
1824    /// Returns true if `QuantityType` is present, Tag 465.
1825    pub fn has_quantity_type(&self) -> bool {
1826        self.message.body.has(tag::QUANTITY_TYPE)
1827    }
1828
1829
1830
1831
1832    /// Sets `RedemptionDate`, Tag 240.
1833    pub fn set_redemption_date(&mut self, v: String) {
1834        self.message.body.set_field(tag::REDEMPTION_DATE, FIXString::from(v));
1835    }
1836
1837    /// Gets `RedemptionDate`, Tag 240.
1838    pub fn get_redemption_date(&self) -> Result<String, MessageRejectErrorEnum> {
1839        let mut fld = field::RedemptionDateField::new(String::new());
1840        self.message.body.get_field(tag::REDEMPTION_DATE, &mut fld.0)?;
1841        Ok(fld.value().to_string())
1842    }
1843
1844
1845    /// Returns true if `RedemptionDate` is present, Tag 240.
1846    pub fn has_redemption_date(&self) -> bool {
1847        self.message.body.has(tag::REDEMPTION_DATE)
1848    }
1849
1850
1851
1852
1853    /// Sets `RegistID`, Tag 513.
1854    pub fn set_regist_id(&mut self, v: String) {
1855        self.message.body.set_field(tag::REGIST_ID, FIXString::from(v));
1856    }
1857
1858    /// Gets `RegistID`, Tag 513.
1859    pub fn get_regist_id(&self) -> Result<String, MessageRejectErrorEnum> {
1860        let mut fld = field::RegistIDField::new(String::new());
1861        self.message.body.get_field(tag::REGIST_ID, &mut fld.0)?;
1862        Ok(fld.value().to_string())
1863    }
1864
1865
1866    /// Returns true if `RegistID` is present, Tag 513.
1867    pub fn has_regist_id(&self) -> bool {
1868        self.message.body.has(tag::REGIST_ID)
1869    }
1870
1871
1872
1873
1874    /// Sets `RepoCollateralSecurityType`, Tag 239.
1875    pub fn set_repo_collateral_security_type(&mut self, v: isize) {
1876        self.message.body.set_field(tag::REPO_COLLATERAL_SECURITY_TYPE, fixer::fix_int::FIXInt::from(v));
1877    }
1878
1879    /// Gets `RepoCollateralSecurityType`, Tag 239.
1880    pub fn get_repo_collateral_security_type(&self) -> Result<isize, MessageRejectErrorEnum> {
1881        let mut fld = field::RepoCollateralSecurityTypeField::new(0);
1882        self.message.body.get_field(tag::REPO_COLLATERAL_SECURITY_TYPE, &mut fld.0)?;
1883        Ok(fld.value())
1884    }
1885
1886
1887    /// Returns true if `RepoCollateralSecurityType` is present, Tag 239.
1888    pub fn has_repo_collateral_security_type(&self) -> bool {
1889        self.message.body.has(tag::REPO_COLLATERAL_SECURITY_TYPE)
1890    }
1891
1892
1893
1894
1895    /// Sets `RepurchaseRate`, Tag 227.
1896    pub fn set_repurchase_rate(&mut self, val: Decimal, scale: i32) {
1897        self.message.body.set_field(tag::REPURCHASE_RATE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1898    }
1899
1900    /// Gets `RepurchaseRate`, Tag 227.
1901    pub fn get_repurchase_rate(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1902        let mut fld = field::RepurchaseRateField::new(Decimal::ZERO, 0);
1903        self.message.body.get_field(tag::REPURCHASE_RATE, &mut fld.0)?;
1904        Ok(fld.value())
1905    }
1906
1907
1908    /// Returns true if `RepurchaseRate` is present, Tag 227.
1909    pub fn has_repurchase_rate(&self) -> bool {
1910        self.message.body.has(tag::REPURCHASE_RATE)
1911    }
1912
1913
1914
1915
1916    /// Sets `RepurchaseTerm`, Tag 226.
1917    pub fn set_repurchase_term(&mut self, v: isize) {
1918        self.message.body.set_field(tag::REPURCHASE_TERM, fixer::fix_int::FIXInt::from(v));
1919    }
1920
1921    /// Gets `RepurchaseTerm`, Tag 226.
1922    pub fn get_repurchase_term(&self) -> Result<isize, MessageRejectErrorEnum> {
1923        let mut fld = field::RepurchaseTermField::new(0);
1924        self.message.body.get_field(tag::REPURCHASE_TERM, &mut fld.0)?;
1925        Ok(fld.value())
1926    }
1927
1928
1929    /// Returns true if `RepurchaseTerm` is present, Tag 226.
1930    pub fn has_repurchase_term(&self) -> bool {
1931        self.message.body.has(tag::REPURCHASE_TERM)
1932    }
1933
1934
1935
1936
1937    /// Sets `RoundingDirection`, Tag 468.
1938    pub fn set_rounding_direction(&mut self, v: String) {
1939        self.message.body.set_field(tag::ROUNDING_DIRECTION, FIXString::from(v));
1940    }
1941
1942    /// Gets `RoundingDirection`, Tag 468.
1943    pub fn get_rounding_direction(&self) -> Result<String, MessageRejectErrorEnum> {
1944        let mut fld = field::RoundingDirectionField::new(String::new());
1945        self.message.body.get_field(tag::ROUNDING_DIRECTION, &mut fld.0)?;
1946        Ok(fld.value().to_string())
1947    }
1948
1949
1950    /// Returns true if `RoundingDirection` is present, Tag 468.
1951    pub fn has_rounding_direction(&self) -> bool {
1952        self.message.body.has(tag::ROUNDING_DIRECTION)
1953    }
1954
1955
1956
1957
1958    /// Sets `RoundingModulus`, Tag 469.
1959    pub fn set_rounding_modulus(&mut self, val: Decimal, scale: i32) {
1960        self.message.body.set_field(tag::ROUNDING_MODULUS, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1961    }
1962
1963    /// Gets `RoundingModulus`, Tag 469.
1964    pub fn get_rounding_modulus(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1965        let mut fld = field::RoundingModulusField::new(Decimal::ZERO, 0);
1966        self.message.body.get_field(tag::ROUNDING_MODULUS, &mut fld.0)?;
1967        Ok(fld.value())
1968    }
1969
1970
1971    /// Returns true if `RoundingModulus` is present, Tag 469.
1972    pub fn has_rounding_modulus(&self) -> bool {
1973        self.message.body.has(tag::ROUNDING_MODULUS)
1974    }
1975
1976
1977
1978
1979    /// Sets `Rule80A`, Tag 47.
1980    pub fn set_rule80_a(&mut self, v: String) {
1981        self.message.body.set_field(tag::RULE80_A, FIXString::from(v));
1982    }
1983
1984    /// Gets `Rule80A`, Tag 47.
1985    pub fn get_rule80_a(&self) -> Result<String, MessageRejectErrorEnum> {
1986        let mut fld = field::Rule80AField::new(String::new());
1987        self.message.body.get_field(tag::RULE80_A, &mut fld.0)?;
1988        Ok(fld.value().to_string())
1989    }
1990
1991
1992    /// Returns true if `Rule80A` is present, Tag 47.
1993    pub fn has_rule80_a(&self) -> bool {
1994        self.message.body.has(tag::RULE80_A)
1995    }
1996
1997
1998
1999
2000    /// Sets `SecondaryClOrdID`, Tag 526.
2001    pub fn set_secondary_cl_ord_id(&mut self, v: String) {
2002        self.message.body.set_field(tag::SECONDARY_CL_ORD_ID, FIXString::from(v));
2003    }
2004
2005    /// Gets `SecondaryClOrdID`, Tag 526.
2006    pub fn get_secondary_cl_ord_id(&self) -> Result<String, MessageRejectErrorEnum> {
2007        let mut fld = field::SecondaryClOrdIDField::new(String::new());
2008        self.message.body.get_field(tag::SECONDARY_CL_ORD_ID, &mut fld.0)?;
2009        Ok(fld.value().to_string())
2010    }
2011
2012
2013    /// Returns true if `SecondaryClOrdID` is present, Tag 526.
2014    pub fn has_secondary_cl_ord_id(&self) -> bool {
2015        self.message.body.has(tag::SECONDARY_CL_ORD_ID)
2016    }
2017
2018
2019
2020
2021    /// Sets `SecurityDesc`, Tag 107.
2022    pub fn set_security_desc(&mut self, v: String) {
2023        self.message.body.set_field(tag::SECURITY_DESC, FIXString::from(v));
2024    }
2025
2026    /// Gets `SecurityDesc`, Tag 107.
2027    pub fn get_security_desc(&self) -> Result<String, MessageRejectErrorEnum> {
2028        let mut fld = field::SecurityDescField::new(String::new());
2029        self.message.body.get_field(tag::SECURITY_DESC, &mut fld.0)?;
2030        Ok(fld.value().to_string())
2031    }
2032
2033
2034    /// Returns true if `SecurityDesc` is present, Tag 107.
2035    pub fn has_security_desc(&self) -> bool {
2036        self.message.body.has(tag::SECURITY_DESC)
2037    }
2038
2039
2040
2041
2042    /// Sets `SecurityExchange`, Tag 207.
2043    pub fn set_security_exchange(&mut self, v: String) {
2044        self.message.body.set_field(tag::SECURITY_EXCHANGE, FIXString::from(v));
2045    }
2046
2047    /// Gets `SecurityExchange`, Tag 207.
2048    pub fn get_security_exchange(&self) -> Result<String, MessageRejectErrorEnum> {
2049        let mut fld = field::SecurityExchangeField::new(String::new());
2050        self.message.body.get_field(tag::SECURITY_EXCHANGE, &mut fld.0)?;
2051        Ok(fld.value().to_string())
2052    }
2053
2054
2055    /// Returns true if `SecurityExchange` is present, Tag 207.
2056    pub fn has_security_exchange(&self) -> bool {
2057        self.message.body.has(tag::SECURITY_EXCHANGE)
2058    }
2059
2060
2061
2062
2063    /// Sets `SecurityID`, Tag 48.
2064    pub fn set_security_id(&mut self, v: String) {
2065        self.message.body.set_field(tag::SECURITY_ID, FIXString::from(v));
2066    }
2067
2068    /// Gets `SecurityID`, Tag 48.
2069    pub fn get_security_id(&self) -> Result<String, MessageRejectErrorEnum> {
2070        let mut fld = field::SecurityIDField::new(String::new());
2071        self.message.body.get_field(tag::SECURITY_ID, &mut fld.0)?;
2072        Ok(fld.value().to_string())
2073    }
2074
2075
2076    /// Returns true if `SecurityID` is present, Tag 48.
2077    pub fn has_security_id(&self) -> bool {
2078        self.message.body.has(tag::SECURITY_ID)
2079    }
2080
2081
2082
2083
2084    /// Sets `SecurityIDSource`, Tag 22.
2085    pub fn set_security_id_source(&mut self, v: String) {
2086        self.message.body.set_field(tag::SECURITY_ID_SOURCE, FIXString::from(v));
2087    }
2088
2089    /// Gets `SecurityIDSource`, Tag 22.
2090    pub fn get_security_id_source(&self) -> Result<String, MessageRejectErrorEnum> {
2091        let mut fld = field::SecurityIDSourceField::new(String::new());
2092        self.message.body.get_field(tag::SECURITY_ID_SOURCE, &mut fld.0)?;
2093        Ok(fld.value().to_string())
2094    }
2095
2096
2097    /// Returns true if `SecurityIDSource` is present, Tag 22.
2098    pub fn has_security_id_source(&self) -> bool {
2099        self.message.body.has(tag::SECURITY_ID_SOURCE)
2100    }
2101
2102
2103
2104
2105    /// Sets `SecurityType`, Tag 167.
2106    pub fn set_security_type(&mut self, v: String) {
2107        self.message.body.set_field(tag::SECURITY_TYPE, FIXString::from(v));
2108    }
2109
2110    /// Gets `SecurityType`, Tag 167.
2111    pub fn get_security_type(&self) -> Result<String, MessageRejectErrorEnum> {
2112        let mut fld = field::SecurityTypeField::new(String::new());
2113        self.message.body.get_field(tag::SECURITY_TYPE, &mut fld.0)?;
2114        Ok(fld.value().to_string())
2115    }
2116
2117
2118    /// Returns true if `SecurityType` is present, Tag 167.
2119    pub fn has_security_type(&self) -> bool {
2120        self.message.body.has(tag::SECURITY_TYPE)
2121    }
2122
2123
2124
2125
2126    /// Sets `SettlCurrency`, Tag 120.
2127    pub fn set_settl_currency(&mut self, v: String) {
2128        self.message.body.set_field(tag::SETTL_CURRENCY, FIXString::from(v));
2129    }
2130
2131    /// Gets `SettlCurrency`, Tag 120.
2132    pub fn get_settl_currency(&self) -> Result<String, MessageRejectErrorEnum> {
2133        let mut fld = field::SettlCurrencyField::new(String::new());
2134        self.message.body.get_field(tag::SETTL_CURRENCY, &mut fld.0)?;
2135        Ok(fld.value().to_string())
2136    }
2137
2138
2139    /// Returns true if `SettlCurrency` is present, Tag 120.
2140    pub fn has_settl_currency(&self) -> bool {
2141        self.message.body.has(tag::SETTL_CURRENCY)
2142    }
2143
2144
2145
2146
2147    /// Sets `SettlmntTyp`, Tag 63.
2148    pub fn set_settlmnt_typ(&mut self, v: String) {
2149        self.message.body.set_field(tag::SETTLMNT_TYP, FIXString::from(v));
2150    }
2151
2152    /// Gets `SettlmntTyp`, Tag 63.
2153    pub fn get_settlmnt_typ(&self) -> Result<String, MessageRejectErrorEnum> {
2154        let mut fld = field::SettlmntTypField::new(String::new());
2155        self.message.body.get_field(tag::SETTLMNT_TYP, &mut fld.0)?;
2156        Ok(fld.value().to_string())
2157    }
2158
2159
2160    /// Returns true if `SettlmntTyp` is present, Tag 63.
2161    pub fn has_settlmnt_typ(&self) -> bool {
2162        self.message.body.has(tag::SETTLMNT_TYP)
2163    }
2164
2165
2166
2167
2168    /// Sets `Side`, Tag 54.
2169    pub fn set_side(&mut self, v: String) {
2170        self.message.body.set_field(tag::SIDE, FIXString::from(v));
2171    }
2172
2173    /// Gets `Side`, Tag 54.
2174    pub fn get_side(&self) -> Result<String, MessageRejectErrorEnum> {
2175        let mut fld = field::SideField::new(String::new());
2176        self.message.body.get_field(tag::SIDE, &mut fld.0)?;
2177        Ok(fld.value().to_string())
2178    }
2179
2180
2181    /// Returns true if `Side` is present, Tag 54.
2182    pub fn has_side(&self) -> bool {
2183        self.message.body.has(tag::SIDE)
2184    }
2185
2186
2187
2188
2189    /// Sets `SolicitedFlag`, Tag 377.
2190    pub fn set_solicited_flag(&mut self, v: bool) {
2191        self.message.body.set_field(tag::SOLICITED_FLAG, fixer::fix_boolean::FIXBoolean::from(v));
2192    }
2193
2194    /// Gets `SolicitedFlag`, Tag 377.
2195    pub fn get_solicited_flag(&self) -> Result<bool, MessageRejectErrorEnum> {
2196        let mut fld = field::SolicitedFlagField::new(false);
2197        self.message.body.get_field(tag::SOLICITED_FLAG, &mut fld.0)?;
2198        Ok(fld.value())
2199    }
2200
2201
2202    /// Returns true if `SolicitedFlag` is present, Tag 377.
2203    pub fn has_solicited_flag(&self) -> bool {
2204        self.message.body.has(tag::SOLICITED_FLAG)
2205    }
2206
2207
2208
2209
2210    /// Sets `Spread`, Tag 218.
2211    pub fn set_spread(&mut self, val: Decimal, scale: i32) {
2212        self.message.body.set_field(tag::SPREAD, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
2213    }
2214
2215    /// Gets `Spread`, Tag 218.
2216    pub fn get_spread(&self) -> Result<Decimal, MessageRejectErrorEnum> {
2217        let mut fld = field::SpreadField::new(Decimal::ZERO, 0);
2218        self.message.body.get_field(tag::SPREAD, &mut fld.0)?;
2219        Ok(fld.value())
2220    }
2221
2222
2223    /// Returns true if `Spread` is present, Tag 218.
2224    pub fn has_spread(&self) -> bool {
2225        self.message.body.has(tag::SPREAD)
2226    }
2227
2228
2229
2230
2231    /// Sets `StateOrProvinceOfIssue`, Tag 471.
2232    pub fn set_state_or_province_of_issue(&mut self, v: String) {
2233        self.message.body.set_field(tag::STATE_OR_PROVINCE_OF_ISSUE, FIXString::from(v));
2234    }
2235
2236    /// Gets `StateOrProvinceOfIssue`, Tag 471.
2237    pub fn get_state_or_province_of_issue(&self) -> Result<String, MessageRejectErrorEnum> {
2238        let mut fld = field::StateOrProvinceOfIssueField::new(String::new());
2239        self.message.body.get_field(tag::STATE_OR_PROVINCE_OF_ISSUE, &mut fld.0)?;
2240        Ok(fld.value().to_string())
2241    }
2242
2243
2244    /// Returns true if `StateOrProvinceOfIssue` is present, Tag 471.
2245    pub fn has_state_or_province_of_issue(&self) -> bool {
2246        self.message.body.has(tag::STATE_OR_PROVINCE_OF_ISSUE)
2247    }
2248
2249
2250
2251
2252    /// Sets `StopPx`, Tag 99.
2253    pub fn set_stop_px(&mut self, val: Decimal, scale: i32) {
2254        self.message.body.set_field(tag::STOP_PX, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
2255    }
2256
2257    /// Gets `StopPx`, Tag 99.
2258    pub fn get_stop_px(&self) -> Result<Decimal, MessageRejectErrorEnum> {
2259        let mut fld = field::StopPxField::new(Decimal::ZERO, 0);
2260        self.message.body.get_field(tag::STOP_PX, &mut fld.0)?;
2261        Ok(fld.value())
2262    }
2263
2264
2265    /// Returns true if `StopPx` is present, Tag 99.
2266    pub fn has_stop_px(&self) -> bool {
2267        self.message.body.has(tag::STOP_PX)
2268    }
2269
2270
2271
2272
2273    /// Sets `StrikePrice`, Tag 202.
2274    pub fn set_strike_price(&mut self, val: Decimal, scale: i32) {
2275        self.message.body.set_field(tag::STRIKE_PRICE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
2276    }
2277
2278    /// Gets `StrikePrice`, Tag 202.
2279    pub fn get_strike_price(&self) -> Result<Decimal, MessageRejectErrorEnum> {
2280        let mut fld = field::StrikePriceField::new(Decimal::ZERO, 0);
2281        self.message.body.get_field(tag::STRIKE_PRICE, &mut fld.0)?;
2282        Ok(fld.value())
2283    }
2284
2285
2286    /// Returns true if `StrikePrice` is present, Tag 202.
2287    pub fn has_strike_price(&self) -> bool {
2288        self.message.body.has(tag::STRIKE_PRICE)
2289    }
2290
2291
2292
2293
2294    /// Sets `Symbol`, Tag 55.
2295    pub fn set_symbol(&mut self, v: String) {
2296        self.message.body.set_field(tag::SYMBOL, FIXString::from(v));
2297    }
2298
2299    /// Gets `Symbol`, Tag 55.
2300    pub fn get_symbol(&self) -> Result<String, MessageRejectErrorEnum> {
2301        let mut fld = field::SymbolField::new(String::new());
2302        self.message.body.get_field(tag::SYMBOL, &mut fld.0)?;
2303        Ok(fld.value().to_string())
2304    }
2305
2306
2307    /// Returns true if `Symbol` is present, Tag 55.
2308    pub fn has_symbol(&self) -> bool {
2309        self.message.body.has(tag::SYMBOL)
2310    }
2311
2312
2313
2314
2315    /// Sets `SymbolSfx`, Tag 65.
2316    pub fn set_symbol_sfx(&mut self, v: String) {
2317        self.message.body.set_field(tag::SYMBOL_SFX, FIXString::from(v));
2318    }
2319
2320    /// Gets `SymbolSfx`, Tag 65.
2321    pub fn get_symbol_sfx(&self) -> Result<String, MessageRejectErrorEnum> {
2322        let mut fld = field::SymbolSfxField::new(String::new());
2323        self.message.body.get_field(tag::SYMBOL_SFX, &mut fld.0)?;
2324        Ok(fld.value().to_string())
2325    }
2326
2327
2328    /// Returns true if `SymbolSfx` is present, Tag 65.
2329    pub fn has_symbol_sfx(&self) -> bool {
2330        self.message.body.has(tag::SYMBOL_SFX)
2331    }
2332
2333
2334
2335
2336    /// Sets `Text`, Tag 58.
2337    pub fn set_text(&mut self, v: String) {
2338        self.message.body.set_field(tag::TEXT, FIXString::from(v));
2339    }
2340
2341    /// Gets `Text`, Tag 58.
2342    pub fn get_text(&self) -> Result<String, MessageRejectErrorEnum> {
2343        let mut fld = field::TextField::new(String::new());
2344        self.message.body.get_field(tag::TEXT, &mut fld.0)?;
2345        Ok(fld.value().to_string())
2346    }
2347
2348
2349    /// Returns true if `Text` is present, Tag 58.
2350    pub fn has_text(&self) -> bool {
2351        self.message.body.has(tag::TEXT)
2352    }
2353
2354
2355
2356
2357    /// Sets `TimeInForce`, Tag 59.
2358    pub fn set_time_in_force(&mut self, v: String) {
2359        self.message.body.set_field(tag::TIME_IN_FORCE, FIXString::from(v));
2360    }
2361
2362    /// Gets `TimeInForce`, Tag 59.
2363    pub fn get_time_in_force(&self) -> Result<String, MessageRejectErrorEnum> {
2364        let mut fld = field::TimeInForceField::new(String::new());
2365        self.message.body.get_field(tag::TIME_IN_FORCE, &mut fld.0)?;
2366        Ok(fld.value().to_string())
2367    }
2368
2369
2370    /// Returns true if `TimeInForce` is present, Tag 59.
2371    pub fn has_time_in_force(&self) -> bool {
2372        self.message.body.has(tag::TIME_IN_FORCE)
2373    }
2374
2375
2376
2377
2378    /// Sets `TradeOriginationDate`, Tag 229.
2379    pub fn set_trade_origination_date(&mut self, v: String) {
2380        self.message.body.set_field(tag::TRADE_ORIGINATION_DATE, FIXString::from(v));
2381    }
2382
2383    /// Gets `TradeOriginationDate`, Tag 229.
2384    pub fn get_trade_origination_date(&self) -> Result<String, MessageRejectErrorEnum> {
2385        let mut fld = field::TradeOriginationDateField::new(String::new());
2386        self.message.body.get_field(tag::TRADE_ORIGINATION_DATE, &mut fld.0)?;
2387        Ok(fld.value().to_string())
2388    }
2389
2390
2391    /// Returns true if `TradeOriginationDate` is present, Tag 229.
2392    pub fn has_trade_origination_date(&self) -> bool {
2393        self.message.body.has(tag::TRADE_ORIGINATION_DATE)
2394    }
2395
2396
2397
2398
2399    /// Sets `TransactTime`, Tag 60.
2400    pub fn set_transact_time(&mut self, v: Timestamp) {
2401        self.message.body.set_field(tag::TRANSACT_TIME, fixer::fix_utc_timestamp::FIXUTCTimestamp {
2402            time: v,
2403            precision: fixer::fix_utc_timestamp::TimestampPrecision::Millis,
2404        });
2405    }
2406
2407    /// Gets `TransactTime`, Tag 60.
2408    pub fn get_transact_time(&self) -> Result<Timestamp, MessageRejectErrorEnum> {
2409        let mut fld = field::TransactTimeField::new(Timestamp::UNIX_EPOCH);
2410        self.message.body.get_field(tag::TRANSACT_TIME, &mut fld.0)?;
2411        Ok(fld.value())
2412    }
2413
2414
2415    /// Returns true if `TransactTime` is present, Tag 60.
2416    pub fn has_transact_time(&self) -> bool {
2417        self.message.body.has(tag::TRANSACT_TIME)
2418    }
2419
2420
2421
2422
2423    /// Sets `Yield`, Tag 236.
2424    pub fn set_yield(&mut self, val: Decimal, scale: i32) {
2425        self.message.body.set_field(tag::YIELD, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
2426    }
2427
2428    /// Gets `Yield`, Tag 236.
2429    pub fn get_yield(&self) -> Result<Decimal, MessageRejectErrorEnum> {
2430        let mut fld = field::YieldField::new(Decimal::ZERO, 0);
2431        self.message.body.get_field(tag::YIELD, &mut fld.0)?;
2432        Ok(fld.value())
2433    }
2434
2435
2436    /// Returns true if `Yield` is present, Tag 236.
2437    pub fn has_yield(&self) -> bool {
2438        self.message.body.has(tag::YIELD)
2439    }
2440
2441
2442
2443
2444    /// Sets `YieldType`, Tag 235.
2445    pub fn set_yield_type(&mut self, v: String) {
2446        self.message.body.set_field(tag::YIELD_TYPE, FIXString::from(v));
2447    }
2448
2449    /// Gets `YieldType`, Tag 235.
2450    pub fn get_yield_type(&self) -> Result<String, MessageRejectErrorEnum> {
2451        let mut fld = field::YieldTypeField::new(String::new());
2452        self.message.body.get_field(tag::YIELD_TYPE, &mut fld.0)?;
2453        Ok(fld.value().to_string())
2454    }
2455
2456
2457    /// Returns true if `YieldType` is present, Tag 235.
2458    pub fn has_yield_type(&self) -> bool {
2459        self.message.body.has(tag::YIELD_TYPE)
2460    }
2461
2462
2463}
2464
2465/// `RouteOut` is the callback type for routing `OrderCancelReplaceRequest` messages.
2466pub type RouteOut = fn(msg: OrderCancelReplaceRequest, session_id: SessionID) -> Result<(), MessageRejectErrorEnum>;
2467
2468/// Route type returned by the `route` function.
2469pub type Route = (&'static str, &'static str, Box<dyn Fn(&Message, SessionID) -> Result<(), MessageRejectErrorEnum> + Send>);
2470
2471/// Returns the begin string, message type, and route function for `OrderCancelReplaceRequest`.
2472pub fn route(router: RouteOut) -> Route {
2473    let r = move |msg: &Message, session_id: SessionID| -> Result<(), MessageRejectErrorEnum> {
2474        router(OrderCancelReplaceRequest::from_message(msg.clone()), session_id)
2475    };
2476    ("FIX.4.3", "G", Box::new(r))
2477}