fixer_fix/fix50/
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 `fix50` `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, 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::SIDE, side.0);
36
37        msg.body.set_field(tag::TRANSACT_TIME, transact_time.0);
38
39        msg.body.set_field(tag::ORD_TYPE, ord_type.0);
40
41        Self { message: msg }
42    }
43
44    /// Creates a `OrderCancelReplaceRequest` from an existing `Message`.
45    pub fn from_message(msg: Message) -> Self {
46        Self { message: msg }
47    }
48
49    /// Returns the underlying `Message`.
50    pub fn to_message(self) -> Message {
51        self.message
52    }
53
54
55
56
57    /// Sets `Account`, Tag 1.
58    pub fn set_account(&mut self, v: String) {
59        self.message.body.set_field(tag::ACCOUNT, FIXString::from(v));
60    }
61
62    /// Gets `Account`, Tag 1.
63    pub fn get_account(&self) -> Result<String, MessageRejectErrorEnum> {
64        let mut fld = field::AccountField::new(String::new());
65        self.message.body.get_field(tag::ACCOUNT, &mut fld.0)?;
66        Ok(fld.value().to_string())
67    }
68
69
70    /// Returns true if `Account` is present, Tag 1.
71    pub fn has_account(&self) -> bool {
72        self.message.body.has(tag::ACCOUNT)
73    }
74
75
76
77
78    /// Sets `AccountType`, Tag 581.
79    pub fn set_account_type(&mut self, v: isize) {
80        self.message.body.set_field(tag::ACCOUNT_TYPE, fixer::fix_int::FIXInt::from(v));
81    }
82
83    /// Gets `AccountType`, Tag 581.
84    pub fn get_account_type(&self) -> Result<isize, MessageRejectErrorEnum> {
85        let mut fld = field::AccountTypeField::new(0);
86        self.message.body.get_field(tag::ACCOUNT_TYPE, &mut fld.0)?;
87        Ok(fld.value())
88    }
89
90
91    /// Returns true if `AccountType` is present, Tag 581.
92    pub fn has_account_type(&self) -> bool {
93        self.message.body.has(tag::ACCOUNT_TYPE)
94    }
95
96
97
98
99    /// Sets `AcctIDSource`, Tag 660.
100    pub fn set_acct_id_source(&mut self, v: isize) {
101        self.message.body.set_field(tag::ACCT_ID_SOURCE, fixer::fix_int::FIXInt::from(v));
102    }
103
104    /// Gets `AcctIDSource`, Tag 660.
105    pub fn get_acct_id_source(&self) -> Result<isize, MessageRejectErrorEnum> {
106        let mut fld = field::AcctIDSourceField::new(0);
107        self.message.body.get_field(tag::ACCT_ID_SOURCE, &mut fld.0)?;
108        Ok(fld.value())
109    }
110
111
112    /// Returns true if `AcctIDSource` is present, Tag 660.
113    pub fn has_acct_id_source(&self) -> bool {
114        self.message.body.has(tag::ACCT_ID_SOURCE)
115    }
116
117
118
119
120    /// Sets `AgreementCurrency`, Tag 918.
121    pub fn set_agreement_currency(&mut self, v: String) {
122        self.message.body.set_field(tag::AGREEMENT_CURRENCY, FIXString::from(v));
123    }
124
125    /// Gets `AgreementCurrency`, Tag 918.
126    pub fn get_agreement_currency(&self) -> Result<String, MessageRejectErrorEnum> {
127        let mut fld = field::AgreementCurrencyField::new(String::new());
128        self.message.body.get_field(tag::AGREEMENT_CURRENCY, &mut fld.0)?;
129        Ok(fld.value().to_string())
130    }
131
132
133    /// Returns true if `AgreementCurrency` is present, Tag 918.
134    pub fn has_agreement_currency(&self) -> bool {
135        self.message.body.has(tag::AGREEMENT_CURRENCY)
136    }
137
138
139
140
141    /// Sets `AgreementDate`, Tag 915.
142    pub fn set_agreement_date(&mut self, v: String) {
143        self.message.body.set_field(tag::AGREEMENT_DATE, FIXString::from(v));
144    }
145
146    /// Gets `AgreementDate`, Tag 915.
147    pub fn get_agreement_date(&self) -> Result<String, MessageRejectErrorEnum> {
148        let mut fld = field::AgreementDateField::new(String::new());
149        self.message.body.get_field(tag::AGREEMENT_DATE, &mut fld.0)?;
150        Ok(fld.value().to_string())
151    }
152
153
154    /// Returns true if `AgreementDate` is present, Tag 915.
155    pub fn has_agreement_date(&self) -> bool {
156        self.message.body.has(tag::AGREEMENT_DATE)
157    }
158
159
160
161
162    /// Sets `AgreementDesc`, Tag 913.
163    pub fn set_agreement_desc(&mut self, v: String) {
164        self.message.body.set_field(tag::AGREEMENT_DESC, FIXString::from(v));
165    }
166
167    /// Gets `AgreementDesc`, Tag 913.
168    pub fn get_agreement_desc(&self) -> Result<String, MessageRejectErrorEnum> {
169        let mut fld = field::AgreementDescField::new(String::new());
170        self.message.body.get_field(tag::AGREEMENT_DESC, &mut fld.0)?;
171        Ok(fld.value().to_string())
172    }
173
174
175    /// Returns true if `AgreementDesc` is present, Tag 913.
176    pub fn has_agreement_desc(&self) -> bool {
177        self.message.body.has(tag::AGREEMENT_DESC)
178    }
179
180
181
182
183    /// Sets `AgreementID`, Tag 914.
184    pub fn set_agreement_id(&mut self, v: String) {
185        self.message.body.set_field(tag::AGREEMENT_ID, FIXString::from(v));
186    }
187
188    /// Gets `AgreementID`, Tag 914.
189    pub fn get_agreement_id(&self) -> Result<String, MessageRejectErrorEnum> {
190        let mut fld = field::AgreementIDField::new(String::new());
191        self.message.body.get_field(tag::AGREEMENT_ID, &mut fld.0)?;
192        Ok(fld.value().to_string())
193    }
194
195
196    /// Returns true if `AgreementID` is present, Tag 914.
197    pub fn has_agreement_id(&self) -> bool {
198        self.message.body.has(tag::AGREEMENT_ID)
199    }
200
201
202
203
204    /// Sets `AllocID`, Tag 70.
205    pub fn set_alloc_id(&mut self, v: String) {
206        self.message.body.set_field(tag::ALLOC_ID, FIXString::from(v));
207    }
208
209    /// Gets `AllocID`, Tag 70.
210    pub fn get_alloc_id(&self) -> Result<String, MessageRejectErrorEnum> {
211        let mut fld = field::AllocIDField::new(String::new());
212        self.message.body.get_field(tag::ALLOC_ID, &mut fld.0)?;
213        Ok(fld.value().to_string())
214    }
215
216
217    /// Returns true if `AllocID` is present, Tag 70.
218    pub fn has_alloc_id(&self) -> bool {
219        self.message.body.has(tag::ALLOC_ID)
220    }
221
222
223
224
225    /// Sets `BenchmarkCurveCurrency`, Tag 220.
226    pub fn set_benchmark_curve_currency(&mut self, v: String) {
227        self.message.body.set_field(tag::BENCHMARK_CURVE_CURRENCY, FIXString::from(v));
228    }
229
230    /// Gets `BenchmarkCurveCurrency`, Tag 220.
231    pub fn get_benchmark_curve_currency(&self) -> Result<String, MessageRejectErrorEnum> {
232        let mut fld = field::BenchmarkCurveCurrencyField::new(String::new());
233        self.message.body.get_field(tag::BENCHMARK_CURVE_CURRENCY, &mut fld.0)?;
234        Ok(fld.value().to_string())
235    }
236
237
238    /// Returns true if `BenchmarkCurveCurrency` is present, Tag 220.
239    pub fn has_benchmark_curve_currency(&self) -> bool {
240        self.message.body.has(tag::BENCHMARK_CURVE_CURRENCY)
241    }
242
243
244
245
246    /// Sets `BenchmarkCurveName`, Tag 221.
247    pub fn set_benchmark_curve_name(&mut self, v: String) {
248        self.message.body.set_field(tag::BENCHMARK_CURVE_NAME, FIXString::from(v));
249    }
250
251    /// Gets `BenchmarkCurveName`, Tag 221.
252    pub fn get_benchmark_curve_name(&self) -> Result<String, MessageRejectErrorEnum> {
253        let mut fld = field::BenchmarkCurveNameField::new(String::new());
254        self.message.body.get_field(tag::BENCHMARK_CURVE_NAME, &mut fld.0)?;
255        Ok(fld.value().to_string())
256    }
257
258
259    /// Returns true if `BenchmarkCurveName` is present, Tag 221.
260    pub fn has_benchmark_curve_name(&self) -> bool {
261        self.message.body.has(tag::BENCHMARK_CURVE_NAME)
262    }
263
264
265
266
267    /// Sets `BenchmarkCurvePoint`, Tag 222.
268    pub fn set_benchmark_curve_point(&mut self, v: String) {
269        self.message.body.set_field(tag::BENCHMARK_CURVE_POINT, FIXString::from(v));
270    }
271
272    /// Gets `BenchmarkCurvePoint`, Tag 222.
273    pub fn get_benchmark_curve_point(&self) -> Result<String, MessageRejectErrorEnum> {
274        let mut fld = field::BenchmarkCurvePointField::new(String::new());
275        self.message.body.get_field(tag::BENCHMARK_CURVE_POINT, &mut fld.0)?;
276        Ok(fld.value().to_string())
277    }
278
279
280    /// Returns true if `BenchmarkCurvePoint` is present, Tag 222.
281    pub fn has_benchmark_curve_point(&self) -> bool {
282        self.message.body.has(tag::BENCHMARK_CURVE_POINT)
283    }
284
285
286
287
288    /// Sets `BenchmarkPrice`, Tag 662.
289    pub fn set_benchmark_price(&mut self, val: Decimal, scale: i32) {
290        self.message.body.set_field(tag::BENCHMARK_PRICE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
291    }
292
293    /// Gets `BenchmarkPrice`, Tag 662.
294    pub fn get_benchmark_price(&self) -> Result<Decimal, MessageRejectErrorEnum> {
295        let mut fld = field::BenchmarkPriceField::new(Decimal::ZERO, 0);
296        self.message.body.get_field(tag::BENCHMARK_PRICE, &mut fld.0)?;
297        Ok(fld.value())
298    }
299
300
301    /// Returns true if `BenchmarkPrice` is present, Tag 662.
302    pub fn has_benchmark_price(&self) -> bool {
303        self.message.body.has(tag::BENCHMARK_PRICE)
304    }
305
306
307
308
309    /// Sets `BenchmarkPriceType`, Tag 663.
310    pub fn set_benchmark_price_type(&mut self, v: isize) {
311        self.message.body.set_field(tag::BENCHMARK_PRICE_TYPE, fixer::fix_int::FIXInt::from(v));
312    }
313
314    /// Gets `BenchmarkPriceType`, Tag 663.
315    pub fn get_benchmark_price_type(&self) -> Result<isize, MessageRejectErrorEnum> {
316        let mut fld = field::BenchmarkPriceTypeField::new(0);
317        self.message.body.get_field(tag::BENCHMARK_PRICE_TYPE, &mut fld.0)?;
318        Ok(fld.value())
319    }
320
321
322    /// Returns true if `BenchmarkPriceType` is present, Tag 663.
323    pub fn has_benchmark_price_type(&self) -> bool {
324        self.message.body.has(tag::BENCHMARK_PRICE_TYPE)
325    }
326
327
328
329
330    /// Sets `BenchmarkSecurityID`, Tag 699.
331    pub fn set_benchmark_security_id(&mut self, v: String) {
332        self.message.body.set_field(tag::BENCHMARK_SECURITY_ID, FIXString::from(v));
333    }
334
335    /// Gets `BenchmarkSecurityID`, Tag 699.
336    pub fn get_benchmark_security_id(&self) -> Result<String, MessageRejectErrorEnum> {
337        let mut fld = field::BenchmarkSecurityIDField::new(String::new());
338        self.message.body.get_field(tag::BENCHMARK_SECURITY_ID, &mut fld.0)?;
339        Ok(fld.value().to_string())
340    }
341
342
343    /// Returns true if `BenchmarkSecurityID` is present, Tag 699.
344    pub fn has_benchmark_security_id(&self) -> bool {
345        self.message.body.has(tag::BENCHMARK_SECURITY_ID)
346    }
347
348
349
350
351    /// Sets `BenchmarkSecurityIDSource`, Tag 761.
352    pub fn set_benchmark_security_id_source(&mut self, v: String) {
353        self.message.body.set_field(tag::BENCHMARK_SECURITY_ID_SOURCE, FIXString::from(v));
354    }
355
356    /// Gets `BenchmarkSecurityIDSource`, Tag 761.
357    pub fn get_benchmark_security_id_source(&self) -> Result<String, MessageRejectErrorEnum> {
358        let mut fld = field::BenchmarkSecurityIDSourceField::new(String::new());
359        self.message.body.get_field(tag::BENCHMARK_SECURITY_ID_SOURCE, &mut fld.0)?;
360        Ok(fld.value().to_string())
361    }
362
363
364    /// Returns true if `BenchmarkSecurityIDSource` is present, Tag 761.
365    pub fn has_benchmark_security_id_source(&self) -> bool {
366        self.message.body.has(tag::BENCHMARK_SECURITY_ID_SOURCE)
367    }
368
369
370
371
372    /// Sets `BookingType`, Tag 775.
373    pub fn set_booking_type(&mut self, v: isize) {
374        self.message.body.set_field(tag::BOOKING_TYPE, fixer::fix_int::FIXInt::from(v));
375    }
376
377    /// Gets `BookingType`, Tag 775.
378    pub fn get_booking_type(&self) -> Result<isize, MessageRejectErrorEnum> {
379        let mut fld = field::BookingTypeField::new(0);
380        self.message.body.get_field(tag::BOOKING_TYPE, &mut fld.0)?;
381        Ok(fld.value())
382    }
383
384
385    /// Returns true if `BookingType` is present, Tag 775.
386    pub fn has_booking_type(&self) -> bool {
387        self.message.body.has(tag::BOOKING_TYPE)
388    }
389
390
391
392
393    /// Sets `BookingUnit`, Tag 590.
394    pub fn set_booking_unit(&mut self, v: String) {
395        self.message.body.set_field(tag::BOOKING_UNIT, FIXString::from(v));
396    }
397
398    /// Gets `BookingUnit`, Tag 590.
399    pub fn get_booking_unit(&self) -> Result<String, MessageRejectErrorEnum> {
400        let mut fld = field::BookingUnitField::new(String::new());
401        self.message.body.get_field(tag::BOOKING_UNIT, &mut fld.0)?;
402        Ok(fld.value().to_string())
403    }
404
405
406    /// Returns true if `BookingUnit` is present, Tag 590.
407    pub fn has_booking_unit(&self) -> bool {
408        self.message.body.has(tag::BOOKING_UNIT)
409    }
410
411
412
413
414    /// Sets `CFICode`, Tag 461.
415    pub fn set_cfi_code(&mut self, v: String) {
416        self.message.body.set_field(tag::CFI_CODE, FIXString::from(v));
417    }
418
419    /// Gets `CFICode`, Tag 461.
420    pub fn get_cfi_code(&self) -> Result<String, MessageRejectErrorEnum> {
421        let mut fld = field::CFICodeField::new(String::new());
422        self.message.body.get_field(tag::CFI_CODE, &mut fld.0)?;
423        Ok(fld.value().to_string())
424    }
425
426
427    /// Returns true if `CFICode` is present, Tag 461.
428    pub fn has_cfi_code(&self) -> bool {
429        self.message.body.has(tag::CFI_CODE)
430    }
431
432
433
434
435    /// Sets `CPProgram`, Tag 875.
436    pub fn set_cp_program(&mut self, v: isize) {
437        self.message.body.set_field(tag::CP_PROGRAM, fixer::fix_int::FIXInt::from(v));
438    }
439
440    /// Gets `CPProgram`, Tag 875.
441    pub fn get_cp_program(&self) -> Result<isize, MessageRejectErrorEnum> {
442        let mut fld = field::CPProgramField::new(0);
443        self.message.body.get_field(tag::CP_PROGRAM, &mut fld.0)?;
444        Ok(fld.value())
445    }
446
447
448    /// Returns true if `CPProgram` is present, Tag 875.
449    pub fn has_cp_program(&self) -> bool {
450        self.message.body.has(tag::CP_PROGRAM)
451    }
452
453
454
455
456    /// Sets `CPRegType`, Tag 876.
457    pub fn set_cp_reg_type(&mut self, v: String) {
458        self.message.body.set_field(tag::CP_REG_TYPE, FIXString::from(v));
459    }
460
461    /// Gets `CPRegType`, Tag 876.
462    pub fn get_cp_reg_type(&self) -> Result<String, MessageRejectErrorEnum> {
463        let mut fld = field::CPRegTypeField::new(String::new());
464        self.message.body.get_field(tag::CP_REG_TYPE, &mut fld.0)?;
465        Ok(fld.value().to_string())
466    }
467
468
469    /// Returns true if `CPRegType` is present, Tag 876.
470    pub fn has_cp_reg_type(&self) -> bool {
471        self.message.body.has(tag::CP_REG_TYPE)
472    }
473
474
475
476
477    /// Sets `CancellationRights`, Tag 480.
478    pub fn set_cancellation_rights(&mut self, v: String) {
479        self.message.body.set_field(tag::CANCELLATION_RIGHTS, FIXString::from(v));
480    }
481
482    /// Gets `CancellationRights`, Tag 480.
483    pub fn get_cancellation_rights(&self) -> Result<String, MessageRejectErrorEnum> {
484        let mut fld = field::CancellationRightsField::new(String::new());
485        self.message.body.get_field(tag::CANCELLATION_RIGHTS, &mut fld.0)?;
486        Ok(fld.value().to_string())
487    }
488
489
490    /// Returns true if `CancellationRights` is present, Tag 480.
491    pub fn has_cancellation_rights(&self) -> bool {
492        self.message.body.has(tag::CANCELLATION_RIGHTS)
493    }
494
495
496
497
498    /// Sets `CashMargin`, Tag 544.
499    pub fn set_cash_margin(&mut self, v: String) {
500        self.message.body.set_field(tag::CASH_MARGIN, FIXString::from(v));
501    }
502
503    /// Gets `CashMargin`, Tag 544.
504    pub fn get_cash_margin(&self) -> Result<String, MessageRejectErrorEnum> {
505        let mut fld = field::CashMarginField::new(String::new());
506        self.message.body.get_field(tag::CASH_MARGIN, &mut fld.0)?;
507        Ok(fld.value().to_string())
508    }
509
510
511    /// Returns true if `CashMargin` is present, Tag 544.
512    pub fn has_cash_margin(&self) -> bool {
513        self.message.body.has(tag::CASH_MARGIN)
514    }
515
516
517
518
519    /// Sets `CashOrderQty`, Tag 152.
520    pub fn set_cash_order_qty(&mut self, val: Decimal, scale: i32) {
521        self.message.body.set_field(tag::CASH_ORDER_QTY, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
522    }
523
524    /// Gets `CashOrderQty`, Tag 152.
525    pub fn get_cash_order_qty(&self) -> Result<Decimal, MessageRejectErrorEnum> {
526        let mut fld = field::CashOrderQtyField::new(Decimal::ZERO, 0);
527        self.message.body.get_field(tag::CASH_ORDER_QTY, &mut fld.0)?;
528        Ok(fld.value())
529    }
530
531
532    /// Returns true if `CashOrderQty` is present, Tag 152.
533    pub fn has_cash_order_qty(&self) -> bool {
534        self.message.body.has(tag::CASH_ORDER_QTY)
535    }
536
537
538
539
540    /// Sets `ClOrdID`, Tag 11.
541    pub fn set_cl_ord_id(&mut self, v: String) {
542        self.message.body.set_field(tag::CL_ORD_ID, FIXString::from(v));
543    }
544
545    /// Gets `ClOrdID`, Tag 11.
546    pub fn get_cl_ord_id(&self) -> Result<String, MessageRejectErrorEnum> {
547        let mut fld = field::ClOrdIDField::new(String::new());
548        self.message.body.get_field(tag::CL_ORD_ID, &mut fld.0)?;
549        Ok(fld.value().to_string())
550    }
551
552
553    /// Returns true if `ClOrdID` is present, Tag 11.
554    pub fn has_cl_ord_id(&self) -> bool {
555        self.message.body.has(tag::CL_ORD_ID)
556    }
557
558
559
560
561    /// Sets `ClOrdLinkID`, Tag 583.
562    pub fn set_cl_ord_link_id(&mut self, v: String) {
563        self.message.body.set_field(tag::CL_ORD_LINK_ID, FIXString::from(v));
564    }
565
566    /// Gets `ClOrdLinkID`, Tag 583.
567    pub fn get_cl_ord_link_id(&self) -> Result<String, MessageRejectErrorEnum> {
568        let mut fld = field::ClOrdLinkIDField::new(String::new());
569        self.message.body.get_field(tag::CL_ORD_LINK_ID, &mut fld.0)?;
570        Ok(fld.value().to_string())
571    }
572
573
574    /// Returns true if `ClOrdLinkID` is present, Tag 583.
575    pub fn has_cl_ord_link_id(&self) -> bool {
576        self.message.body.has(tag::CL_ORD_LINK_ID)
577    }
578
579
580
581
582    /// Sets `ClearingFeeIndicator`, Tag 635.
583    pub fn set_clearing_fee_indicator(&mut self, v: String) {
584        self.message.body.set_field(tag::CLEARING_FEE_INDICATOR, FIXString::from(v));
585    }
586
587    /// Gets `ClearingFeeIndicator`, Tag 635.
588    pub fn get_clearing_fee_indicator(&self) -> Result<String, MessageRejectErrorEnum> {
589        let mut fld = field::ClearingFeeIndicatorField::new(String::new());
590        self.message.body.get_field(tag::CLEARING_FEE_INDICATOR, &mut fld.0)?;
591        Ok(fld.value().to_string())
592    }
593
594
595    /// Returns true if `ClearingFeeIndicator` is present, Tag 635.
596    pub fn has_clearing_fee_indicator(&self) -> bool {
597        self.message.body.has(tag::CLEARING_FEE_INDICATOR)
598    }
599
600
601
602
603    /// Sets `CommCurrency`, Tag 479.
604    pub fn set_comm_currency(&mut self, v: String) {
605        self.message.body.set_field(tag::COMM_CURRENCY, FIXString::from(v));
606    }
607
608    /// Gets `CommCurrency`, Tag 479.
609    pub fn get_comm_currency(&self) -> Result<String, MessageRejectErrorEnum> {
610        let mut fld = field::CommCurrencyField::new(String::new());
611        self.message.body.get_field(tag::COMM_CURRENCY, &mut fld.0)?;
612        Ok(fld.value().to_string())
613    }
614
615
616    /// Returns true if `CommCurrency` is present, Tag 479.
617    pub fn has_comm_currency(&self) -> bool {
618        self.message.body.has(tag::COMM_CURRENCY)
619    }
620
621
622
623
624    /// Sets `CommType`, Tag 13.
625    pub fn set_comm_type(&mut self, v: String) {
626        self.message.body.set_field(tag::COMM_TYPE, FIXString::from(v));
627    }
628
629    /// Gets `CommType`, Tag 13.
630    pub fn get_comm_type(&self) -> Result<String, MessageRejectErrorEnum> {
631        let mut fld = field::CommTypeField::new(String::new());
632        self.message.body.get_field(tag::COMM_TYPE, &mut fld.0)?;
633        Ok(fld.value().to_string())
634    }
635
636
637    /// Returns true if `CommType` is present, Tag 13.
638    pub fn has_comm_type(&self) -> bool {
639        self.message.body.has(tag::COMM_TYPE)
640    }
641
642
643
644
645    /// Sets `Commission`, Tag 12.
646    pub fn set_commission(&mut self, val: Decimal, scale: i32) {
647        self.message.body.set_field(tag::COMMISSION, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
648    }
649
650    /// Gets `Commission`, Tag 12.
651    pub fn get_commission(&self) -> Result<Decimal, MessageRejectErrorEnum> {
652        let mut fld = field::CommissionField::new(Decimal::ZERO, 0);
653        self.message.body.get_field(tag::COMMISSION, &mut fld.0)?;
654        Ok(fld.value())
655    }
656
657
658    /// Returns true if `Commission` is present, Tag 12.
659    pub fn has_commission(&self) -> bool {
660        self.message.body.has(tag::COMMISSION)
661    }
662
663
664
665
666    /// Sets `ComplianceID`, Tag 376.
667    pub fn set_compliance_id(&mut self, v: String) {
668        self.message.body.set_field(tag::COMPLIANCE_ID, FIXString::from(v));
669    }
670
671    /// Gets `ComplianceID`, Tag 376.
672    pub fn get_compliance_id(&self) -> Result<String, MessageRejectErrorEnum> {
673        let mut fld = field::ComplianceIDField::new(String::new());
674        self.message.body.get_field(tag::COMPLIANCE_ID, &mut fld.0)?;
675        Ok(fld.value().to_string())
676    }
677
678
679    /// Returns true if `ComplianceID` is present, Tag 376.
680    pub fn has_compliance_id(&self) -> bool {
681        self.message.body.has(tag::COMPLIANCE_ID)
682    }
683
684
685
686
687    /// Sets `ContractMultiplier`, Tag 231.
688    pub fn set_contract_multiplier(&mut self, val: Decimal, scale: i32) {
689        self.message.body.set_field(tag::CONTRACT_MULTIPLIER, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
690    }
691
692    /// Gets `ContractMultiplier`, Tag 231.
693    pub fn get_contract_multiplier(&self) -> Result<Decimal, MessageRejectErrorEnum> {
694        let mut fld = field::ContractMultiplierField::new(Decimal::ZERO, 0);
695        self.message.body.get_field(tag::CONTRACT_MULTIPLIER, &mut fld.0)?;
696        Ok(fld.value())
697    }
698
699
700    /// Returns true if `ContractMultiplier` is present, Tag 231.
701    pub fn has_contract_multiplier(&self) -> bool {
702        self.message.body.has(tag::CONTRACT_MULTIPLIER)
703    }
704
705
706
707
708    /// Sets `ContractSettlMonth`, Tag 667.
709    pub fn set_contract_settl_month(&mut self, v: String) {
710        self.message.body.set_field(tag::CONTRACT_SETTL_MONTH, FIXString::from(v));
711    }
712
713    /// Gets `ContractSettlMonth`, Tag 667.
714    pub fn get_contract_settl_month(&self) -> Result<String, MessageRejectErrorEnum> {
715        let mut fld = field::ContractSettlMonthField::new(String::new());
716        self.message.body.get_field(tag::CONTRACT_SETTL_MONTH, &mut fld.0)?;
717        Ok(fld.value().to_string())
718    }
719
720
721    /// Returns true if `ContractSettlMonth` is present, Tag 667.
722    pub fn has_contract_settl_month(&self) -> bool {
723        self.message.body.has(tag::CONTRACT_SETTL_MONTH)
724    }
725
726
727
728
729    /// Sets `CountryOfIssue`, Tag 470.
730    pub fn set_country_of_issue(&mut self, v: String) {
731        self.message.body.set_field(tag::COUNTRY_OF_ISSUE, FIXString::from(v));
732    }
733
734    /// Gets `CountryOfIssue`, Tag 470.
735    pub fn get_country_of_issue(&self) -> Result<String, MessageRejectErrorEnum> {
736        let mut fld = field::CountryOfIssueField::new(String::new());
737        self.message.body.get_field(tag::COUNTRY_OF_ISSUE, &mut fld.0)?;
738        Ok(fld.value().to_string())
739    }
740
741
742    /// Returns true if `CountryOfIssue` is present, Tag 470.
743    pub fn has_country_of_issue(&self) -> bool {
744        self.message.body.has(tag::COUNTRY_OF_ISSUE)
745    }
746
747
748
749
750    /// Sets `CouponPaymentDate`, Tag 224.
751    pub fn set_coupon_payment_date(&mut self, v: String) {
752        self.message.body.set_field(tag::COUPON_PAYMENT_DATE, FIXString::from(v));
753    }
754
755    /// Gets `CouponPaymentDate`, Tag 224.
756    pub fn get_coupon_payment_date(&self) -> Result<String, MessageRejectErrorEnum> {
757        let mut fld = field::CouponPaymentDateField::new(String::new());
758        self.message.body.get_field(tag::COUPON_PAYMENT_DATE, &mut fld.0)?;
759        Ok(fld.value().to_string())
760    }
761
762
763    /// Returns true if `CouponPaymentDate` is present, Tag 224.
764    pub fn has_coupon_payment_date(&self) -> bool {
765        self.message.body.has(tag::COUPON_PAYMENT_DATE)
766    }
767
768
769
770
771    /// Sets `CouponRate`, Tag 223.
772    pub fn set_coupon_rate(&mut self, val: Decimal, scale: i32) {
773        self.message.body.set_field(tag::COUPON_RATE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
774    }
775
776    /// Gets `CouponRate`, Tag 223.
777    pub fn get_coupon_rate(&self) -> Result<Decimal, MessageRejectErrorEnum> {
778        let mut fld = field::CouponRateField::new(Decimal::ZERO, 0);
779        self.message.body.get_field(tag::COUPON_RATE, &mut fld.0)?;
780        Ok(fld.value())
781    }
782
783
784    /// Returns true if `CouponRate` is present, Tag 223.
785    pub fn has_coupon_rate(&self) -> bool {
786        self.message.body.has(tag::COUPON_RATE)
787    }
788
789
790
791
792    /// Sets `CoveredOrUncovered`, Tag 203.
793    pub fn set_covered_or_uncovered(&mut self, v: isize) {
794        self.message.body.set_field(tag::COVERED_OR_UNCOVERED, fixer::fix_int::FIXInt::from(v));
795    }
796
797    /// Gets `CoveredOrUncovered`, Tag 203.
798    pub fn get_covered_or_uncovered(&self) -> Result<isize, MessageRejectErrorEnum> {
799        let mut fld = field::CoveredOrUncoveredField::new(0);
800        self.message.body.get_field(tag::COVERED_OR_UNCOVERED, &mut fld.0)?;
801        Ok(fld.value())
802    }
803
804
805    /// Returns true if `CoveredOrUncovered` is present, Tag 203.
806    pub fn has_covered_or_uncovered(&self) -> bool {
807        self.message.body.has(tag::COVERED_OR_UNCOVERED)
808    }
809
810
811
812
813    /// Sets `CreditRating`, Tag 255.
814    pub fn set_credit_rating(&mut self, v: String) {
815        self.message.body.set_field(tag::CREDIT_RATING, FIXString::from(v));
816    }
817
818    /// Gets `CreditRating`, Tag 255.
819    pub fn get_credit_rating(&self) -> Result<String, MessageRejectErrorEnum> {
820        let mut fld = field::CreditRatingField::new(String::new());
821        self.message.body.get_field(tag::CREDIT_RATING, &mut fld.0)?;
822        Ok(fld.value().to_string())
823    }
824
825
826    /// Returns true if `CreditRating` is present, Tag 255.
827    pub fn has_credit_rating(&self) -> bool {
828        self.message.body.has(tag::CREDIT_RATING)
829    }
830
831
832
833
834    /// Sets `Currency`, Tag 15.
835    pub fn set_currency(&mut self, v: String) {
836        self.message.body.set_field(tag::CURRENCY, FIXString::from(v));
837    }
838
839    /// Gets `Currency`, Tag 15.
840    pub fn get_currency(&self) -> Result<String, MessageRejectErrorEnum> {
841        let mut fld = field::CurrencyField::new(String::new());
842        self.message.body.get_field(tag::CURRENCY, &mut fld.0)?;
843        Ok(fld.value().to_string())
844    }
845
846
847    /// Returns true if `Currency` is present, Tag 15.
848    pub fn has_currency(&self) -> bool {
849        self.message.body.has(tag::CURRENCY)
850    }
851
852
853
854
855    /// Sets `CustDirectedOrder`, Tag 1029.
856    pub fn set_cust_directed_order(&mut self, v: bool) {
857        self.message.body.set_field(tag::CUST_DIRECTED_ORDER, fixer::fix_boolean::FIXBoolean::from(v));
858    }
859
860    /// Gets `CustDirectedOrder`, Tag 1029.
861    pub fn get_cust_directed_order(&self) -> Result<bool, MessageRejectErrorEnum> {
862        let mut fld = field::CustDirectedOrderField::new(false);
863        self.message.body.get_field(tag::CUST_DIRECTED_ORDER, &mut fld.0)?;
864        Ok(fld.value())
865    }
866
867
868    /// Returns true if `CustDirectedOrder` is present, Tag 1029.
869    pub fn has_cust_directed_order(&self) -> bool {
870        self.message.body.has(tag::CUST_DIRECTED_ORDER)
871    }
872
873
874
875
876    /// Sets `CustOrderCapacity`, Tag 582.
877    pub fn set_cust_order_capacity(&mut self, v: isize) {
878        self.message.body.set_field(tag::CUST_ORDER_CAPACITY, fixer::fix_int::FIXInt::from(v));
879    }
880
881    /// Gets `CustOrderCapacity`, Tag 582.
882    pub fn get_cust_order_capacity(&self) -> Result<isize, MessageRejectErrorEnum> {
883        let mut fld = field::CustOrderCapacityField::new(0);
884        self.message.body.get_field(tag::CUST_ORDER_CAPACITY, &mut fld.0)?;
885        Ok(fld.value())
886    }
887
888
889    /// Returns true if `CustOrderCapacity` is present, Tag 582.
890    pub fn has_cust_order_capacity(&self) -> bool {
891        self.message.body.has(tag::CUST_ORDER_CAPACITY)
892    }
893
894
895
896
897    /// Sets `CustOrderHandlingInst`, Tag 1031.
898    pub fn set_cust_order_handling_inst(&mut self, v: String) {
899        self.message.body.set_field(tag::CUST_ORDER_HANDLING_INST, FIXString::from(v));
900    }
901
902    /// Gets `CustOrderHandlingInst`, Tag 1031.
903    pub fn get_cust_order_handling_inst(&self) -> Result<String, MessageRejectErrorEnum> {
904        let mut fld = field::CustOrderHandlingInstField::new(String::new());
905        self.message.body.get_field(tag::CUST_ORDER_HANDLING_INST, &mut fld.0)?;
906        Ok(fld.value().to_string())
907    }
908
909
910    /// Returns true if `CustOrderHandlingInst` is present, Tag 1031.
911    pub fn has_cust_order_handling_inst(&self) -> bool {
912        self.message.body.has(tag::CUST_ORDER_HANDLING_INST)
913    }
914
915
916
917
918    /// Sets `DatedDate`, Tag 873.
919    pub fn set_dated_date(&mut self, v: String) {
920        self.message.body.set_field(tag::DATED_DATE, FIXString::from(v));
921    }
922
923    /// Gets `DatedDate`, Tag 873.
924    pub fn get_dated_date(&self) -> Result<String, MessageRejectErrorEnum> {
925        let mut fld = field::DatedDateField::new(String::new());
926        self.message.body.get_field(tag::DATED_DATE, &mut fld.0)?;
927        Ok(fld.value().to_string())
928    }
929
930
931    /// Returns true if `DatedDate` is present, Tag 873.
932    pub fn has_dated_date(&self) -> bool {
933        self.message.body.has(tag::DATED_DATE)
934    }
935
936
937
938
939    /// Sets `DayBookingInst`, Tag 589.
940    pub fn set_day_booking_inst(&mut self, v: String) {
941        self.message.body.set_field(tag::DAY_BOOKING_INST, FIXString::from(v));
942    }
943
944    /// Gets `DayBookingInst`, Tag 589.
945    pub fn get_day_booking_inst(&self) -> Result<String, MessageRejectErrorEnum> {
946        let mut fld = field::DayBookingInstField::new(String::new());
947        self.message.body.get_field(tag::DAY_BOOKING_INST, &mut fld.0)?;
948        Ok(fld.value().to_string())
949    }
950
951
952    /// Returns true if `DayBookingInst` is present, Tag 589.
953    pub fn has_day_booking_inst(&self) -> bool {
954        self.message.body.has(tag::DAY_BOOKING_INST)
955    }
956
957
958
959
960    /// Sets `DeliveryType`, Tag 919.
961    pub fn set_delivery_type(&mut self, v: isize) {
962        self.message.body.set_field(tag::DELIVERY_TYPE, fixer::fix_int::FIXInt::from(v));
963    }
964
965    /// Gets `DeliveryType`, Tag 919.
966    pub fn get_delivery_type(&self) -> Result<isize, MessageRejectErrorEnum> {
967        let mut fld = field::DeliveryTypeField::new(0);
968        self.message.body.get_field(tag::DELIVERY_TYPE, &mut fld.0)?;
969        Ok(fld.value())
970    }
971
972
973    /// Returns true if `DeliveryType` is present, Tag 919.
974    pub fn has_delivery_type(&self) -> bool {
975        self.message.body.has(tag::DELIVERY_TYPE)
976    }
977
978
979
980
981    /// Sets `Designation`, Tag 494.
982    pub fn set_designation(&mut self, v: String) {
983        self.message.body.set_field(tag::DESIGNATION, FIXString::from(v));
984    }
985
986    /// Gets `Designation`, Tag 494.
987    pub fn get_designation(&self) -> Result<String, MessageRejectErrorEnum> {
988        let mut fld = field::DesignationField::new(String::new());
989        self.message.body.get_field(tag::DESIGNATION, &mut fld.0)?;
990        Ok(fld.value().to_string())
991    }
992
993
994    /// Returns true if `Designation` is present, Tag 494.
995    pub fn has_designation(&self) -> bool {
996        self.message.body.has(tag::DESIGNATION)
997    }
998
999
1000
1001
1002    /// Sets `DiscretionInst`, Tag 388.
1003    pub fn set_discretion_inst(&mut self, v: String) {
1004        self.message.body.set_field(tag::DISCRETION_INST, FIXString::from(v));
1005    }
1006
1007    /// Gets `DiscretionInst`, Tag 388.
1008    pub fn get_discretion_inst(&self) -> Result<String, MessageRejectErrorEnum> {
1009        let mut fld = field::DiscretionInstField::new(String::new());
1010        self.message.body.get_field(tag::DISCRETION_INST, &mut fld.0)?;
1011        Ok(fld.value().to_string())
1012    }
1013
1014
1015    /// Returns true if `DiscretionInst` is present, Tag 388.
1016    pub fn has_discretion_inst(&self) -> bool {
1017        self.message.body.has(tag::DISCRETION_INST)
1018    }
1019
1020
1021
1022
1023    /// Sets `DiscretionLimitType`, Tag 843.
1024    pub fn set_discretion_limit_type(&mut self, v: isize) {
1025        self.message.body.set_field(tag::DISCRETION_LIMIT_TYPE, fixer::fix_int::FIXInt::from(v));
1026    }
1027
1028    /// Gets `DiscretionLimitType`, Tag 843.
1029    pub fn get_discretion_limit_type(&self) -> Result<isize, MessageRejectErrorEnum> {
1030        let mut fld = field::DiscretionLimitTypeField::new(0);
1031        self.message.body.get_field(tag::DISCRETION_LIMIT_TYPE, &mut fld.0)?;
1032        Ok(fld.value())
1033    }
1034
1035
1036    /// Returns true if `DiscretionLimitType` is present, Tag 843.
1037    pub fn has_discretion_limit_type(&self) -> bool {
1038        self.message.body.has(tag::DISCRETION_LIMIT_TYPE)
1039    }
1040
1041
1042
1043
1044    /// Sets `DiscretionMoveType`, Tag 841.
1045    pub fn set_discretion_move_type(&mut self, v: isize) {
1046        self.message.body.set_field(tag::DISCRETION_MOVE_TYPE, fixer::fix_int::FIXInt::from(v));
1047    }
1048
1049    /// Gets `DiscretionMoveType`, Tag 841.
1050    pub fn get_discretion_move_type(&self) -> Result<isize, MessageRejectErrorEnum> {
1051        let mut fld = field::DiscretionMoveTypeField::new(0);
1052        self.message.body.get_field(tag::DISCRETION_MOVE_TYPE, &mut fld.0)?;
1053        Ok(fld.value())
1054    }
1055
1056
1057    /// Returns true if `DiscretionMoveType` is present, Tag 841.
1058    pub fn has_discretion_move_type(&self) -> bool {
1059        self.message.body.has(tag::DISCRETION_MOVE_TYPE)
1060    }
1061
1062
1063
1064
1065    /// Sets `DiscretionOffsetType`, Tag 842.
1066    pub fn set_discretion_offset_type(&mut self, v: isize) {
1067        self.message.body.set_field(tag::DISCRETION_OFFSET_TYPE, fixer::fix_int::FIXInt::from(v));
1068    }
1069
1070    /// Gets `DiscretionOffsetType`, Tag 842.
1071    pub fn get_discretion_offset_type(&self) -> Result<isize, MessageRejectErrorEnum> {
1072        let mut fld = field::DiscretionOffsetTypeField::new(0);
1073        self.message.body.get_field(tag::DISCRETION_OFFSET_TYPE, &mut fld.0)?;
1074        Ok(fld.value())
1075    }
1076
1077
1078    /// Returns true if `DiscretionOffsetType` is present, Tag 842.
1079    pub fn has_discretion_offset_type(&self) -> bool {
1080        self.message.body.has(tag::DISCRETION_OFFSET_TYPE)
1081    }
1082
1083
1084
1085
1086    /// Sets `DiscretionOffsetValue`, Tag 389.
1087    pub fn set_discretion_offset_value(&mut self, val: Decimal, scale: i32) {
1088        self.message.body.set_field(tag::DISCRETION_OFFSET_VALUE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1089    }
1090
1091    /// Gets `DiscretionOffsetValue`, Tag 389.
1092    pub fn get_discretion_offset_value(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1093        let mut fld = field::DiscretionOffsetValueField::new(Decimal::ZERO, 0);
1094        self.message.body.get_field(tag::DISCRETION_OFFSET_VALUE, &mut fld.0)?;
1095        Ok(fld.value())
1096    }
1097
1098
1099    /// Returns true if `DiscretionOffsetValue` is present, Tag 389.
1100    pub fn has_discretion_offset_value(&self) -> bool {
1101        self.message.body.has(tag::DISCRETION_OFFSET_VALUE)
1102    }
1103
1104
1105
1106
1107    /// Sets `DiscretionRoundDirection`, Tag 844.
1108    pub fn set_discretion_round_direction(&mut self, v: isize) {
1109        self.message.body.set_field(tag::DISCRETION_ROUND_DIRECTION, fixer::fix_int::FIXInt::from(v));
1110    }
1111
1112    /// Gets `DiscretionRoundDirection`, Tag 844.
1113    pub fn get_discretion_round_direction(&self) -> Result<isize, MessageRejectErrorEnum> {
1114        let mut fld = field::DiscretionRoundDirectionField::new(0);
1115        self.message.body.get_field(tag::DISCRETION_ROUND_DIRECTION, &mut fld.0)?;
1116        Ok(fld.value())
1117    }
1118
1119
1120    /// Returns true if `DiscretionRoundDirection` is present, Tag 844.
1121    pub fn has_discretion_round_direction(&self) -> bool {
1122        self.message.body.has(tag::DISCRETION_ROUND_DIRECTION)
1123    }
1124
1125
1126
1127
1128    /// Sets `DiscretionScope`, Tag 846.
1129    pub fn set_discretion_scope(&mut self, v: isize) {
1130        self.message.body.set_field(tag::DISCRETION_SCOPE, fixer::fix_int::FIXInt::from(v));
1131    }
1132
1133    /// Gets `DiscretionScope`, Tag 846.
1134    pub fn get_discretion_scope(&self) -> Result<isize, MessageRejectErrorEnum> {
1135        let mut fld = field::DiscretionScopeField::new(0);
1136        self.message.body.get_field(tag::DISCRETION_SCOPE, &mut fld.0)?;
1137        Ok(fld.value())
1138    }
1139
1140
1141    /// Returns true if `DiscretionScope` is present, Tag 846.
1142    pub fn has_discretion_scope(&self) -> bool {
1143        self.message.body.has(tag::DISCRETION_SCOPE)
1144    }
1145
1146
1147
1148
1149    /// Sets `DisplayHighQty`, Tag 1086.
1150    pub fn set_display_high_qty(&mut self, val: Decimal, scale: i32) {
1151        self.message.body.set_field(tag::DISPLAY_HIGH_QTY, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1152    }
1153
1154    /// Gets `DisplayHighQty`, Tag 1086.
1155    pub fn get_display_high_qty(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1156        let mut fld = field::DisplayHighQtyField::new(Decimal::ZERO, 0);
1157        self.message.body.get_field(tag::DISPLAY_HIGH_QTY, &mut fld.0)?;
1158        Ok(fld.value())
1159    }
1160
1161
1162    /// Returns true if `DisplayHighQty` is present, Tag 1086.
1163    pub fn has_display_high_qty(&self) -> bool {
1164        self.message.body.has(tag::DISPLAY_HIGH_QTY)
1165    }
1166
1167
1168
1169
1170    /// Sets `DisplayLowQty`, Tag 1085.
1171    pub fn set_display_low_qty(&mut self, val: Decimal, scale: i32) {
1172        self.message.body.set_field(tag::DISPLAY_LOW_QTY, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1173    }
1174
1175    /// Gets `DisplayLowQty`, Tag 1085.
1176    pub fn get_display_low_qty(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1177        let mut fld = field::DisplayLowQtyField::new(Decimal::ZERO, 0);
1178        self.message.body.get_field(tag::DISPLAY_LOW_QTY, &mut fld.0)?;
1179        Ok(fld.value())
1180    }
1181
1182
1183    /// Returns true if `DisplayLowQty` is present, Tag 1085.
1184    pub fn has_display_low_qty(&self) -> bool {
1185        self.message.body.has(tag::DISPLAY_LOW_QTY)
1186    }
1187
1188
1189
1190
1191    /// Sets `DisplayMethod`, Tag 1084.
1192    pub fn set_display_method(&mut self, v: String) {
1193        self.message.body.set_field(tag::DISPLAY_METHOD, FIXString::from(v));
1194    }
1195
1196    /// Gets `DisplayMethod`, Tag 1084.
1197    pub fn get_display_method(&self) -> Result<String, MessageRejectErrorEnum> {
1198        let mut fld = field::DisplayMethodField::new(String::new());
1199        self.message.body.get_field(tag::DISPLAY_METHOD, &mut fld.0)?;
1200        Ok(fld.value().to_string())
1201    }
1202
1203
1204    /// Returns true if `DisplayMethod` is present, Tag 1084.
1205    pub fn has_display_method(&self) -> bool {
1206        self.message.body.has(tag::DISPLAY_METHOD)
1207    }
1208
1209
1210
1211
1212    /// Sets `DisplayMinIncr`, Tag 1087.
1213    pub fn set_display_min_incr(&mut self, val: Decimal, scale: i32) {
1214        self.message.body.set_field(tag::DISPLAY_MIN_INCR, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1215    }
1216
1217    /// Gets `DisplayMinIncr`, Tag 1087.
1218    pub fn get_display_min_incr(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1219        let mut fld = field::DisplayMinIncrField::new(Decimal::ZERO, 0);
1220        self.message.body.get_field(tag::DISPLAY_MIN_INCR, &mut fld.0)?;
1221        Ok(fld.value())
1222    }
1223
1224
1225    /// Returns true if `DisplayMinIncr` is present, Tag 1087.
1226    pub fn has_display_min_incr(&self) -> bool {
1227        self.message.body.has(tag::DISPLAY_MIN_INCR)
1228    }
1229
1230
1231
1232
1233    /// Sets `DisplayQty`, Tag 1138.
1234    pub fn set_display_qty(&mut self, val: Decimal, scale: i32) {
1235        self.message.body.set_field(tag::DISPLAY_QTY, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1236    }
1237
1238    /// Gets `DisplayQty`, Tag 1138.
1239    pub fn get_display_qty(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1240        let mut fld = field::DisplayQtyField::new(Decimal::ZERO, 0);
1241        self.message.body.get_field(tag::DISPLAY_QTY, &mut fld.0)?;
1242        Ok(fld.value())
1243    }
1244
1245
1246    /// Returns true if `DisplayQty` is present, Tag 1138.
1247    pub fn has_display_qty(&self) -> bool {
1248        self.message.body.has(tag::DISPLAY_QTY)
1249    }
1250
1251
1252
1253
1254    /// Sets `DisplayWhen`, Tag 1083.
1255    pub fn set_display_when(&mut self, v: String) {
1256        self.message.body.set_field(tag::DISPLAY_WHEN, FIXString::from(v));
1257    }
1258
1259    /// Gets `DisplayWhen`, Tag 1083.
1260    pub fn get_display_when(&self) -> Result<String, MessageRejectErrorEnum> {
1261        let mut fld = field::DisplayWhenField::new(String::new());
1262        self.message.body.get_field(tag::DISPLAY_WHEN, &mut fld.0)?;
1263        Ok(fld.value().to_string())
1264    }
1265
1266
1267    /// Returns true if `DisplayWhen` is present, Tag 1083.
1268    pub fn has_display_when(&self) -> bool {
1269        self.message.body.has(tag::DISPLAY_WHEN)
1270    }
1271
1272
1273
1274
1275    /// Sets `EffectiveTime`, Tag 168.
1276    pub fn set_effective_time(&mut self, v: Timestamp) {
1277        self.message.body.set_field(tag::EFFECTIVE_TIME, fixer::fix_utc_timestamp::FIXUTCTimestamp {
1278            time: v,
1279            precision: fixer::fix_utc_timestamp::TimestampPrecision::Millis,
1280        });
1281    }
1282
1283    /// Gets `EffectiveTime`, Tag 168.
1284    pub fn get_effective_time(&self) -> Result<Timestamp, MessageRejectErrorEnum> {
1285        let mut fld = field::EffectiveTimeField::new(Timestamp::UNIX_EPOCH);
1286        self.message.body.get_field(tag::EFFECTIVE_TIME, &mut fld.0)?;
1287        Ok(fld.value())
1288    }
1289
1290
1291    /// Returns true if `EffectiveTime` is present, Tag 168.
1292    pub fn has_effective_time(&self) -> bool {
1293        self.message.body.has(tag::EFFECTIVE_TIME)
1294    }
1295
1296
1297
1298
1299    /// Sets `EncodedIssuer`, Tag 349.
1300    pub fn set_encoded_issuer(&mut self, v: String) {
1301        self.message.body.set_field(tag::ENCODED_ISSUER, FIXString::from(v));
1302    }
1303
1304    /// Gets `EncodedIssuer`, Tag 349.
1305    pub fn get_encoded_issuer(&self) -> Result<String, MessageRejectErrorEnum> {
1306        let mut fld = field::EncodedIssuerField::new(String::new());
1307        self.message.body.get_field(tag::ENCODED_ISSUER, &mut fld.0)?;
1308        Ok(fld.value().to_string())
1309    }
1310
1311
1312    /// Returns true if `EncodedIssuer` is present, Tag 349.
1313    pub fn has_encoded_issuer(&self) -> bool {
1314        self.message.body.has(tag::ENCODED_ISSUER)
1315    }
1316
1317
1318
1319
1320    /// Sets `EncodedIssuerLen`, Tag 348.
1321    pub fn set_encoded_issuer_len(&mut self, v: isize) {
1322        self.message.body.set_field(tag::ENCODED_ISSUER_LEN, fixer::fix_int::FIXInt::from(v));
1323    }
1324
1325    /// Gets `EncodedIssuerLen`, Tag 348.
1326    pub fn get_encoded_issuer_len(&self) -> Result<isize, MessageRejectErrorEnum> {
1327        let mut fld = field::EncodedIssuerLenField::new(0);
1328        self.message.body.get_field(tag::ENCODED_ISSUER_LEN, &mut fld.0)?;
1329        Ok(fld.value())
1330    }
1331
1332
1333    /// Returns true if `EncodedIssuerLen` is present, Tag 348.
1334    pub fn has_encoded_issuer_len(&self) -> bool {
1335        self.message.body.has(tag::ENCODED_ISSUER_LEN)
1336    }
1337
1338
1339
1340
1341    /// Sets `EncodedSecurityDesc`, Tag 351.
1342    pub fn set_encoded_security_desc(&mut self, v: String) {
1343        self.message.body.set_field(tag::ENCODED_SECURITY_DESC, FIXString::from(v));
1344    }
1345
1346    /// Gets `EncodedSecurityDesc`, Tag 351.
1347    pub fn get_encoded_security_desc(&self) -> Result<String, MessageRejectErrorEnum> {
1348        let mut fld = field::EncodedSecurityDescField::new(String::new());
1349        self.message.body.get_field(tag::ENCODED_SECURITY_DESC, &mut fld.0)?;
1350        Ok(fld.value().to_string())
1351    }
1352
1353
1354    /// Returns true if `EncodedSecurityDesc` is present, Tag 351.
1355    pub fn has_encoded_security_desc(&self) -> bool {
1356        self.message.body.has(tag::ENCODED_SECURITY_DESC)
1357    }
1358
1359
1360
1361
1362    /// Sets `EncodedSecurityDescLen`, Tag 350.
1363    pub fn set_encoded_security_desc_len(&mut self, v: isize) {
1364        self.message.body.set_field(tag::ENCODED_SECURITY_DESC_LEN, fixer::fix_int::FIXInt::from(v));
1365    }
1366
1367    /// Gets `EncodedSecurityDescLen`, Tag 350.
1368    pub fn get_encoded_security_desc_len(&self) -> Result<isize, MessageRejectErrorEnum> {
1369        let mut fld = field::EncodedSecurityDescLenField::new(0);
1370        self.message.body.get_field(tag::ENCODED_SECURITY_DESC_LEN, &mut fld.0)?;
1371        Ok(fld.value())
1372    }
1373
1374
1375    /// Returns true if `EncodedSecurityDescLen` is present, Tag 350.
1376    pub fn has_encoded_security_desc_len(&self) -> bool {
1377        self.message.body.has(tag::ENCODED_SECURITY_DESC_LEN)
1378    }
1379
1380
1381
1382
1383    /// Sets `EncodedText`, Tag 355.
1384    pub fn set_encoded_text(&mut self, v: String) {
1385        self.message.body.set_field(tag::ENCODED_TEXT, FIXString::from(v));
1386    }
1387
1388    /// Gets `EncodedText`, Tag 355.
1389    pub fn get_encoded_text(&self) -> Result<String, MessageRejectErrorEnum> {
1390        let mut fld = field::EncodedTextField::new(String::new());
1391        self.message.body.get_field(tag::ENCODED_TEXT, &mut fld.0)?;
1392        Ok(fld.value().to_string())
1393    }
1394
1395
1396    /// Returns true if `EncodedText` is present, Tag 355.
1397    pub fn has_encoded_text(&self) -> bool {
1398        self.message.body.has(tag::ENCODED_TEXT)
1399    }
1400
1401
1402
1403
1404    /// Sets `EncodedTextLen`, Tag 354.
1405    pub fn set_encoded_text_len(&mut self, v: isize) {
1406        self.message.body.set_field(tag::ENCODED_TEXT_LEN, fixer::fix_int::FIXInt::from(v));
1407    }
1408
1409    /// Gets `EncodedTextLen`, Tag 354.
1410    pub fn get_encoded_text_len(&self) -> Result<isize, MessageRejectErrorEnum> {
1411        let mut fld = field::EncodedTextLenField::new(0);
1412        self.message.body.get_field(tag::ENCODED_TEXT_LEN, &mut fld.0)?;
1413        Ok(fld.value())
1414    }
1415
1416
1417    /// Returns true if `EncodedTextLen` is present, Tag 354.
1418    pub fn has_encoded_text_len(&self) -> bool {
1419        self.message.body.has(tag::ENCODED_TEXT_LEN)
1420    }
1421
1422
1423
1424
1425    /// Sets `EndDate`, Tag 917.
1426    pub fn set_end_date(&mut self, v: String) {
1427        self.message.body.set_field(tag::END_DATE, FIXString::from(v));
1428    }
1429
1430    /// Gets `EndDate`, Tag 917.
1431    pub fn get_end_date(&self) -> Result<String, MessageRejectErrorEnum> {
1432        let mut fld = field::EndDateField::new(String::new());
1433        self.message.body.get_field(tag::END_DATE, &mut fld.0)?;
1434        Ok(fld.value().to_string())
1435    }
1436
1437
1438    /// Returns true if `EndDate` is present, Tag 917.
1439    pub fn has_end_date(&self) -> bool {
1440        self.message.body.has(tag::END_DATE)
1441    }
1442
1443
1444
1445
1446    /// Sets `ExDestination`, Tag 100.
1447    pub fn set_ex_destination(&mut self, v: String) {
1448        self.message.body.set_field(tag::EX_DESTINATION, FIXString::from(v));
1449    }
1450
1451    /// Gets `ExDestination`, Tag 100.
1452    pub fn get_ex_destination(&self) -> Result<String, MessageRejectErrorEnum> {
1453        let mut fld = field::ExDestinationField::new(String::new());
1454        self.message.body.get_field(tag::EX_DESTINATION, &mut fld.0)?;
1455        Ok(fld.value().to_string())
1456    }
1457
1458
1459    /// Returns true if `ExDestination` is present, Tag 100.
1460    pub fn has_ex_destination(&self) -> bool {
1461        self.message.body.has(tag::EX_DESTINATION)
1462    }
1463
1464
1465
1466
1467    /// Sets `ExDestinationIDSource`, Tag 1133.
1468    pub fn set_ex_destination_id_source(&mut self, v: String) {
1469        self.message.body.set_field(tag::EX_DESTINATION_ID_SOURCE, FIXString::from(v));
1470    }
1471
1472    /// Gets `ExDestinationIDSource`, Tag 1133.
1473    pub fn get_ex_destination_id_source(&self) -> Result<String, MessageRejectErrorEnum> {
1474        let mut fld = field::ExDestinationIDSourceField::new(String::new());
1475        self.message.body.get_field(tag::EX_DESTINATION_ID_SOURCE, &mut fld.0)?;
1476        Ok(fld.value().to_string())
1477    }
1478
1479
1480    /// Returns true if `ExDestinationIDSource` is present, Tag 1133.
1481    pub fn has_ex_destination_id_source(&self) -> bool {
1482        self.message.body.has(tag::EX_DESTINATION_ID_SOURCE)
1483    }
1484
1485
1486
1487
1488    /// Sets `ExecInst`, Tag 18.
1489    pub fn set_exec_inst(&mut self, v: String) {
1490        self.message.body.set_field(tag::EXEC_INST, FIXString::from(v));
1491    }
1492
1493    /// Gets `ExecInst`, Tag 18.
1494    pub fn get_exec_inst(&self) -> Result<String, MessageRejectErrorEnum> {
1495        let mut fld = field::ExecInstField::new(String::new());
1496        self.message.body.get_field(tag::EXEC_INST, &mut fld.0)?;
1497        Ok(fld.value().to_string())
1498    }
1499
1500
1501    /// Returns true if `ExecInst` is present, Tag 18.
1502    pub fn has_exec_inst(&self) -> bool {
1503        self.message.body.has(tag::EXEC_INST)
1504    }
1505
1506
1507
1508
1509    /// Sets `ExpireDate`, Tag 432.
1510    pub fn set_expire_date(&mut self, v: String) {
1511        self.message.body.set_field(tag::EXPIRE_DATE, FIXString::from(v));
1512    }
1513
1514    /// Gets `ExpireDate`, Tag 432.
1515    pub fn get_expire_date(&self) -> Result<String, MessageRejectErrorEnum> {
1516        let mut fld = field::ExpireDateField::new(String::new());
1517        self.message.body.get_field(tag::EXPIRE_DATE, &mut fld.0)?;
1518        Ok(fld.value().to_string())
1519    }
1520
1521
1522    /// Returns true if `ExpireDate` is present, Tag 432.
1523    pub fn has_expire_date(&self) -> bool {
1524        self.message.body.has(tag::EXPIRE_DATE)
1525    }
1526
1527
1528
1529
1530    /// Sets `ExpireTime`, Tag 126.
1531    pub fn set_expire_time(&mut self, v: Timestamp) {
1532        self.message.body.set_field(tag::EXPIRE_TIME, fixer::fix_utc_timestamp::FIXUTCTimestamp {
1533            time: v,
1534            precision: fixer::fix_utc_timestamp::TimestampPrecision::Millis,
1535        });
1536    }
1537
1538    /// Gets `ExpireTime`, Tag 126.
1539    pub fn get_expire_time(&self) -> Result<Timestamp, MessageRejectErrorEnum> {
1540        let mut fld = field::ExpireTimeField::new(Timestamp::UNIX_EPOCH);
1541        self.message.body.get_field(tag::EXPIRE_TIME, &mut fld.0)?;
1542        Ok(fld.value())
1543    }
1544
1545
1546    /// Returns true if `ExpireTime` is present, Tag 126.
1547    pub fn has_expire_time(&self) -> bool {
1548        self.message.body.has(tag::EXPIRE_TIME)
1549    }
1550
1551
1552
1553
1554    /// Sets `Factor`, Tag 228.
1555    pub fn set_factor(&mut self, val: Decimal, scale: i32) {
1556        self.message.body.set_field(tag::FACTOR, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1557    }
1558
1559    /// Gets `Factor`, Tag 228.
1560    pub fn get_factor(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1561        let mut fld = field::FactorField::new(Decimal::ZERO, 0);
1562        self.message.body.get_field(tag::FACTOR, &mut fld.0)?;
1563        Ok(fld.value())
1564    }
1565
1566
1567    /// Returns true if `Factor` is present, Tag 228.
1568    pub fn has_factor(&self) -> bool {
1569        self.message.body.has(tag::FACTOR)
1570    }
1571
1572
1573
1574
1575    /// Sets `ForexReq`, Tag 121.
1576    pub fn set_forex_req(&mut self, v: bool) {
1577        self.message.body.set_field(tag::FOREX_REQ, fixer::fix_boolean::FIXBoolean::from(v));
1578    }
1579
1580    /// Gets `ForexReq`, Tag 121.
1581    pub fn get_forex_req(&self) -> Result<bool, MessageRejectErrorEnum> {
1582        let mut fld = field::ForexReqField::new(false);
1583        self.message.body.get_field(tag::FOREX_REQ, &mut fld.0)?;
1584        Ok(fld.value())
1585    }
1586
1587
1588    /// Returns true if `ForexReq` is present, Tag 121.
1589    pub fn has_forex_req(&self) -> bool {
1590        self.message.body.has(tag::FOREX_REQ)
1591    }
1592
1593
1594
1595
1596    /// Sets `FundRenewWaiv`, Tag 497.
1597    pub fn set_fund_renew_waiv(&mut self, v: String) {
1598        self.message.body.set_field(tag::FUND_RENEW_WAIV, FIXString::from(v));
1599    }
1600
1601    /// Gets `FundRenewWaiv`, Tag 497.
1602    pub fn get_fund_renew_waiv(&self) -> Result<String, MessageRejectErrorEnum> {
1603        let mut fld = field::FundRenewWaivField::new(String::new());
1604        self.message.body.get_field(tag::FUND_RENEW_WAIV, &mut fld.0)?;
1605        Ok(fld.value().to_string())
1606    }
1607
1608
1609    /// Returns true if `FundRenewWaiv` is present, Tag 497.
1610    pub fn has_fund_renew_waiv(&self) -> bool {
1611        self.message.body.has(tag::FUND_RENEW_WAIV)
1612    }
1613
1614
1615
1616
1617    /// Sets `GTBookingInst`, Tag 427.
1618    pub fn set_gt_booking_inst(&mut self, v: isize) {
1619        self.message.body.set_field(tag::GT_BOOKING_INST, fixer::fix_int::FIXInt::from(v));
1620    }
1621
1622    /// Gets `GTBookingInst`, Tag 427.
1623    pub fn get_gt_booking_inst(&self) -> Result<isize, MessageRejectErrorEnum> {
1624        let mut fld = field::GTBookingInstField::new(0);
1625        self.message.body.get_field(tag::GT_BOOKING_INST, &mut fld.0)?;
1626        Ok(fld.value())
1627    }
1628
1629
1630    /// Returns true if `GTBookingInst` is present, Tag 427.
1631    pub fn has_gt_booking_inst(&self) -> bool {
1632        self.message.body.has(tag::GT_BOOKING_INST)
1633    }
1634
1635
1636
1637
1638    /// Sets `HandlInst`, Tag 21.
1639    pub fn set_handl_inst(&mut self, v: String) {
1640        self.message.body.set_field(tag::HANDL_INST, FIXString::from(v));
1641    }
1642
1643    /// Gets `HandlInst`, Tag 21.
1644    pub fn get_handl_inst(&self) -> Result<String, MessageRejectErrorEnum> {
1645        let mut fld = field::HandlInstField::new(String::new());
1646        self.message.body.get_field(tag::HANDL_INST, &mut fld.0)?;
1647        Ok(fld.value().to_string())
1648    }
1649
1650
1651    /// Returns true if `HandlInst` is present, Tag 21.
1652    pub fn has_handl_inst(&self) -> bool {
1653        self.message.body.has(tag::HANDL_INST)
1654    }
1655
1656
1657
1658
1659    /// Sets `InstrRegistry`, Tag 543.
1660    pub fn set_instr_registry(&mut self, v: String) {
1661        self.message.body.set_field(tag::INSTR_REGISTRY, FIXString::from(v));
1662    }
1663
1664    /// Gets `InstrRegistry`, Tag 543.
1665    pub fn get_instr_registry(&self) -> Result<String, MessageRejectErrorEnum> {
1666        let mut fld = field::InstrRegistryField::new(String::new());
1667        self.message.body.get_field(tag::INSTR_REGISTRY, &mut fld.0)?;
1668        Ok(fld.value().to_string())
1669    }
1670
1671
1672    /// Returns true if `InstrRegistry` is present, Tag 543.
1673    pub fn has_instr_registry(&self) -> bool {
1674        self.message.body.has(tag::INSTR_REGISTRY)
1675    }
1676
1677
1678
1679
1680    /// Sets `InstrmtAssignmentMethod`, Tag 1049.
1681    pub fn set_instrmt_assignment_method(&mut self, v: String) {
1682        self.message.body.set_field(tag::INSTRMT_ASSIGNMENT_METHOD, FIXString::from(v));
1683    }
1684
1685    /// Gets `InstrmtAssignmentMethod`, Tag 1049.
1686    pub fn get_instrmt_assignment_method(&self) -> Result<String, MessageRejectErrorEnum> {
1687        let mut fld = field::InstrmtAssignmentMethodField::new(String::new());
1688        self.message.body.get_field(tag::INSTRMT_ASSIGNMENT_METHOD, &mut fld.0)?;
1689        Ok(fld.value().to_string())
1690    }
1691
1692
1693    /// Returns true if `InstrmtAssignmentMethod` is present, Tag 1049.
1694    pub fn has_instrmt_assignment_method(&self) -> bool {
1695        self.message.body.has(tag::INSTRMT_ASSIGNMENT_METHOD)
1696    }
1697
1698
1699
1700
1701    /// Sets `InterestAccrualDate`, Tag 874.
1702    pub fn set_interest_accrual_date(&mut self, v: String) {
1703        self.message.body.set_field(tag::INTEREST_ACCRUAL_DATE, FIXString::from(v));
1704    }
1705
1706    /// Gets `InterestAccrualDate`, Tag 874.
1707    pub fn get_interest_accrual_date(&self) -> Result<String, MessageRejectErrorEnum> {
1708        let mut fld = field::InterestAccrualDateField::new(String::new());
1709        self.message.body.get_field(tag::INTEREST_ACCRUAL_DATE, &mut fld.0)?;
1710        Ok(fld.value().to_string())
1711    }
1712
1713
1714    /// Returns true if `InterestAccrualDate` is present, Tag 874.
1715    pub fn has_interest_accrual_date(&self) -> bool {
1716        self.message.body.has(tag::INTEREST_ACCRUAL_DATE)
1717    }
1718
1719
1720
1721
1722    /// Sets `IssueDate`, Tag 225.
1723    pub fn set_issue_date(&mut self, v: String) {
1724        self.message.body.set_field(tag::ISSUE_DATE, FIXString::from(v));
1725    }
1726
1727    /// Gets `IssueDate`, Tag 225.
1728    pub fn get_issue_date(&self) -> Result<String, MessageRejectErrorEnum> {
1729        let mut fld = field::IssueDateField::new(String::new());
1730        self.message.body.get_field(tag::ISSUE_DATE, &mut fld.0)?;
1731        Ok(fld.value().to_string())
1732    }
1733
1734
1735    /// Returns true if `IssueDate` is present, Tag 225.
1736    pub fn has_issue_date(&self) -> bool {
1737        self.message.body.has(tag::ISSUE_DATE)
1738    }
1739
1740
1741
1742
1743    /// Sets `Issuer`, Tag 106.
1744    pub fn set_issuer(&mut self, v: String) {
1745        self.message.body.set_field(tag::ISSUER, FIXString::from(v));
1746    }
1747
1748    /// Gets `Issuer`, Tag 106.
1749    pub fn get_issuer(&self) -> Result<String, MessageRejectErrorEnum> {
1750        let mut fld = field::IssuerField::new(String::new());
1751        self.message.body.get_field(tag::ISSUER, &mut fld.0)?;
1752        Ok(fld.value().to_string())
1753    }
1754
1755
1756    /// Returns true if `Issuer` is present, Tag 106.
1757    pub fn has_issuer(&self) -> bool {
1758        self.message.body.has(tag::ISSUER)
1759    }
1760
1761
1762
1763
1764    /// Sets `ListID`, Tag 66.
1765    pub fn set_list_id(&mut self, v: String) {
1766        self.message.body.set_field(tag::LIST_ID, FIXString::from(v));
1767    }
1768
1769    /// Gets `ListID`, Tag 66.
1770    pub fn get_list_id(&self) -> Result<String, MessageRejectErrorEnum> {
1771        let mut fld = field::ListIDField::new(String::new());
1772        self.message.body.get_field(tag::LIST_ID, &mut fld.0)?;
1773        Ok(fld.value().to_string())
1774    }
1775
1776
1777    /// Returns true if `ListID` is present, Tag 66.
1778    pub fn has_list_id(&self) -> bool {
1779        self.message.body.has(tag::LIST_ID)
1780    }
1781
1782
1783
1784
1785    /// Sets `LocaleOfIssue`, Tag 472.
1786    pub fn set_locale_of_issue(&mut self, v: String) {
1787        self.message.body.set_field(tag::LOCALE_OF_ISSUE, FIXString::from(v));
1788    }
1789
1790    /// Gets `LocaleOfIssue`, Tag 472.
1791    pub fn get_locale_of_issue(&self) -> Result<String, MessageRejectErrorEnum> {
1792        let mut fld = field::LocaleOfIssueField::new(String::new());
1793        self.message.body.get_field(tag::LOCALE_OF_ISSUE, &mut fld.0)?;
1794        Ok(fld.value().to_string())
1795    }
1796
1797
1798    /// Returns true if `LocaleOfIssue` is present, Tag 472.
1799    pub fn has_locale_of_issue(&self) -> bool {
1800        self.message.body.has(tag::LOCALE_OF_ISSUE)
1801    }
1802
1803
1804
1805
1806    /// Sets `LocateReqd`, Tag 114.
1807    pub fn set_locate_reqd(&mut self, v: bool) {
1808        self.message.body.set_field(tag::LOCATE_REQD, fixer::fix_boolean::FIXBoolean::from(v));
1809    }
1810
1811    /// Gets `LocateReqd`, Tag 114.
1812    pub fn get_locate_reqd(&self) -> Result<bool, MessageRejectErrorEnum> {
1813        let mut fld = field::LocateReqdField::new(false);
1814        self.message.body.get_field(tag::LOCATE_REQD, &mut fld.0)?;
1815        Ok(fld.value())
1816    }
1817
1818
1819    /// Returns true if `LocateReqd` is present, Tag 114.
1820    pub fn has_locate_reqd(&self) -> bool {
1821        self.message.body.has(tag::LOCATE_REQD)
1822    }
1823
1824
1825
1826
1827    /// Sets `ManualOrderIndicator`, Tag 1028.
1828    pub fn set_manual_order_indicator(&mut self, v: bool) {
1829        self.message.body.set_field(tag::MANUAL_ORDER_INDICATOR, fixer::fix_boolean::FIXBoolean::from(v));
1830    }
1831
1832    /// Gets `ManualOrderIndicator`, Tag 1028.
1833    pub fn get_manual_order_indicator(&self) -> Result<bool, MessageRejectErrorEnum> {
1834        let mut fld = field::ManualOrderIndicatorField::new(false);
1835        self.message.body.get_field(tag::MANUAL_ORDER_INDICATOR, &mut fld.0)?;
1836        Ok(fld.value())
1837    }
1838
1839
1840    /// Returns true if `ManualOrderIndicator` is present, Tag 1028.
1841    pub fn has_manual_order_indicator(&self) -> bool {
1842        self.message.body.has(tag::MANUAL_ORDER_INDICATOR)
1843    }
1844
1845
1846
1847
1848    /// Sets `MarginRatio`, Tag 898.
1849    pub fn set_margin_ratio(&mut self, val: Decimal, scale: i32) {
1850        self.message.body.set_field(tag::MARGIN_RATIO, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1851    }
1852
1853    /// Gets `MarginRatio`, Tag 898.
1854    pub fn get_margin_ratio(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1855        let mut fld = field::MarginRatioField::new(Decimal::ZERO, 0);
1856        self.message.body.get_field(tag::MARGIN_RATIO, &mut fld.0)?;
1857        Ok(fld.value())
1858    }
1859
1860
1861    /// Returns true if `MarginRatio` is present, Tag 898.
1862    pub fn has_margin_ratio(&self) -> bool {
1863        self.message.body.has(tag::MARGIN_RATIO)
1864    }
1865
1866
1867
1868
1869    /// Sets `MatchIncrement`, Tag 1089.
1870    pub fn set_match_increment(&mut self, val: Decimal, scale: i32) {
1871        self.message.body.set_field(tag::MATCH_INCREMENT, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1872    }
1873
1874    /// Gets `MatchIncrement`, Tag 1089.
1875    pub fn get_match_increment(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1876        let mut fld = field::MatchIncrementField::new(Decimal::ZERO, 0);
1877        self.message.body.get_field(tag::MATCH_INCREMENT, &mut fld.0)?;
1878        Ok(fld.value())
1879    }
1880
1881
1882    /// Returns true if `MatchIncrement` is present, Tag 1089.
1883    pub fn has_match_increment(&self) -> bool {
1884        self.message.body.has(tag::MATCH_INCREMENT)
1885    }
1886
1887
1888
1889
1890    /// Sets `MaturityDate`, Tag 541.
1891    pub fn set_maturity_date(&mut self, v: String) {
1892        self.message.body.set_field(tag::MATURITY_DATE, FIXString::from(v));
1893    }
1894
1895    /// Gets `MaturityDate`, Tag 541.
1896    pub fn get_maturity_date(&self) -> Result<String, MessageRejectErrorEnum> {
1897        let mut fld = field::MaturityDateField::new(String::new());
1898        self.message.body.get_field(tag::MATURITY_DATE, &mut fld.0)?;
1899        Ok(fld.value().to_string())
1900    }
1901
1902
1903    /// Returns true if `MaturityDate` is present, Tag 541.
1904    pub fn has_maturity_date(&self) -> bool {
1905        self.message.body.has(tag::MATURITY_DATE)
1906    }
1907
1908
1909
1910
1911    /// Sets `MaturityMonthYear`, Tag 200.
1912    pub fn set_maturity_month_year(&mut self, v: String) {
1913        self.message.body.set_field(tag::MATURITY_MONTH_YEAR, FIXString::from(v));
1914    }
1915
1916    /// Gets `MaturityMonthYear`, Tag 200.
1917    pub fn get_maturity_month_year(&self) -> Result<String, MessageRejectErrorEnum> {
1918        let mut fld = field::MaturityMonthYearField::new(String::new());
1919        self.message.body.get_field(tag::MATURITY_MONTH_YEAR, &mut fld.0)?;
1920        Ok(fld.value().to_string())
1921    }
1922
1923
1924    /// Returns true if `MaturityMonthYear` is present, Tag 200.
1925    pub fn has_maturity_month_year(&self) -> bool {
1926        self.message.body.has(tag::MATURITY_MONTH_YEAR)
1927    }
1928
1929
1930
1931
1932    /// Sets `MaturityTime`, Tag 1079.
1933    pub fn set_maturity_time(&mut self, v: String) {
1934        self.message.body.set_field(tag::MATURITY_TIME, FIXString::from(v));
1935    }
1936
1937    /// Gets `MaturityTime`, Tag 1079.
1938    pub fn get_maturity_time(&self) -> Result<String, MessageRejectErrorEnum> {
1939        let mut fld = field::MaturityTimeField::new(String::new());
1940        self.message.body.get_field(tag::MATURITY_TIME, &mut fld.0)?;
1941        Ok(fld.value().to_string())
1942    }
1943
1944
1945    /// Returns true if `MaturityTime` is present, Tag 1079.
1946    pub fn has_maturity_time(&self) -> bool {
1947        self.message.body.has(tag::MATURITY_TIME)
1948    }
1949
1950
1951
1952
1953    /// Sets `MaxFloor`, Tag 111.
1954    pub fn set_max_floor(&mut self, val: Decimal, scale: i32) {
1955        self.message.body.set_field(tag::MAX_FLOOR, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1956    }
1957
1958    /// Gets `MaxFloor`, Tag 111.
1959    pub fn get_max_floor(&self) -> Result<Decimal, MessageRejectErrorEnum> {
1960        let mut fld = field::MaxFloorField::new(Decimal::ZERO, 0);
1961        self.message.body.get_field(tag::MAX_FLOOR, &mut fld.0)?;
1962        Ok(fld.value())
1963    }
1964
1965
1966    /// Returns true if `MaxFloor` is present, Tag 111.
1967    pub fn has_max_floor(&self) -> bool {
1968        self.message.body.has(tag::MAX_FLOOR)
1969    }
1970
1971
1972
1973
1974    /// Sets `MaxPriceLevels`, Tag 1090.
1975    pub fn set_max_price_levels(&mut self, v: isize) {
1976        self.message.body.set_field(tag::MAX_PRICE_LEVELS, fixer::fix_int::FIXInt::from(v));
1977    }
1978
1979    /// Gets `MaxPriceLevels`, Tag 1090.
1980    pub fn get_max_price_levels(&self) -> Result<isize, MessageRejectErrorEnum> {
1981        let mut fld = field::MaxPriceLevelsField::new(0);
1982        self.message.body.get_field(tag::MAX_PRICE_LEVELS, &mut fld.0)?;
1983        Ok(fld.value())
1984    }
1985
1986
1987    /// Returns true if `MaxPriceLevels` is present, Tag 1090.
1988    pub fn has_max_price_levels(&self) -> bool {
1989        self.message.body.has(tag::MAX_PRICE_LEVELS)
1990    }
1991
1992
1993
1994
1995    /// Sets `MaxShow`, Tag 210.
1996    pub fn set_max_show(&mut self, val: Decimal, scale: i32) {
1997        self.message.body.set_field(tag::MAX_SHOW, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
1998    }
1999
2000    /// Gets `MaxShow`, Tag 210.
2001    pub fn get_max_show(&self) -> Result<Decimal, MessageRejectErrorEnum> {
2002        let mut fld = field::MaxShowField::new(Decimal::ZERO, 0);
2003        self.message.body.get_field(tag::MAX_SHOW, &mut fld.0)?;
2004        Ok(fld.value())
2005    }
2006
2007
2008    /// Returns true if `MaxShow` is present, Tag 210.
2009    pub fn has_max_show(&self) -> bool {
2010        self.message.body.has(tag::MAX_SHOW)
2011    }
2012
2013
2014
2015
2016    /// Sets `MinPriceIncrement`, Tag 969.
2017    pub fn set_min_price_increment(&mut self, val: Decimal, scale: i32) {
2018        self.message.body.set_field(tag::MIN_PRICE_INCREMENT, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
2019    }
2020
2021    /// Gets `MinPriceIncrement`, Tag 969.
2022    pub fn get_min_price_increment(&self) -> Result<Decimal, MessageRejectErrorEnum> {
2023        let mut fld = field::MinPriceIncrementField::new(Decimal::ZERO, 0);
2024        self.message.body.get_field(tag::MIN_PRICE_INCREMENT, &mut fld.0)?;
2025        Ok(fld.value())
2026    }
2027
2028
2029    /// Returns true if `MinPriceIncrement` is present, Tag 969.
2030    pub fn has_min_price_increment(&self) -> bool {
2031        self.message.body.has(tag::MIN_PRICE_INCREMENT)
2032    }
2033
2034
2035
2036
2037    /// Sets `MinQty`, Tag 110.
2038    pub fn set_min_qty(&mut self, val: Decimal, scale: i32) {
2039        self.message.body.set_field(tag::MIN_QTY, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
2040    }
2041
2042    /// Gets `MinQty`, Tag 110.
2043    pub fn get_min_qty(&self) -> Result<Decimal, MessageRejectErrorEnum> {
2044        let mut fld = field::MinQtyField::new(Decimal::ZERO, 0);
2045        self.message.body.get_field(tag::MIN_QTY, &mut fld.0)?;
2046        Ok(fld.value())
2047    }
2048
2049
2050    /// Returns true if `MinQty` is present, Tag 110.
2051    pub fn has_min_qty(&self) -> bool {
2052        self.message.body.has(tag::MIN_QTY)
2053    }
2054
2055
2056
2057
2058    /// Sets `MoneyLaunderingStatus`, Tag 481.
2059    pub fn set_money_laundering_status(&mut self, v: String) {
2060        self.message.body.set_field(tag::MONEY_LAUNDERING_STATUS, FIXString::from(v));
2061    }
2062
2063    /// Gets `MoneyLaunderingStatus`, Tag 481.
2064    pub fn get_money_laundering_status(&self) -> Result<String, MessageRejectErrorEnum> {
2065        let mut fld = field::MoneyLaunderingStatusField::new(String::new());
2066        self.message.body.get_field(tag::MONEY_LAUNDERING_STATUS, &mut fld.0)?;
2067        Ok(fld.value().to_string())
2068    }
2069
2070
2071    /// Returns true if `MoneyLaunderingStatus` is present, Tag 481.
2072    pub fn has_money_laundering_status(&self) -> bool {
2073        self.message.body.has(tag::MONEY_LAUNDERING_STATUS)
2074    }
2075
2076
2077
2078
2079    /// Sets `NTPositionLimit`, Tag 971.
2080    pub fn set_nt_position_limit(&mut self, v: isize) {
2081        self.message.body.set_field(tag::NT_POSITION_LIMIT, fixer::fix_int::FIXInt::from(v));
2082    }
2083
2084    /// Gets `NTPositionLimit`, Tag 971.
2085    pub fn get_nt_position_limit(&self) -> Result<isize, MessageRejectErrorEnum> {
2086        let mut fld = field::NTPositionLimitField::new(0);
2087        self.message.body.get_field(tag::NT_POSITION_LIMIT, &mut fld.0)?;
2088        Ok(fld.value())
2089    }
2090
2091
2092    /// Returns true if `NTPositionLimit` is present, Tag 971.
2093    pub fn has_nt_position_limit(&self) -> bool {
2094        self.message.body.has(tag::NT_POSITION_LIMIT)
2095    }
2096
2097
2098
2099
2100    /// Sets `NoAllocs`, Tag 78.
2101    pub fn set_no_allocs(&mut self, v: isize) {
2102        self.message.body.set_field(tag::NO_ALLOCS, fixer::fix_int::FIXInt::from(v));
2103    }
2104
2105    /// Gets `NoAllocs`, Tag 78.
2106    pub fn get_no_allocs(&self) -> Result<isize, MessageRejectErrorEnum> {
2107        let mut fld = field::NoAllocsField::new(0);
2108        self.message.body.get_field(tag::NO_ALLOCS, &mut fld.0)?;
2109        Ok(fld.value())
2110    }
2111
2112
2113    /// Returns true if `NoAllocs` is present, Tag 78.
2114    pub fn has_no_allocs(&self) -> bool {
2115        self.message.body.has(tag::NO_ALLOCS)
2116    }
2117
2118
2119
2120
2121    /// Sets `NoEvents`, Tag 864.
2122    pub fn set_no_events(&mut self, v: isize) {
2123        self.message.body.set_field(tag::NO_EVENTS, fixer::fix_int::FIXInt::from(v));
2124    }
2125
2126    /// Gets `NoEvents`, Tag 864.
2127    pub fn get_no_events(&self) -> Result<isize, MessageRejectErrorEnum> {
2128        let mut fld = field::NoEventsField::new(0);
2129        self.message.body.get_field(tag::NO_EVENTS, &mut fld.0)?;
2130        Ok(fld.value())
2131    }
2132
2133
2134    /// Returns true if `NoEvents` is present, Tag 864.
2135    pub fn has_no_events(&self) -> bool {
2136        self.message.body.has(tag::NO_EVENTS)
2137    }
2138
2139
2140
2141
2142    /// Sets `NoInstrumentParties`, Tag 1018.
2143    pub fn set_no_instrument_parties(&mut self, v: isize) {
2144        self.message.body.set_field(tag::NO_INSTRUMENT_PARTIES, fixer::fix_int::FIXInt::from(v));
2145    }
2146
2147    /// Gets `NoInstrumentParties`, Tag 1018.
2148    pub fn get_no_instrument_parties(&self) -> Result<isize, MessageRejectErrorEnum> {
2149        let mut fld = field::NoInstrumentPartiesField::new(0);
2150        self.message.body.get_field(tag::NO_INSTRUMENT_PARTIES, &mut fld.0)?;
2151        Ok(fld.value())
2152    }
2153
2154
2155    /// Returns true if `NoInstrumentParties` is present, Tag 1018.
2156    pub fn has_no_instrument_parties(&self) -> bool {
2157        self.message.body.has(tag::NO_INSTRUMENT_PARTIES)
2158    }
2159
2160
2161
2162
2163    /// Sets `NoPartyIDs`, Tag 453.
2164    pub fn set_no_party_i_ds(&mut self, v: isize) {
2165        self.message.body.set_field(tag::NO_PARTY_I_DS, fixer::fix_int::FIXInt::from(v));
2166    }
2167
2168    /// Gets `NoPartyIDs`, Tag 453.
2169    pub fn get_no_party_i_ds(&self) -> Result<isize, MessageRejectErrorEnum> {
2170        let mut fld = field::NoPartyIDsField::new(0);
2171        self.message.body.get_field(tag::NO_PARTY_I_DS, &mut fld.0)?;
2172        Ok(fld.value())
2173    }
2174
2175
2176    /// Returns true if `NoPartyIDs` is present, Tag 453.
2177    pub fn has_no_party_i_ds(&self) -> bool {
2178        self.message.body.has(tag::NO_PARTY_I_DS)
2179    }
2180
2181
2182
2183
2184    /// Sets `NoSecurityAltID`, Tag 454.
2185    pub fn set_no_security_alt_id(&mut self, v: isize) {
2186        self.message.body.set_field(tag::NO_SECURITY_ALT_ID, fixer::fix_int::FIXInt::from(v));
2187    }
2188
2189    /// Gets `NoSecurityAltID`, Tag 454.
2190    pub fn get_no_security_alt_id(&self) -> Result<isize, MessageRejectErrorEnum> {
2191        let mut fld = field::NoSecurityAltIDField::new(0);
2192        self.message.body.get_field(tag::NO_SECURITY_ALT_ID, &mut fld.0)?;
2193        Ok(fld.value())
2194    }
2195
2196
2197    /// Returns true if `NoSecurityAltID` is present, Tag 454.
2198    pub fn has_no_security_alt_id(&self) -> bool {
2199        self.message.body.has(tag::NO_SECURITY_ALT_ID)
2200    }
2201
2202
2203
2204
2205    /// Sets `NoStrategyParameters`, Tag 957.
2206    pub fn set_no_strategy_parameters(&mut self, v: isize) {
2207        self.message.body.set_field(tag::NO_STRATEGY_PARAMETERS, fixer::fix_int::FIXInt::from(v));
2208    }
2209
2210    /// Gets `NoStrategyParameters`, Tag 957.
2211    pub fn get_no_strategy_parameters(&self) -> Result<isize, MessageRejectErrorEnum> {
2212        let mut fld = field::NoStrategyParametersField::new(0);
2213        self.message.body.get_field(tag::NO_STRATEGY_PARAMETERS, &mut fld.0)?;
2214        Ok(fld.value())
2215    }
2216
2217
2218    /// Returns true if `NoStrategyParameters` is present, Tag 957.
2219    pub fn has_no_strategy_parameters(&self) -> bool {
2220        self.message.body.has(tag::NO_STRATEGY_PARAMETERS)
2221    }
2222
2223
2224
2225
2226    /// Sets `NoTradingSessions`, Tag 386.
2227    pub fn set_no_trading_sessions(&mut self, v: isize) {
2228        self.message.body.set_field(tag::NO_TRADING_SESSIONS, fixer::fix_int::FIXInt::from(v));
2229    }
2230
2231    /// Gets `NoTradingSessions`, Tag 386.
2232    pub fn get_no_trading_sessions(&self) -> Result<isize, MessageRejectErrorEnum> {
2233        let mut fld = field::NoTradingSessionsField::new(0);
2234        self.message.body.get_field(tag::NO_TRADING_SESSIONS, &mut fld.0)?;
2235        Ok(fld.value())
2236    }
2237
2238
2239    /// Returns true if `NoTradingSessions` is present, Tag 386.
2240    pub fn has_no_trading_sessions(&self) -> bool {
2241        self.message.body.has(tag::NO_TRADING_SESSIONS)
2242    }
2243
2244
2245
2246
2247    /// Sets `NoTrdRegTimestamps`, Tag 768.
2248    pub fn set_no_trd_reg_timestamps(&mut self, v: isize) {
2249        self.message.body.set_field(tag::NO_TRD_REG_TIMESTAMPS, fixer::fix_int::FIXInt::from(v));
2250    }
2251
2252    /// Gets `NoTrdRegTimestamps`, Tag 768.
2253    pub fn get_no_trd_reg_timestamps(&self) -> Result<isize, MessageRejectErrorEnum> {
2254        let mut fld = field::NoTrdRegTimestampsField::new(0);
2255        self.message.body.get_field(tag::NO_TRD_REG_TIMESTAMPS, &mut fld.0)?;
2256        Ok(fld.value())
2257    }
2258
2259
2260    /// Returns true if `NoTrdRegTimestamps` is present, Tag 768.
2261    pub fn has_no_trd_reg_timestamps(&self) -> bool {
2262        self.message.body.has(tag::NO_TRD_REG_TIMESTAMPS)
2263    }
2264
2265
2266
2267
2268    /// Sets `NoUnderlyings`, Tag 711.
2269    pub fn set_no_underlyings(&mut self, v: isize) {
2270        self.message.body.set_field(tag::NO_UNDERLYINGS, fixer::fix_int::FIXInt::from(v));
2271    }
2272
2273    /// Gets `NoUnderlyings`, Tag 711.
2274    pub fn get_no_underlyings(&self) -> Result<isize, MessageRejectErrorEnum> {
2275        let mut fld = field::NoUnderlyingsField::new(0);
2276        self.message.body.get_field(tag::NO_UNDERLYINGS, &mut fld.0)?;
2277        Ok(fld.value())
2278    }
2279
2280
2281    /// Returns true if `NoUnderlyings` is present, Tag 711.
2282    pub fn has_no_underlyings(&self) -> bool {
2283        self.message.body.has(tag::NO_UNDERLYINGS)
2284    }
2285
2286
2287
2288
2289    /// Sets `OptAttribute`, Tag 206.
2290    pub fn set_opt_attribute(&mut self, v: String) {
2291        self.message.body.set_field(tag::OPT_ATTRIBUTE, FIXString::from(v));
2292    }
2293
2294    /// Gets `OptAttribute`, Tag 206.
2295    pub fn get_opt_attribute(&self) -> Result<String, MessageRejectErrorEnum> {
2296        let mut fld = field::OptAttributeField::new(String::new());
2297        self.message.body.get_field(tag::OPT_ATTRIBUTE, &mut fld.0)?;
2298        Ok(fld.value().to_string())
2299    }
2300
2301
2302    /// Returns true if `OptAttribute` is present, Tag 206.
2303    pub fn has_opt_attribute(&self) -> bool {
2304        self.message.body.has(tag::OPT_ATTRIBUTE)
2305    }
2306
2307
2308
2309
2310    /// Sets `OrdType`, Tag 40.
2311    pub fn set_ord_type(&mut self, v: String) {
2312        self.message.body.set_field(tag::ORD_TYPE, FIXString::from(v));
2313    }
2314
2315    /// Gets `OrdType`, Tag 40.
2316    pub fn get_ord_type(&self) -> Result<String, MessageRejectErrorEnum> {
2317        let mut fld = field::OrdTypeField::new(String::new());
2318        self.message.body.get_field(tag::ORD_TYPE, &mut fld.0)?;
2319        Ok(fld.value().to_string())
2320    }
2321
2322
2323    /// Returns true if `OrdType` is present, Tag 40.
2324    pub fn has_ord_type(&self) -> bool {
2325        self.message.body.has(tag::ORD_TYPE)
2326    }
2327
2328
2329
2330
2331    /// Sets `OrderCapacity`, Tag 528.
2332    pub fn set_order_capacity(&mut self, v: String) {
2333        self.message.body.set_field(tag::ORDER_CAPACITY, FIXString::from(v));
2334    }
2335
2336    /// Gets `OrderCapacity`, Tag 528.
2337    pub fn get_order_capacity(&self) -> Result<String, MessageRejectErrorEnum> {
2338        let mut fld = field::OrderCapacityField::new(String::new());
2339        self.message.body.get_field(tag::ORDER_CAPACITY, &mut fld.0)?;
2340        Ok(fld.value().to_string())
2341    }
2342
2343
2344    /// Returns true if `OrderCapacity` is present, Tag 528.
2345    pub fn has_order_capacity(&self) -> bool {
2346        self.message.body.has(tag::ORDER_CAPACITY)
2347    }
2348
2349
2350
2351
2352    /// Sets `OrderHandlingInstSource`, Tag 1032.
2353    pub fn set_order_handling_inst_source(&mut self, v: isize) {
2354        self.message.body.set_field(tag::ORDER_HANDLING_INST_SOURCE, fixer::fix_int::FIXInt::from(v));
2355    }
2356
2357    /// Gets `OrderHandlingInstSource`, Tag 1032.
2358    pub fn get_order_handling_inst_source(&self) -> Result<isize, MessageRejectErrorEnum> {
2359        let mut fld = field::OrderHandlingInstSourceField::new(0);
2360        self.message.body.get_field(tag::ORDER_HANDLING_INST_SOURCE, &mut fld.0)?;
2361        Ok(fld.value())
2362    }
2363
2364
2365    /// Returns true if `OrderHandlingInstSource` is present, Tag 1032.
2366    pub fn has_order_handling_inst_source(&self) -> bool {
2367        self.message.body.has(tag::ORDER_HANDLING_INST_SOURCE)
2368    }
2369
2370
2371
2372
2373    /// Sets `OrderID`, Tag 37.
2374    pub fn set_order_id(&mut self, v: String) {
2375        self.message.body.set_field(tag::ORDER_ID, FIXString::from(v));
2376    }
2377
2378    /// Gets `OrderID`, Tag 37.
2379    pub fn get_order_id(&self) -> Result<String, MessageRejectErrorEnum> {
2380        let mut fld = field::OrderIDField::new(String::new());
2381        self.message.body.get_field(tag::ORDER_ID, &mut fld.0)?;
2382        Ok(fld.value().to_string())
2383    }
2384
2385
2386    /// Returns true if `OrderID` is present, Tag 37.
2387    pub fn has_order_id(&self) -> bool {
2388        self.message.body.has(tag::ORDER_ID)
2389    }
2390
2391
2392
2393
2394    /// Sets `OrderPercent`, Tag 516.
2395    pub fn set_order_percent(&mut self, val: Decimal, scale: i32) {
2396        self.message.body.set_field(tag::ORDER_PERCENT, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
2397    }
2398
2399    /// Gets `OrderPercent`, Tag 516.
2400    pub fn get_order_percent(&self) -> Result<Decimal, MessageRejectErrorEnum> {
2401        let mut fld = field::OrderPercentField::new(Decimal::ZERO, 0);
2402        self.message.body.get_field(tag::ORDER_PERCENT, &mut fld.0)?;
2403        Ok(fld.value())
2404    }
2405
2406
2407    /// Returns true if `OrderPercent` is present, Tag 516.
2408    pub fn has_order_percent(&self) -> bool {
2409        self.message.body.has(tag::ORDER_PERCENT)
2410    }
2411
2412
2413
2414
2415    /// Sets `OrderQty`, Tag 38.
2416    pub fn set_order_qty(&mut self, val: Decimal, scale: i32) {
2417        self.message.body.set_field(tag::ORDER_QTY, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
2418    }
2419
2420    /// Gets `OrderQty`, Tag 38.
2421    pub fn get_order_qty(&self) -> Result<Decimal, MessageRejectErrorEnum> {
2422        let mut fld = field::OrderQtyField::new(Decimal::ZERO, 0);
2423        self.message.body.get_field(tag::ORDER_QTY, &mut fld.0)?;
2424        Ok(fld.value())
2425    }
2426
2427
2428    /// Returns true if `OrderQty` is present, Tag 38.
2429    pub fn has_order_qty(&self) -> bool {
2430        self.message.body.has(tag::ORDER_QTY)
2431    }
2432
2433
2434
2435
2436    /// Sets `OrderQty2`, Tag 192.
2437    pub fn set_order_qty2(&mut self, val: Decimal, scale: i32) {
2438        self.message.body.set_field(tag::ORDER_QTY2, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
2439    }
2440
2441    /// Gets `OrderQty2`, Tag 192.
2442    pub fn get_order_qty2(&self) -> Result<Decimal, MessageRejectErrorEnum> {
2443        let mut fld = field::OrderQty2Field::new(Decimal::ZERO, 0);
2444        self.message.body.get_field(tag::ORDER_QTY2, &mut fld.0)?;
2445        Ok(fld.value())
2446    }
2447
2448
2449    /// Returns true if `OrderQty2` is present, Tag 192.
2450    pub fn has_order_qty2(&self) -> bool {
2451        self.message.body.has(tag::ORDER_QTY2)
2452    }
2453
2454
2455
2456
2457    /// Sets `OrderRestrictions`, Tag 529.
2458    pub fn set_order_restrictions(&mut self, v: String) {
2459        self.message.body.set_field(tag::ORDER_RESTRICTIONS, FIXString::from(v));
2460    }
2461
2462    /// Gets `OrderRestrictions`, Tag 529.
2463    pub fn get_order_restrictions(&self) -> Result<String, MessageRejectErrorEnum> {
2464        let mut fld = field::OrderRestrictionsField::new(String::new());
2465        self.message.body.get_field(tag::ORDER_RESTRICTIONS, &mut fld.0)?;
2466        Ok(fld.value().to_string())
2467    }
2468
2469
2470    /// Returns true if `OrderRestrictions` is present, Tag 529.
2471    pub fn has_order_restrictions(&self) -> bool {
2472        self.message.body.has(tag::ORDER_RESTRICTIONS)
2473    }
2474
2475
2476
2477
2478    /// Sets `OrigClOrdID`, Tag 41.
2479    pub fn set_orig_cl_ord_id(&mut self, v: String) {
2480        self.message.body.set_field(tag::ORIG_CL_ORD_ID, FIXString::from(v));
2481    }
2482
2483    /// Gets `OrigClOrdID`, Tag 41.
2484    pub fn get_orig_cl_ord_id(&self) -> Result<String, MessageRejectErrorEnum> {
2485        let mut fld = field::OrigClOrdIDField::new(String::new());
2486        self.message.body.get_field(tag::ORIG_CL_ORD_ID, &mut fld.0)?;
2487        Ok(fld.value().to_string())
2488    }
2489
2490
2491    /// Returns true if `OrigClOrdID` is present, Tag 41.
2492    pub fn has_orig_cl_ord_id(&self) -> bool {
2493        self.message.body.has(tag::ORIG_CL_ORD_ID)
2494    }
2495
2496
2497
2498
2499    /// Sets `OrigOrdModTime`, Tag 586.
2500    pub fn set_orig_ord_mod_time(&mut self, v: Timestamp) {
2501        self.message.body.set_field(tag::ORIG_ORD_MOD_TIME, fixer::fix_utc_timestamp::FIXUTCTimestamp {
2502            time: v,
2503            precision: fixer::fix_utc_timestamp::TimestampPrecision::Millis,
2504        });
2505    }
2506
2507    /// Gets `OrigOrdModTime`, Tag 586.
2508    pub fn get_orig_ord_mod_time(&self) -> Result<Timestamp, MessageRejectErrorEnum> {
2509        let mut fld = field::OrigOrdModTimeField::new(Timestamp::UNIX_EPOCH);
2510        self.message.body.get_field(tag::ORIG_ORD_MOD_TIME, &mut fld.0)?;
2511        Ok(fld.value())
2512    }
2513
2514
2515    /// Returns true if `OrigOrdModTime` is present, Tag 586.
2516    pub fn has_orig_ord_mod_time(&self) -> bool {
2517        self.message.body.has(tag::ORIG_ORD_MOD_TIME)
2518    }
2519
2520
2521
2522
2523    /// Sets `ParticipationRate`, Tag 849.
2524    pub fn set_participation_rate(&mut self, val: Decimal, scale: i32) {
2525        self.message.body.set_field(tag::PARTICIPATION_RATE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
2526    }
2527
2528    /// Gets `ParticipationRate`, Tag 849.
2529    pub fn get_participation_rate(&self) -> Result<Decimal, MessageRejectErrorEnum> {
2530        let mut fld = field::ParticipationRateField::new(Decimal::ZERO, 0);
2531        self.message.body.get_field(tag::PARTICIPATION_RATE, &mut fld.0)?;
2532        Ok(fld.value())
2533    }
2534
2535
2536    /// Returns true if `ParticipationRate` is present, Tag 849.
2537    pub fn has_participation_rate(&self) -> bool {
2538        self.message.body.has(tag::PARTICIPATION_RATE)
2539    }
2540
2541
2542
2543
2544    /// Sets `PegLimitType`, Tag 837.
2545    pub fn set_peg_limit_type(&mut self, v: isize) {
2546        self.message.body.set_field(tag::PEG_LIMIT_TYPE, fixer::fix_int::FIXInt::from(v));
2547    }
2548
2549    /// Gets `PegLimitType`, Tag 837.
2550    pub fn get_peg_limit_type(&self) -> Result<isize, MessageRejectErrorEnum> {
2551        let mut fld = field::PegLimitTypeField::new(0);
2552        self.message.body.get_field(tag::PEG_LIMIT_TYPE, &mut fld.0)?;
2553        Ok(fld.value())
2554    }
2555
2556
2557    /// Returns true if `PegLimitType` is present, Tag 837.
2558    pub fn has_peg_limit_type(&self) -> bool {
2559        self.message.body.has(tag::PEG_LIMIT_TYPE)
2560    }
2561
2562
2563
2564
2565    /// Sets `PegMoveType`, Tag 835.
2566    pub fn set_peg_move_type(&mut self, v: isize) {
2567        self.message.body.set_field(tag::PEG_MOVE_TYPE, fixer::fix_int::FIXInt::from(v));
2568    }
2569
2570    /// Gets `PegMoveType`, Tag 835.
2571    pub fn get_peg_move_type(&self) -> Result<isize, MessageRejectErrorEnum> {
2572        let mut fld = field::PegMoveTypeField::new(0);
2573        self.message.body.get_field(tag::PEG_MOVE_TYPE, &mut fld.0)?;
2574        Ok(fld.value())
2575    }
2576
2577
2578    /// Returns true if `PegMoveType` is present, Tag 835.
2579    pub fn has_peg_move_type(&self) -> bool {
2580        self.message.body.has(tag::PEG_MOVE_TYPE)
2581    }
2582
2583
2584
2585
2586    /// Sets `PegOffsetType`, Tag 836.
2587    pub fn set_peg_offset_type(&mut self, v: isize) {
2588        self.message.body.set_field(tag::PEG_OFFSET_TYPE, fixer::fix_int::FIXInt::from(v));
2589    }
2590
2591    /// Gets `PegOffsetType`, Tag 836.
2592    pub fn get_peg_offset_type(&self) -> Result<isize, MessageRejectErrorEnum> {
2593        let mut fld = field::PegOffsetTypeField::new(0);
2594        self.message.body.get_field(tag::PEG_OFFSET_TYPE, &mut fld.0)?;
2595        Ok(fld.value())
2596    }
2597
2598
2599    /// Returns true if `PegOffsetType` is present, Tag 836.
2600    pub fn has_peg_offset_type(&self) -> bool {
2601        self.message.body.has(tag::PEG_OFFSET_TYPE)
2602    }
2603
2604
2605
2606
2607    /// Sets `PegOffsetValue`, Tag 211.
2608    pub fn set_peg_offset_value(&mut self, val: Decimal, scale: i32) {
2609        self.message.body.set_field(tag::PEG_OFFSET_VALUE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
2610    }
2611
2612    /// Gets `PegOffsetValue`, Tag 211.
2613    pub fn get_peg_offset_value(&self) -> Result<Decimal, MessageRejectErrorEnum> {
2614        let mut fld = field::PegOffsetValueField::new(Decimal::ZERO, 0);
2615        self.message.body.get_field(tag::PEG_OFFSET_VALUE, &mut fld.0)?;
2616        Ok(fld.value())
2617    }
2618
2619
2620    /// Returns true if `PegOffsetValue` is present, Tag 211.
2621    pub fn has_peg_offset_value(&self) -> bool {
2622        self.message.body.has(tag::PEG_OFFSET_VALUE)
2623    }
2624
2625
2626
2627
2628    /// Sets `PegPriceType`, Tag 1094.
2629    pub fn set_peg_price_type(&mut self, v: isize) {
2630        self.message.body.set_field(tag::PEG_PRICE_TYPE, fixer::fix_int::FIXInt::from(v));
2631    }
2632
2633    /// Gets `PegPriceType`, Tag 1094.
2634    pub fn get_peg_price_type(&self) -> Result<isize, MessageRejectErrorEnum> {
2635        let mut fld = field::PegPriceTypeField::new(0);
2636        self.message.body.get_field(tag::PEG_PRICE_TYPE, &mut fld.0)?;
2637        Ok(fld.value())
2638    }
2639
2640
2641    /// Returns true if `PegPriceType` is present, Tag 1094.
2642    pub fn has_peg_price_type(&self) -> bool {
2643        self.message.body.has(tag::PEG_PRICE_TYPE)
2644    }
2645
2646
2647
2648
2649    /// Sets `PegRoundDirection`, Tag 838.
2650    pub fn set_peg_round_direction(&mut self, v: isize) {
2651        self.message.body.set_field(tag::PEG_ROUND_DIRECTION, fixer::fix_int::FIXInt::from(v));
2652    }
2653
2654    /// Gets `PegRoundDirection`, Tag 838.
2655    pub fn get_peg_round_direction(&self) -> Result<isize, MessageRejectErrorEnum> {
2656        let mut fld = field::PegRoundDirectionField::new(0);
2657        self.message.body.get_field(tag::PEG_ROUND_DIRECTION, &mut fld.0)?;
2658        Ok(fld.value())
2659    }
2660
2661
2662    /// Returns true if `PegRoundDirection` is present, Tag 838.
2663    pub fn has_peg_round_direction(&self) -> bool {
2664        self.message.body.has(tag::PEG_ROUND_DIRECTION)
2665    }
2666
2667
2668
2669
2670    /// Sets `PegScope`, Tag 840.
2671    pub fn set_peg_scope(&mut self, v: isize) {
2672        self.message.body.set_field(tag::PEG_SCOPE, fixer::fix_int::FIXInt::from(v));
2673    }
2674
2675    /// Gets `PegScope`, Tag 840.
2676    pub fn get_peg_scope(&self) -> Result<isize, MessageRejectErrorEnum> {
2677        let mut fld = field::PegScopeField::new(0);
2678        self.message.body.get_field(tag::PEG_SCOPE, &mut fld.0)?;
2679        Ok(fld.value())
2680    }
2681
2682
2683    /// Returns true if `PegScope` is present, Tag 840.
2684    pub fn has_peg_scope(&self) -> bool {
2685        self.message.body.has(tag::PEG_SCOPE)
2686    }
2687
2688
2689
2690
2691    /// Sets `PegSecurityDesc`, Tag 1099.
2692    pub fn set_peg_security_desc(&mut self, v: String) {
2693        self.message.body.set_field(tag::PEG_SECURITY_DESC, FIXString::from(v));
2694    }
2695
2696    /// Gets `PegSecurityDesc`, Tag 1099.
2697    pub fn get_peg_security_desc(&self) -> Result<String, MessageRejectErrorEnum> {
2698        let mut fld = field::PegSecurityDescField::new(String::new());
2699        self.message.body.get_field(tag::PEG_SECURITY_DESC, &mut fld.0)?;
2700        Ok(fld.value().to_string())
2701    }
2702
2703
2704    /// Returns true if `PegSecurityDesc` is present, Tag 1099.
2705    pub fn has_peg_security_desc(&self) -> bool {
2706        self.message.body.has(tag::PEG_SECURITY_DESC)
2707    }
2708
2709
2710
2711
2712    /// Sets `PegSecurityID`, Tag 1097.
2713    pub fn set_peg_security_id(&mut self, v: String) {
2714        self.message.body.set_field(tag::PEG_SECURITY_ID, FIXString::from(v));
2715    }
2716
2717    /// Gets `PegSecurityID`, Tag 1097.
2718    pub fn get_peg_security_id(&self) -> Result<String, MessageRejectErrorEnum> {
2719        let mut fld = field::PegSecurityIDField::new(String::new());
2720        self.message.body.get_field(tag::PEG_SECURITY_ID, &mut fld.0)?;
2721        Ok(fld.value().to_string())
2722    }
2723
2724
2725    /// Returns true if `PegSecurityID` is present, Tag 1097.
2726    pub fn has_peg_security_id(&self) -> bool {
2727        self.message.body.has(tag::PEG_SECURITY_ID)
2728    }
2729
2730
2731
2732
2733    /// Sets `PegSecurityIDSource`, Tag 1096.
2734    pub fn set_peg_security_id_source(&mut self, v: String) {
2735        self.message.body.set_field(tag::PEG_SECURITY_ID_SOURCE, FIXString::from(v));
2736    }
2737
2738    /// Gets `PegSecurityIDSource`, Tag 1096.
2739    pub fn get_peg_security_id_source(&self) -> Result<String, MessageRejectErrorEnum> {
2740        let mut fld = field::PegSecurityIDSourceField::new(String::new());
2741        self.message.body.get_field(tag::PEG_SECURITY_ID_SOURCE, &mut fld.0)?;
2742        Ok(fld.value().to_string())
2743    }
2744
2745
2746    /// Returns true if `PegSecurityIDSource` is present, Tag 1096.
2747    pub fn has_peg_security_id_source(&self) -> bool {
2748        self.message.body.has(tag::PEG_SECURITY_ID_SOURCE)
2749    }
2750
2751
2752
2753
2754    /// Sets `PegSymbol`, Tag 1098.
2755    pub fn set_peg_symbol(&mut self, v: String) {
2756        self.message.body.set_field(tag::PEG_SYMBOL, FIXString::from(v));
2757    }
2758
2759    /// Gets `PegSymbol`, Tag 1098.
2760    pub fn get_peg_symbol(&self) -> Result<String, MessageRejectErrorEnum> {
2761        let mut fld = field::PegSymbolField::new(String::new());
2762        self.message.body.get_field(tag::PEG_SYMBOL, &mut fld.0)?;
2763        Ok(fld.value().to_string())
2764    }
2765
2766
2767    /// Returns true if `PegSymbol` is present, Tag 1098.
2768    pub fn has_peg_symbol(&self) -> bool {
2769        self.message.body.has(tag::PEG_SYMBOL)
2770    }
2771
2772
2773
2774
2775    /// Sets `Pool`, Tag 691.
2776    pub fn set_pool(&mut self, v: String) {
2777        self.message.body.set_field(tag::POOL, FIXString::from(v));
2778    }
2779
2780    /// Gets `Pool`, Tag 691.
2781    pub fn get_pool(&self) -> Result<String, MessageRejectErrorEnum> {
2782        let mut fld = field::PoolField::new(String::new());
2783        self.message.body.get_field(tag::POOL, &mut fld.0)?;
2784        Ok(fld.value().to_string())
2785    }
2786
2787
2788    /// Returns true if `Pool` is present, Tag 691.
2789    pub fn has_pool(&self) -> bool {
2790        self.message.body.has(tag::POOL)
2791    }
2792
2793
2794
2795
2796    /// Sets `PositionEffect`, Tag 77.
2797    pub fn set_position_effect(&mut self, v: String) {
2798        self.message.body.set_field(tag::POSITION_EFFECT, FIXString::from(v));
2799    }
2800
2801    /// Gets `PositionEffect`, Tag 77.
2802    pub fn get_position_effect(&self) -> Result<String, MessageRejectErrorEnum> {
2803        let mut fld = field::PositionEffectField::new(String::new());
2804        self.message.body.get_field(tag::POSITION_EFFECT, &mut fld.0)?;
2805        Ok(fld.value().to_string())
2806    }
2807
2808
2809    /// Returns true if `PositionEffect` is present, Tag 77.
2810    pub fn has_position_effect(&self) -> bool {
2811        self.message.body.has(tag::POSITION_EFFECT)
2812    }
2813
2814
2815
2816
2817    /// Sets `PositionLimit`, Tag 970.
2818    pub fn set_position_limit(&mut self, v: isize) {
2819        self.message.body.set_field(tag::POSITION_LIMIT, fixer::fix_int::FIXInt::from(v));
2820    }
2821
2822    /// Gets `PositionLimit`, Tag 970.
2823    pub fn get_position_limit(&self) -> Result<isize, MessageRejectErrorEnum> {
2824        let mut fld = field::PositionLimitField::new(0);
2825        self.message.body.get_field(tag::POSITION_LIMIT, &mut fld.0)?;
2826        Ok(fld.value())
2827    }
2828
2829
2830    /// Returns true if `PositionLimit` is present, Tag 970.
2831    pub fn has_position_limit(&self) -> bool {
2832        self.message.body.has(tag::POSITION_LIMIT)
2833    }
2834
2835
2836
2837
2838    /// Sets `PreTradeAnonymity`, Tag 1091.
2839    pub fn set_pre_trade_anonymity(&mut self, v: bool) {
2840        self.message.body.set_field(tag::PRE_TRADE_ANONYMITY, fixer::fix_boolean::FIXBoolean::from(v));
2841    }
2842
2843    /// Gets `PreTradeAnonymity`, Tag 1091.
2844    pub fn get_pre_trade_anonymity(&self) -> Result<bool, MessageRejectErrorEnum> {
2845        let mut fld = field::PreTradeAnonymityField::new(false);
2846        self.message.body.get_field(tag::PRE_TRADE_ANONYMITY, &mut fld.0)?;
2847        Ok(fld.value())
2848    }
2849
2850
2851    /// Returns true if `PreTradeAnonymity` is present, Tag 1091.
2852    pub fn has_pre_trade_anonymity(&self) -> bool {
2853        self.message.body.has(tag::PRE_TRADE_ANONYMITY)
2854    }
2855
2856
2857
2858
2859    /// Sets `PreallocMethod`, Tag 591.
2860    pub fn set_prealloc_method(&mut self, v: String) {
2861        self.message.body.set_field(tag::PREALLOC_METHOD, FIXString::from(v));
2862    }
2863
2864    /// Gets `PreallocMethod`, Tag 591.
2865    pub fn get_prealloc_method(&self) -> Result<String, MessageRejectErrorEnum> {
2866        let mut fld = field::PreallocMethodField::new(String::new());
2867        self.message.body.get_field(tag::PREALLOC_METHOD, &mut fld.0)?;
2868        Ok(fld.value().to_string())
2869    }
2870
2871
2872    /// Returns true if `PreallocMethod` is present, Tag 591.
2873    pub fn has_prealloc_method(&self) -> bool {
2874        self.message.body.has(tag::PREALLOC_METHOD)
2875    }
2876
2877
2878
2879
2880    /// Sets `Price`, Tag 44.
2881    pub fn set_price(&mut self, val: Decimal, scale: i32) {
2882        self.message.body.set_field(tag::PRICE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
2883    }
2884
2885    /// Gets `Price`, Tag 44.
2886    pub fn get_price(&self) -> Result<Decimal, MessageRejectErrorEnum> {
2887        let mut fld = field::PriceField::new(Decimal::ZERO, 0);
2888        self.message.body.get_field(tag::PRICE, &mut fld.0)?;
2889        Ok(fld.value())
2890    }
2891
2892
2893    /// Returns true if `Price` is present, Tag 44.
2894    pub fn has_price(&self) -> bool {
2895        self.message.body.has(tag::PRICE)
2896    }
2897
2898
2899
2900
2901    /// Sets `Price2`, Tag 640.
2902    pub fn set_price2(&mut self, val: Decimal, scale: i32) {
2903        self.message.body.set_field(tag::PRICE2, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
2904    }
2905
2906    /// Gets `Price2`, Tag 640.
2907    pub fn get_price2(&self) -> Result<Decimal, MessageRejectErrorEnum> {
2908        let mut fld = field::Price2Field::new(Decimal::ZERO, 0);
2909        self.message.body.get_field(tag::PRICE2, &mut fld.0)?;
2910        Ok(fld.value())
2911    }
2912
2913
2914    /// Returns true if `Price2` is present, Tag 640.
2915    pub fn has_price2(&self) -> bool {
2916        self.message.body.has(tag::PRICE2)
2917    }
2918
2919
2920
2921
2922    /// Sets `PriceProtectionScope`, Tag 1092.
2923    pub fn set_price_protection_scope(&mut self, v: String) {
2924        self.message.body.set_field(tag::PRICE_PROTECTION_SCOPE, FIXString::from(v));
2925    }
2926
2927    /// Gets `PriceProtectionScope`, Tag 1092.
2928    pub fn get_price_protection_scope(&self) -> Result<String, MessageRejectErrorEnum> {
2929        let mut fld = field::PriceProtectionScopeField::new(String::new());
2930        self.message.body.get_field(tag::PRICE_PROTECTION_SCOPE, &mut fld.0)?;
2931        Ok(fld.value().to_string())
2932    }
2933
2934
2935    /// Returns true if `PriceProtectionScope` is present, Tag 1092.
2936    pub fn has_price_protection_scope(&self) -> bool {
2937        self.message.body.has(tag::PRICE_PROTECTION_SCOPE)
2938    }
2939
2940
2941
2942
2943    /// Sets `PriceType`, Tag 423.
2944    pub fn set_price_type(&mut self, v: isize) {
2945        self.message.body.set_field(tag::PRICE_TYPE, fixer::fix_int::FIXInt::from(v));
2946    }
2947
2948    /// Gets `PriceType`, Tag 423.
2949    pub fn get_price_type(&self) -> Result<isize, MessageRejectErrorEnum> {
2950        let mut fld = field::PriceTypeField::new(0);
2951        self.message.body.get_field(tag::PRICE_TYPE, &mut fld.0)?;
2952        Ok(fld.value())
2953    }
2954
2955
2956    /// Returns true if `PriceType` is present, Tag 423.
2957    pub fn has_price_type(&self) -> bool {
2958        self.message.body.has(tag::PRICE_TYPE)
2959    }
2960
2961
2962
2963
2964    /// Sets `Product`, Tag 460.
2965    pub fn set_product(&mut self, v: isize) {
2966        self.message.body.set_field(tag::PRODUCT, fixer::fix_int::FIXInt::from(v));
2967    }
2968
2969    /// Gets `Product`, Tag 460.
2970    pub fn get_product(&self) -> Result<isize, MessageRejectErrorEnum> {
2971        let mut fld = field::ProductField::new(0);
2972        self.message.body.get_field(tag::PRODUCT, &mut fld.0)?;
2973        Ok(fld.value())
2974    }
2975
2976
2977    /// Returns true if `Product` is present, Tag 460.
2978    pub fn has_product(&self) -> bool {
2979        self.message.body.has(tag::PRODUCT)
2980    }
2981
2982
2983
2984
2985    /// Sets `QtyType`, Tag 854.
2986    pub fn set_qty_type(&mut self, v: isize) {
2987        self.message.body.set_field(tag::QTY_TYPE, fixer::fix_int::FIXInt::from(v));
2988    }
2989
2990    /// Gets `QtyType`, Tag 854.
2991    pub fn get_qty_type(&self) -> Result<isize, MessageRejectErrorEnum> {
2992        let mut fld = field::QtyTypeField::new(0);
2993        self.message.body.get_field(tag::QTY_TYPE, &mut fld.0)?;
2994        Ok(fld.value())
2995    }
2996
2997
2998    /// Returns true if `QtyType` is present, Tag 854.
2999    pub fn has_qty_type(&self) -> bool {
3000        self.message.body.has(tag::QTY_TYPE)
3001    }
3002
3003
3004
3005
3006    /// Sets `ReceivedDeptID`, Tag 1030.
3007    pub fn set_received_dept_id(&mut self, v: String) {
3008        self.message.body.set_field(tag::RECEIVED_DEPT_ID, FIXString::from(v));
3009    }
3010
3011    /// Gets `ReceivedDeptID`, Tag 1030.
3012    pub fn get_received_dept_id(&self) -> Result<String, MessageRejectErrorEnum> {
3013        let mut fld = field::ReceivedDeptIDField::new(String::new());
3014        self.message.body.get_field(tag::RECEIVED_DEPT_ID, &mut fld.0)?;
3015        Ok(fld.value().to_string())
3016    }
3017
3018
3019    /// Returns true if `ReceivedDeptID` is present, Tag 1030.
3020    pub fn has_received_dept_id(&self) -> bool {
3021        self.message.body.has(tag::RECEIVED_DEPT_ID)
3022    }
3023
3024
3025
3026
3027    /// Sets `RedemptionDate`, Tag 240.
3028    pub fn set_redemption_date(&mut self, v: String) {
3029        self.message.body.set_field(tag::REDEMPTION_DATE, FIXString::from(v));
3030    }
3031
3032    /// Gets `RedemptionDate`, Tag 240.
3033    pub fn get_redemption_date(&self) -> Result<String, MessageRejectErrorEnum> {
3034        let mut fld = field::RedemptionDateField::new(String::new());
3035        self.message.body.get_field(tag::REDEMPTION_DATE, &mut fld.0)?;
3036        Ok(fld.value().to_string())
3037    }
3038
3039
3040    /// Returns true if `RedemptionDate` is present, Tag 240.
3041    pub fn has_redemption_date(&self) -> bool {
3042        self.message.body.has(tag::REDEMPTION_DATE)
3043    }
3044
3045
3046
3047
3048    /// Sets `RefreshQty`, Tag 1088.
3049    pub fn set_refresh_qty(&mut self, val: Decimal, scale: i32) {
3050        self.message.body.set_field(tag::REFRESH_QTY, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
3051    }
3052
3053    /// Gets `RefreshQty`, Tag 1088.
3054    pub fn get_refresh_qty(&self) -> Result<Decimal, MessageRejectErrorEnum> {
3055        let mut fld = field::RefreshQtyField::new(Decimal::ZERO, 0);
3056        self.message.body.get_field(tag::REFRESH_QTY, &mut fld.0)?;
3057        Ok(fld.value())
3058    }
3059
3060
3061    /// Returns true if `RefreshQty` is present, Tag 1088.
3062    pub fn has_refresh_qty(&self) -> bool {
3063        self.message.body.has(tag::REFRESH_QTY)
3064    }
3065
3066
3067
3068
3069    /// Sets `RegistID`, Tag 513.
3070    pub fn set_regist_id(&mut self, v: String) {
3071        self.message.body.set_field(tag::REGIST_ID, FIXString::from(v));
3072    }
3073
3074    /// Gets `RegistID`, Tag 513.
3075    pub fn get_regist_id(&self) -> Result<String, MessageRejectErrorEnum> {
3076        let mut fld = field::RegistIDField::new(String::new());
3077        self.message.body.get_field(tag::REGIST_ID, &mut fld.0)?;
3078        Ok(fld.value().to_string())
3079    }
3080
3081
3082    /// Returns true if `RegistID` is present, Tag 513.
3083    pub fn has_regist_id(&self) -> bool {
3084        self.message.body.has(tag::REGIST_ID)
3085    }
3086
3087
3088
3089
3090    /// Sets `RepoCollateralSecurityType`, Tag 239.
3091    pub fn set_repo_collateral_security_type(&mut self, v: isize) {
3092        self.message.body.set_field(tag::REPO_COLLATERAL_SECURITY_TYPE, fixer::fix_int::FIXInt::from(v));
3093    }
3094
3095    /// Gets `RepoCollateralSecurityType`, Tag 239.
3096    pub fn get_repo_collateral_security_type(&self) -> Result<isize, MessageRejectErrorEnum> {
3097        let mut fld = field::RepoCollateralSecurityTypeField::new(0);
3098        self.message.body.get_field(tag::REPO_COLLATERAL_SECURITY_TYPE, &mut fld.0)?;
3099        Ok(fld.value())
3100    }
3101
3102
3103    /// Returns true if `RepoCollateralSecurityType` is present, Tag 239.
3104    pub fn has_repo_collateral_security_type(&self) -> bool {
3105        self.message.body.has(tag::REPO_COLLATERAL_SECURITY_TYPE)
3106    }
3107
3108
3109
3110
3111    /// Sets `RepurchaseRate`, Tag 227.
3112    pub fn set_repurchase_rate(&mut self, val: Decimal, scale: i32) {
3113        self.message.body.set_field(tag::REPURCHASE_RATE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
3114    }
3115
3116    /// Gets `RepurchaseRate`, Tag 227.
3117    pub fn get_repurchase_rate(&self) -> Result<Decimal, MessageRejectErrorEnum> {
3118        let mut fld = field::RepurchaseRateField::new(Decimal::ZERO, 0);
3119        self.message.body.get_field(tag::REPURCHASE_RATE, &mut fld.0)?;
3120        Ok(fld.value())
3121    }
3122
3123
3124    /// Returns true if `RepurchaseRate` is present, Tag 227.
3125    pub fn has_repurchase_rate(&self) -> bool {
3126        self.message.body.has(tag::REPURCHASE_RATE)
3127    }
3128
3129
3130
3131
3132    /// Sets `RepurchaseTerm`, Tag 226.
3133    pub fn set_repurchase_term(&mut self, v: isize) {
3134        self.message.body.set_field(tag::REPURCHASE_TERM, fixer::fix_int::FIXInt::from(v));
3135    }
3136
3137    /// Gets `RepurchaseTerm`, Tag 226.
3138    pub fn get_repurchase_term(&self) -> Result<isize, MessageRejectErrorEnum> {
3139        let mut fld = field::RepurchaseTermField::new(0);
3140        self.message.body.get_field(tag::REPURCHASE_TERM, &mut fld.0)?;
3141        Ok(fld.value())
3142    }
3143
3144
3145    /// Returns true if `RepurchaseTerm` is present, Tag 226.
3146    pub fn has_repurchase_term(&self) -> bool {
3147        self.message.body.has(tag::REPURCHASE_TERM)
3148    }
3149
3150
3151
3152
3153    /// Sets `RoundingDirection`, Tag 468.
3154    pub fn set_rounding_direction(&mut self, v: String) {
3155        self.message.body.set_field(tag::ROUNDING_DIRECTION, FIXString::from(v));
3156    }
3157
3158    /// Gets `RoundingDirection`, Tag 468.
3159    pub fn get_rounding_direction(&self) -> Result<String, MessageRejectErrorEnum> {
3160        let mut fld = field::RoundingDirectionField::new(String::new());
3161        self.message.body.get_field(tag::ROUNDING_DIRECTION, &mut fld.0)?;
3162        Ok(fld.value().to_string())
3163    }
3164
3165
3166    /// Returns true if `RoundingDirection` is present, Tag 468.
3167    pub fn has_rounding_direction(&self) -> bool {
3168        self.message.body.has(tag::ROUNDING_DIRECTION)
3169    }
3170
3171
3172
3173
3174    /// Sets `RoundingModulus`, Tag 469.
3175    pub fn set_rounding_modulus(&mut self, val: Decimal, scale: i32) {
3176        self.message.body.set_field(tag::ROUNDING_MODULUS, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
3177    }
3178
3179    /// Gets `RoundingModulus`, Tag 469.
3180    pub fn get_rounding_modulus(&self) -> Result<Decimal, MessageRejectErrorEnum> {
3181        let mut fld = field::RoundingModulusField::new(Decimal::ZERO, 0);
3182        self.message.body.get_field(tag::ROUNDING_MODULUS, &mut fld.0)?;
3183        Ok(fld.value())
3184    }
3185
3186
3187    /// Returns true if `RoundingModulus` is present, Tag 469.
3188    pub fn has_rounding_modulus(&self) -> bool {
3189        self.message.body.has(tag::ROUNDING_MODULUS)
3190    }
3191
3192
3193
3194
3195    /// Sets `SecondaryClOrdID`, Tag 526.
3196    pub fn set_secondary_cl_ord_id(&mut self, v: String) {
3197        self.message.body.set_field(tag::SECONDARY_CL_ORD_ID, FIXString::from(v));
3198    }
3199
3200    /// Gets `SecondaryClOrdID`, Tag 526.
3201    pub fn get_secondary_cl_ord_id(&self) -> Result<String, MessageRejectErrorEnum> {
3202        let mut fld = field::SecondaryClOrdIDField::new(String::new());
3203        self.message.body.get_field(tag::SECONDARY_CL_ORD_ID, &mut fld.0)?;
3204        Ok(fld.value().to_string())
3205    }
3206
3207
3208    /// Returns true if `SecondaryClOrdID` is present, Tag 526.
3209    pub fn has_secondary_cl_ord_id(&self) -> bool {
3210        self.message.body.has(tag::SECONDARY_CL_ORD_ID)
3211    }
3212
3213
3214
3215
3216    /// Sets `SecondaryDisplayQty`, Tag 1082.
3217    pub fn set_secondary_display_qty(&mut self, val: Decimal, scale: i32) {
3218        self.message.body.set_field(tag::SECONDARY_DISPLAY_QTY, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
3219    }
3220
3221    /// Gets `SecondaryDisplayQty`, Tag 1082.
3222    pub fn get_secondary_display_qty(&self) -> Result<Decimal, MessageRejectErrorEnum> {
3223        let mut fld = field::SecondaryDisplayQtyField::new(Decimal::ZERO, 0);
3224        self.message.body.get_field(tag::SECONDARY_DISPLAY_QTY, &mut fld.0)?;
3225        Ok(fld.value())
3226    }
3227
3228
3229    /// Returns true if `SecondaryDisplayQty` is present, Tag 1082.
3230    pub fn has_secondary_display_qty(&self) -> bool {
3231        self.message.body.has(tag::SECONDARY_DISPLAY_QTY)
3232    }
3233
3234
3235
3236
3237    /// Sets `SecurityDesc`, Tag 107.
3238    pub fn set_security_desc(&mut self, v: String) {
3239        self.message.body.set_field(tag::SECURITY_DESC, FIXString::from(v));
3240    }
3241
3242    /// Gets `SecurityDesc`, Tag 107.
3243    pub fn get_security_desc(&self) -> Result<String, MessageRejectErrorEnum> {
3244        let mut fld = field::SecurityDescField::new(String::new());
3245        self.message.body.get_field(tag::SECURITY_DESC, &mut fld.0)?;
3246        Ok(fld.value().to_string())
3247    }
3248
3249
3250    /// Returns true if `SecurityDesc` is present, Tag 107.
3251    pub fn has_security_desc(&self) -> bool {
3252        self.message.body.has(tag::SECURITY_DESC)
3253    }
3254
3255
3256
3257
3258    /// Sets `SecurityExchange`, Tag 207.
3259    pub fn set_security_exchange(&mut self, v: String) {
3260        self.message.body.set_field(tag::SECURITY_EXCHANGE, FIXString::from(v));
3261    }
3262
3263    /// Gets `SecurityExchange`, Tag 207.
3264    pub fn get_security_exchange(&self) -> Result<String, MessageRejectErrorEnum> {
3265        let mut fld = field::SecurityExchangeField::new(String::new());
3266        self.message.body.get_field(tag::SECURITY_EXCHANGE, &mut fld.0)?;
3267        Ok(fld.value().to_string())
3268    }
3269
3270
3271    /// Returns true if `SecurityExchange` is present, Tag 207.
3272    pub fn has_security_exchange(&self) -> bool {
3273        self.message.body.has(tag::SECURITY_EXCHANGE)
3274    }
3275
3276
3277
3278
3279    /// Sets `SecurityID`, Tag 48.
3280    pub fn set_security_id(&mut self, v: String) {
3281        self.message.body.set_field(tag::SECURITY_ID, FIXString::from(v));
3282    }
3283
3284    /// Gets `SecurityID`, Tag 48.
3285    pub fn get_security_id(&self) -> Result<String, MessageRejectErrorEnum> {
3286        let mut fld = field::SecurityIDField::new(String::new());
3287        self.message.body.get_field(tag::SECURITY_ID, &mut fld.0)?;
3288        Ok(fld.value().to_string())
3289    }
3290
3291
3292    /// Returns true if `SecurityID` is present, Tag 48.
3293    pub fn has_security_id(&self) -> bool {
3294        self.message.body.has(tag::SECURITY_ID)
3295    }
3296
3297
3298
3299
3300    /// Sets `SecurityIDSource`, Tag 22.
3301    pub fn set_security_id_source(&mut self, v: String) {
3302        self.message.body.set_field(tag::SECURITY_ID_SOURCE, FIXString::from(v));
3303    }
3304
3305    /// Gets `SecurityIDSource`, Tag 22.
3306    pub fn get_security_id_source(&self) -> Result<String, MessageRejectErrorEnum> {
3307        let mut fld = field::SecurityIDSourceField::new(String::new());
3308        self.message.body.get_field(tag::SECURITY_ID_SOURCE, &mut fld.0)?;
3309        Ok(fld.value().to_string())
3310    }
3311
3312
3313    /// Returns true if `SecurityIDSource` is present, Tag 22.
3314    pub fn has_security_id_source(&self) -> bool {
3315        self.message.body.has(tag::SECURITY_ID_SOURCE)
3316    }
3317
3318
3319
3320
3321    /// Sets `SecurityStatus`, Tag 965.
3322    pub fn set_security_status(&mut self, v: String) {
3323        self.message.body.set_field(tag::SECURITY_STATUS, FIXString::from(v));
3324    }
3325
3326    /// Gets `SecurityStatus`, Tag 965.
3327    pub fn get_security_status(&self) -> Result<String, MessageRejectErrorEnum> {
3328        let mut fld = field::SecurityStatusField::new(String::new());
3329        self.message.body.get_field(tag::SECURITY_STATUS, &mut fld.0)?;
3330        Ok(fld.value().to_string())
3331    }
3332
3333
3334    /// Returns true if `SecurityStatus` is present, Tag 965.
3335    pub fn has_security_status(&self) -> bool {
3336        self.message.body.has(tag::SECURITY_STATUS)
3337    }
3338
3339
3340
3341
3342    /// Sets `SecuritySubType`, Tag 762.
3343    pub fn set_security_sub_type(&mut self, v: String) {
3344        self.message.body.set_field(tag::SECURITY_SUB_TYPE, FIXString::from(v));
3345    }
3346
3347    /// Gets `SecuritySubType`, Tag 762.
3348    pub fn get_security_sub_type(&self) -> Result<String, MessageRejectErrorEnum> {
3349        let mut fld = field::SecuritySubTypeField::new(String::new());
3350        self.message.body.get_field(tag::SECURITY_SUB_TYPE, &mut fld.0)?;
3351        Ok(fld.value().to_string())
3352    }
3353
3354
3355    /// Returns true if `SecuritySubType` is present, Tag 762.
3356    pub fn has_security_sub_type(&self) -> bool {
3357        self.message.body.has(tag::SECURITY_SUB_TYPE)
3358    }
3359
3360
3361
3362
3363    /// Sets `SecurityType`, Tag 167.
3364    pub fn set_security_type(&mut self, v: String) {
3365        self.message.body.set_field(tag::SECURITY_TYPE, FIXString::from(v));
3366    }
3367
3368    /// Gets `SecurityType`, Tag 167.
3369    pub fn get_security_type(&self) -> Result<String, MessageRejectErrorEnum> {
3370        let mut fld = field::SecurityTypeField::new(String::new());
3371        self.message.body.get_field(tag::SECURITY_TYPE, &mut fld.0)?;
3372        Ok(fld.value().to_string())
3373    }
3374
3375
3376    /// Returns true if `SecurityType` is present, Tag 167.
3377    pub fn has_security_type(&self) -> bool {
3378        self.message.body.has(tag::SECURITY_TYPE)
3379    }
3380
3381
3382
3383
3384    /// Sets `SettlCurrency`, Tag 120.
3385    pub fn set_settl_currency(&mut self, v: String) {
3386        self.message.body.set_field(tag::SETTL_CURRENCY, FIXString::from(v));
3387    }
3388
3389    /// Gets `SettlCurrency`, Tag 120.
3390    pub fn get_settl_currency(&self) -> Result<String, MessageRejectErrorEnum> {
3391        let mut fld = field::SettlCurrencyField::new(String::new());
3392        self.message.body.get_field(tag::SETTL_CURRENCY, &mut fld.0)?;
3393        Ok(fld.value().to_string())
3394    }
3395
3396
3397    /// Returns true if `SettlCurrency` is present, Tag 120.
3398    pub fn has_settl_currency(&self) -> bool {
3399        self.message.body.has(tag::SETTL_CURRENCY)
3400    }
3401
3402
3403
3404
3405    /// Sets `SettlDate`, Tag 64.
3406    pub fn set_settl_date(&mut self, v: String) {
3407        self.message.body.set_field(tag::SETTL_DATE, FIXString::from(v));
3408    }
3409
3410    /// Gets `SettlDate`, Tag 64.
3411    pub fn get_settl_date(&self) -> Result<String, MessageRejectErrorEnum> {
3412        let mut fld = field::SettlDateField::new(String::new());
3413        self.message.body.get_field(tag::SETTL_DATE, &mut fld.0)?;
3414        Ok(fld.value().to_string())
3415    }
3416
3417
3418    /// Returns true if `SettlDate` is present, Tag 64.
3419    pub fn has_settl_date(&self) -> bool {
3420        self.message.body.has(tag::SETTL_DATE)
3421    }
3422
3423
3424
3425
3426    /// Sets `SettlDate2`, Tag 193.
3427    pub fn set_settl_date2(&mut self, v: String) {
3428        self.message.body.set_field(tag::SETTL_DATE2, FIXString::from(v));
3429    }
3430
3431    /// Gets `SettlDate2`, Tag 193.
3432    pub fn get_settl_date2(&self) -> Result<String, MessageRejectErrorEnum> {
3433        let mut fld = field::SettlDate2Field::new(String::new());
3434        self.message.body.get_field(tag::SETTL_DATE2, &mut fld.0)?;
3435        Ok(fld.value().to_string())
3436    }
3437
3438
3439    /// Returns true if `SettlDate2` is present, Tag 193.
3440    pub fn has_settl_date2(&self) -> bool {
3441        self.message.body.has(tag::SETTL_DATE2)
3442    }
3443
3444
3445
3446
3447    /// Sets `SettlType`, Tag 63.
3448    pub fn set_settl_type(&mut self, v: String) {
3449        self.message.body.set_field(tag::SETTL_TYPE, FIXString::from(v));
3450    }
3451
3452    /// Gets `SettlType`, Tag 63.
3453    pub fn get_settl_type(&self) -> Result<String, MessageRejectErrorEnum> {
3454        let mut fld = field::SettlTypeField::new(String::new());
3455        self.message.body.get_field(tag::SETTL_TYPE, &mut fld.0)?;
3456        Ok(fld.value().to_string())
3457    }
3458
3459
3460    /// Returns true if `SettlType` is present, Tag 63.
3461    pub fn has_settl_type(&self) -> bool {
3462        self.message.body.has(tag::SETTL_TYPE)
3463    }
3464
3465
3466
3467
3468    /// Sets `SettleOnOpenFlag`, Tag 966.
3469    pub fn set_settle_on_open_flag(&mut self, v: String) {
3470        self.message.body.set_field(tag::SETTLE_ON_OPEN_FLAG, FIXString::from(v));
3471    }
3472
3473    /// Gets `SettleOnOpenFlag`, Tag 966.
3474    pub fn get_settle_on_open_flag(&self) -> Result<String, MessageRejectErrorEnum> {
3475        let mut fld = field::SettleOnOpenFlagField::new(String::new());
3476        self.message.body.get_field(tag::SETTLE_ON_OPEN_FLAG, &mut fld.0)?;
3477        Ok(fld.value().to_string())
3478    }
3479
3480
3481    /// Returns true if `SettleOnOpenFlag` is present, Tag 966.
3482    pub fn has_settle_on_open_flag(&self) -> bool {
3483        self.message.body.has(tag::SETTLE_ON_OPEN_FLAG)
3484    }
3485
3486
3487
3488
3489    /// Sets `Side`, Tag 54.
3490    pub fn set_side(&mut self, v: String) {
3491        self.message.body.set_field(tag::SIDE, FIXString::from(v));
3492    }
3493
3494    /// Gets `Side`, Tag 54.
3495    pub fn get_side(&self) -> Result<String, MessageRejectErrorEnum> {
3496        let mut fld = field::SideField::new(String::new());
3497        self.message.body.get_field(tag::SIDE, &mut fld.0)?;
3498        Ok(fld.value().to_string())
3499    }
3500
3501
3502    /// Returns true if `Side` is present, Tag 54.
3503    pub fn has_side(&self) -> bool {
3504        self.message.body.has(tag::SIDE)
3505    }
3506
3507
3508
3509
3510    /// Sets `SolicitedFlag`, Tag 377.
3511    pub fn set_solicited_flag(&mut self, v: bool) {
3512        self.message.body.set_field(tag::SOLICITED_FLAG, fixer::fix_boolean::FIXBoolean::from(v));
3513    }
3514
3515    /// Gets `SolicitedFlag`, Tag 377.
3516    pub fn get_solicited_flag(&self) -> Result<bool, MessageRejectErrorEnum> {
3517        let mut fld = field::SolicitedFlagField::new(false);
3518        self.message.body.get_field(tag::SOLICITED_FLAG, &mut fld.0)?;
3519        Ok(fld.value())
3520    }
3521
3522
3523    /// Returns true if `SolicitedFlag` is present, Tag 377.
3524    pub fn has_solicited_flag(&self) -> bool {
3525        self.message.body.has(tag::SOLICITED_FLAG)
3526    }
3527
3528
3529
3530
3531    /// Sets `Spread`, Tag 218.
3532    pub fn set_spread(&mut self, val: Decimal, scale: i32) {
3533        self.message.body.set_field(tag::SPREAD, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
3534    }
3535
3536    /// Gets `Spread`, Tag 218.
3537    pub fn get_spread(&self) -> Result<Decimal, MessageRejectErrorEnum> {
3538        let mut fld = field::SpreadField::new(Decimal::ZERO, 0);
3539        self.message.body.get_field(tag::SPREAD, &mut fld.0)?;
3540        Ok(fld.value())
3541    }
3542
3543
3544    /// Returns true if `Spread` is present, Tag 218.
3545    pub fn has_spread(&self) -> bool {
3546        self.message.body.has(tag::SPREAD)
3547    }
3548
3549
3550
3551
3552    /// Sets `StartDate`, Tag 916.
3553    pub fn set_start_date(&mut self, v: String) {
3554        self.message.body.set_field(tag::START_DATE, FIXString::from(v));
3555    }
3556
3557    /// Gets `StartDate`, Tag 916.
3558    pub fn get_start_date(&self) -> Result<String, MessageRejectErrorEnum> {
3559        let mut fld = field::StartDateField::new(String::new());
3560        self.message.body.get_field(tag::START_DATE, &mut fld.0)?;
3561        Ok(fld.value().to_string())
3562    }
3563
3564
3565    /// Returns true if `StartDate` is present, Tag 916.
3566    pub fn has_start_date(&self) -> bool {
3567        self.message.body.has(tag::START_DATE)
3568    }
3569
3570
3571
3572
3573    /// Sets `StateOrProvinceOfIssue`, Tag 471.
3574    pub fn set_state_or_province_of_issue(&mut self, v: String) {
3575        self.message.body.set_field(tag::STATE_OR_PROVINCE_OF_ISSUE, FIXString::from(v));
3576    }
3577
3578    /// Gets `StateOrProvinceOfIssue`, Tag 471.
3579    pub fn get_state_or_province_of_issue(&self) -> Result<String, MessageRejectErrorEnum> {
3580        let mut fld = field::StateOrProvinceOfIssueField::new(String::new());
3581        self.message.body.get_field(tag::STATE_OR_PROVINCE_OF_ISSUE, &mut fld.0)?;
3582        Ok(fld.value().to_string())
3583    }
3584
3585
3586    /// Returns true if `StateOrProvinceOfIssue` is present, Tag 471.
3587    pub fn has_state_or_province_of_issue(&self) -> bool {
3588        self.message.body.has(tag::STATE_OR_PROVINCE_OF_ISSUE)
3589    }
3590
3591
3592
3593
3594    /// Sets `StopPx`, Tag 99.
3595    pub fn set_stop_px(&mut self, val: Decimal, scale: i32) {
3596        self.message.body.set_field(tag::STOP_PX, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
3597    }
3598
3599    /// Gets `StopPx`, Tag 99.
3600    pub fn get_stop_px(&self) -> Result<Decimal, MessageRejectErrorEnum> {
3601        let mut fld = field::StopPxField::new(Decimal::ZERO, 0);
3602        self.message.body.get_field(tag::STOP_PX, &mut fld.0)?;
3603        Ok(fld.value())
3604    }
3605
3606
3607    /// Returns true if `StopPx` is present, Tag 99.
3608    pub fn has_stop_px(&self) -> bool {
3609        self.message.body.has(tag::STOP_PX)
3610    }
3611
3612
3613
3614
3615    /// Sets `StrikeCurrency`, Tag 947.
3616    pub fn set_strike_currency(&mut self, v: String) {
3617        self.message.body.set_field(tag::STRIKE_CURRENCY, FIXString::from(v));
3618    }
3619
3620    /// Gets `StrikeCurrency`, Tag 947.
3621    pub fn get_strike_currency(&self) -> Result<String, MessageRejectErrorEnum> {
3622        let mut fld = field::StrikeCurrencyField::new(String::new());
3623        self.message.body.get_field(tag::STRIKE_CURRENCY, &mut fld.0)?;
3624        Ok(fld.value().to_string())
3625    }
3626
3627
3628    /// Returns true if `StrikeCurrency` is present, Tag 947.
3629    pub fn has_strike_currency(&self) -> bool {
3630        self.message.body.has(tag::STRIKE_CURRENCY)
3631    }
3632
3633
3634
3635
3636    /// Sets `StrikeMultiplier`, Tag 967.
3637    pub fn set_strike_multiplier(&mut self, val: Decimal, scale: i32) {
3638        self.message.body.set_field(tag::STRIKE_MULTIPLIER, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
3639    }
3640
3641    /// Gets `StrikeMultiplier`, Tag 967.
3642    pub fn get_strike_multiplier(&self) -> Result<Decimal, MessageRejectErrorEnum> {
3643        let mut fld = field::StrikeMultiplierField::new(Decimal::ZERO, 0);
3644        self.message.body.get_field(tag::STRIKE_MULTIPLIER, &mut fld.0)?;
3645        Ok(fld.value())
3646    }
3647
3648
3649    /// Returns true if `StrikeMultiplier` is present, Tag 967.
3650    pub fn has_strike_multiplier(&self) -> bool {
3651        self.message.body.has(tag::STRIKE_MULTIPLIER)
3652    }
3653
3654
3655
3656
3657    /// Sets `StrikePrice`, Tag 202.
3658    pub fn set_strike_price(&mut self, val: Decimal, scale: i32) {
3659        self.message.body.set_field(tag::STRIKE_PRICE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
3660    }
3661
3662    /// Gets `StrikePrice`, Tag 202.
3663    pub fn get_strike_price(&self) -> Result<Decimal, MessageRejectErrorEnum> {
3664        let mut fld = field::StrikePriceField::new(Decimal::ZERO, 0);
3665        self.message.body.get_field(tag::STRIKE_PRICE, &mut fld.0)?;
3666        Ok(fld.value())
3667    }
3668
3669
3670    /// Returns true if `StrikePrice` is present, Tag 202.
3671    pub fn has_strike_price(&self) -> bool {
3672        self.message.body.has(tag::STRIKE_PRICE)
3673    }
3674
3675
3676
3677
3678    /// Sets `StrikeValue`, Tag 968.
3679    pub fn set_strike_value(&mut self, val: Decimal, scale: i32) {
3680        self.message.body.set_field(tag::STRIKE_VALUE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
3681    }
3682
3683    /// Gets `StrikeValue`, Tag 968.
3684    pub fn get_strike_value(&self) -> Result<Decimal, MessageRejectErrorEnum> {
3685        let mut fld = field::StrikeValueField::new(Decimal::ZERO, 0);
3686        self.message.body.get_field(tag::STRIKE_VALUE, &mut fld.0)?;
3687        Ok(fld.value())
3688    }
3689
3690
3691    /// Returns true if `StrikeValue` is present, Tag 968.
3692    pub fn has_strike_value(&self) -> bool {
3693        self.message.body.has(tag::STRIKE_VALUE)
3694    }
3695
3696
3697
3698
3699    /// Sets `Symbol`, Tag 55.
3700    pub fn set_symbol(&mut self, v: String) {
3701        self.message.body.set_field(tag::SYMBOL, FIXString::from(v));
3702    }
3703
3704    /// Gets `Symbol`, Tag 55.
3705    pub fn get_symbol(&self) -> Result<String, MessageRejectErrorEnum> {
3706        let mut fld = field::SymbolField::new(String::new());
3707        self.message.body.get_field(tag::SYMBOL, &mut fld.0)?;
3708        Ok(fld.value().to_string())
3709    }
3710
3711
3712    /// Returns true if `Symbol` is present, Tag 55.
3713    pub fn has_symbol(&self) -> bool {
3714        self.message.body.has(tag::SYMBOL)
3715    }
3716
3717
3718
3719
3720    /// Sets `SymbolSfx`, Tag 65.
3721    pub fn set_symbol_sfx(&mut self, v: String) {
3722        self.message.body.set_field(tag::SYMBOL_SFX, FIXString::from(v));
3723    }
3724
3725    /// Gets `SymbolSfx`, Tag 65.
3726    pub fn get_symbol_sfx(&self) -> Result<String, MessageRejectErrorEnum> {
3727        let mut fld = field::SymbolSfxField::new(String::new());
3728        self.message.body.get_field(tag::SYMBOL_SFX, &mut fld.0)?;
3729        Ok(fld.value().to_string())
3730    }
3731
3732
3733    /// Returns true if `SymbolSfx` is present, Tag 65.
3734    pub fn has_symbol_sfx(&self) -> bool {
3735        self.message.body.has(tag::SYMBOL_SFX)
3736    }
3737
3738
3739
3740
3741    /// Sets `TargetStrategy`, Tag 847.
3742    pub fn set_target_strategy(&mut self, v: isize) {
3743        self.message.body.set_field(tag::TARGET_STRATEGY, fixer::fix_int::FIXInt::from(v));
3744    }
3745
3746    /// Gets `TargetStrategy`, Tag 847.
3747    pub fn get_target_strategy(&self) -> Result<isize, MessageRejectErrorEnum> {
3748        let mut fld = field::TargetStrategyField::new(0);
3749        self.message.body.get_field(tag::TARGET_STRATEGY, &mut fld.0)?;
3750        Ok(fld.value())
3751    }
3752
3753
3754    /// Returns true if `TargetStrategy` is present, Tag 847.
3755    pub fn has_target_strategy(&self) -> bool {
3756        self.message.body.has(tag::TARGET_STRATEGY)
3757    }
3758
3759
3760
3761
3762    /// Sets `TargetStrategyParameters`, Tag 848.
3763    pub fn set_target_strategy_parameters(&mut self, v: String) {
3764        self.message.body.set_field(tag::TARGET_STRATEGY_PARAMETERS, FIXString::from(v));
3765    }
3766
3767    /// Gets `TargetStrategyParameters`, Tag 848.
3768    pub fn get_target_strategy_parameters(&self) -> Result<String, MessageRejectErrorEnum> {
3769        let mut fld = field::TargetStrategyParametersField::new(String::new());
3770        self.message.body.get_field(tag::TARGET_STRATEGY_PARAMETERS, &mut fld.0)?;
3771        Ok(fld.value().to_string())
3772    }
3773
3774
3775    /// Returns true if `TargetStrategyParameters` is present, Tag 848.
3776    pub fn has_target_strategy_parameters(&self) -> bool {
3777        self.message.body.has(tag::TARGET_STRATEGY_PARAMETERS)
3778    }
3779
3780
3781
3782
3783    /// Sets `TerminationType`, Tag 788.
3784    pub fn set_termination_type(&mut self, v: isize) {
3785        self.message.body.set_field(tag::TERMINATION_TYPE, fixer::fix_int::FIXInt::from(v));
3786    }
3787
3788    /// Gets `TerminationType`, Tag 788.
3789    pub fn get_termination_type(&self) -> Result<isize, MessageRejectErrorEnum> {
3790        let mut fld = field::TerminationTypeField::new(0);
3791        self.message.body.get_field(tag::TERMINATION_TYPE, &mut fld.0)?;
3792        Ok(fld.value())
3793    }
3794
3795
3796    /// Returns true if `TerminationType` is present, Tag 788.
3797    pub fn has_termination_type(&self) -> bool {
3798        self.message.body.has(tag::TERMINATION_TYPE)
3799    }
3800
3801
3802
3803
3804    /// Sets `Text`, Tag 58.
3805    pub fn set_text(&mut self, v: String) {
3806        self.message.body.set_field(tag::TEXT, FIXString::from(v));
3807    }
3808
3809    /// Gets `Text`, Tag 58.
3810    pub fn get_text(&self) -> Result<String, MessageRejectErrorEnum> {
3811        let mut fld = field::TextField::new(String::new());
3812        self.message.body.get_field(tag::TEXT, &mut fld.0)?;
3813        Ok(fld.value().to_string())
3814    }
3815
3816
3817    /// Returns true if `Text` is present, Tag 58.
3818    pub fn has_text(&self) -> bool {
3819        self.message.body.has(tag::TEXT)
3820    }
3821
3822
3823
3824
3825    /// Sets `TimeInForce`, Tag 59.
3826    pub fn set_time_in_force(&mut self, v: String) {
3827        self.message.body.set_field(tag::TIME_IN_FORCE, FIXString::from(v));
3828    }
3829
3830    /// Gets `TimeInForce`, Tag 59.
3831    pub fn get_time_in_force(&self) -> Result<String, MessageRejectErrorEnum> {
3832        let mut fld = field::TimeInForceField::new(String::new());
3833        self.message.body.get_field(tag::TIME_IN_FORCE, &mut fld.0)?;
3834        Ok(fld.value().to_string())
3835    }
3836
3837
3838    /// Returns true if `TimeInForce` is present, Tag 59.
3839    pub fn has_time_in_force(&self) -> bool {
3840        self.message.body.has(tag::TIME_IN_FORCE)
3841    }
3842
3843
3844
3845
3846    /// Sets `TimeUnit`, Tag 997.
3847    pub fn set_time_unit(&mut self, v: String) {
3848        self.message.body.set_field(tag::TIME_UNIT, FIXString::from(v));
3849    }
3850
3851    /// Gets `TimeUnit`, Tag 997.
3852    pub fn get_time_unit(&self) -> Result<String, MessageRejectErrorEnum> {
3853        let mut fld = field::TimeUnitField::new(String::new());
3854        self.message.body.get_field(tag::TIME_UNIT, &mut fld.0)?;
3855        Ok(fld.value().to_string())
3856    }
3857
3858
3859    /// Returns true if `TimeUnit` is present, Tag 997.
3860    pub fn has_time_unit(&self) -> bool {
3861        self.message.body.has(tag::TIME_UNIT)
3862    }
3863
3864
3865
3866
3867    /// Sets `TradeDate`, Tag 75.
3868    pub fn set_trade_date(&mut self, v: String) {
3869        self.message.body.set_field(tag::TRADE_DATE, FIXString::from(v));
3870    }
3871
3872    /// Gets `TradeDate`, Tag 75.
3873    pub fn get_trade_date(&self) -> Result<String, MessageRejectErrorEnum> {
3874        let mut fld = field::TradeDateField::new(String::new());
3875        self.message.body.get_field(tag::TRADE_DATE, &mut fld.0)?;
3876        Ok(fld.value().to_string())
3877    }
3878
3879
3880    /// Returns true if `TradeDate` is present, Tag 75.
3881    pub fn has_trade_date(&self) -> bool {
3882        self.message.body.has(tag::TRADE_DATE)
3883    }
3884
3885
3886
3887
3888    /// Sets `TradeOriginationDate`, Tag 229.
3889    pub fn set_trade_origination_date(&mut self, v: String) {
3890        self.message.body.set_field(tag::TRADE_ORIGINATION_DATE, FIXString::from(v));
3891    }
3892
3893    /// Gets `TradeOriginationDate`, Tag 229.
3894    pub fn get_trade_origination_date(&self) -> Result<String, MessageRejectErrorEnum> {
3895        let mut fld = field::TradeOriginationDateField::new(String::new());
3896        self.message.body.get_field(tag::TRADE_ORIGINATION_DATE, &mut fld.0)?;
3897        Ok(fld.value().to_string())
3898    }
3899
3900
3901    /// Returns true if `TradeOriginationDate` is present, Tag 229.
3902    pub fn has_trade_origination_date(&self) -> bool {
3903        self.message.body.has(tag::TRADE_ORIGINATION_DATE)
3904    }
3905
3906
3907
3908
3909    /// Sets `TransactTime`, Tag 60.
3910    pub fn set_transact_time(&mut self, v: Timestamp) {
3911        self.message.body.set_field(tag::TRANSACT_TIME, fixer::fix_utc_timestamp::FIXUTCTimestamp {
3912            time: v,
3913            precision: fixer::fix_utc_timestamp::TimestampPrecision::Millis,
3914        });
3915    }
3916
3917    /// Gets `TransactTime`, Tag 60.
3918    pub fn get_transact_time(&self) -> Result<Timestamp, MessageRejectErrorEnum> {
3919        let mut fld = field::TransactTimeField::new(Timestamp::UNIX_EPOCH);
3920        self.message.body.get_field(tag::TRANSACT_TIME, &mut fld.0)?;
3921        Ok(fld.value())
3922    }
3923
3924
3925    /// Returns true if `TransactTime` is present, Tag 60.
3926    pub fn has_transact_time(&self) -> bool {
3927        self.message.body.has(tag::TRANSACT_TIME)
3928    }
3929
3930
3931
3932
3933    /// Sets `TriggerAction`, Tag 1101.
3934    pub fn set_trigger_action(&mut self, v: String) {
3935        self.message.body.set_field(tag::TRIGGER_ACTION, FIXString::from(v));
3936    }
3937
3938    /// Gets `TriggerAction`, Tag 1101.
3939    pub fn get_trigger_action(&self) -> Result<String, MessageRejectErrorEnum> {
3940        let mut fld = field::TriggerActionField::new(String::new());
3941        self.message.body.get_field(tag::TRIGGER_ACTION, &mut fld.0)?;
3942        Ok(fld.value().to_string())
3943    }
3944
3945
3946    /// Returns true if `TriggerAction` is present, Tag 1101.
3947    pub fn has_trigger_action(&self) -> bool {
3948        self.message.body.has(tag::TRIGGER_ACTION)
3949    }
3950
3951
3952
3953
3954    /// Sets `TriggerNewPrice`, Tag 1110.
3955    pub fn set_trigger_new_price(&mut self, val: Decimal, scale: i32) {
3956        self.message.body.set_field(tag::TRIGGER_NEW_PRICE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
3957    }
3958
3959    /// Gets `TriggerNewPrice`, Tag 1110.
3960    pub fn get_trigger_new_price(&self) -> Result<Decimal, MessageRejectErrorEnum> {
3961        let mut fld = field::TriggerNewPriceField::new(Decimal::ZERO, 0);
3962        self.message.body.get_field(tag::TRIGGER_NEW_PRICE, &mut fld.0)?;
3963        Ok(fld.value())
3964    }
3965
3966
3967    /// Returns true if `TriggerNewPrice` is present, Tag 1110.
3968    pub fn has_trigger_new_price(&self) -> bool {
3969        self.message.body.has(tag::TRIGGER_NEW_PRICE)
3970    }
3971
3972
3973
3974
3975    /// Sets `TriggerNewQty`, Tag 1112.
3976    pub fn set_trigger_new_qty(&mut self, val: Decimal, scale: i32) {
3977        self.message.body.set_field(tag::TRIGGER_NEW_QTY, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
3978    }
3979
3980    /// Gets `TriggerNewQty`, Tag 1112.
3981    pub fn get_trigger_new_qty(&self) -> Result<Decimal, MessageRejectErrorEnum> {
3982        let mut fld = field::TriggerNewQtyField::new(Decimal::ZERO, 0);
3983        self.message.body.get_field(tag::TRIGGER_NEW_QTY, &mut fld.0)?;
3984        Ok(fld.value())
3985    }
3986
3987
3988    /// Returns true if `TriggerNewQty` is present, Tag 1112.
3989    pub fn has_trigger_new_qty(&self) -> bool {
3990        self.message.body.has(tag::TRIGGER_NEW_QTY)
3991    }
3992
3993
3994
3995
3996    /// Sets `TriggerOrderType`, Tag 1111.
3997    pub fn set_trigger_order_type(&mut self, v: String) {
3998        self.message.body.set_field(tag::TRIGGER_ORDER_TYPE, FIXString::from(v));
3999    }
4000
4001    /// Gets `TriggerOrderType`, Tag 1111.
4002    pub fn get_trigger_order_type(&self) -> Result<String, MessageRejectErrorEnum> {
4003        let mut fld = field::TriggerOrderTypeField::new(String::new());
4004        self.message.body.get_field(tag::TRIGGER_ORDER_TYPE, &mut fld.0)?;
4005        Ok(fld.value().to_string())
4006    }
4007
4008
4009    /// Returns true if `TriggerOrderType` is present, Tag 1111.
4010    pub fn has_trigger_order_type(&self) -> bool {
4011        self.message.body.has(tag::TRIGGER_ORDER_TYPE)
4012    }
4013
4014
4015
4016
4017    /// Sets `TriggerPrice`, Tag 1102.
4018    pub fn set_trigger_price(&mut self, val: Decimal, scale: i32) {
4019        self.message.body.set_field(tag::TRIGGER_PRICE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
4020    }
4021
4022    /// Gets `TriggerPrice`, Tag 1102.
4023    pub fn get_trigger_price(&self) -> Result<Decimal, MessageRejectErrorEnum> {
4024        let mut fld = field::TriggerPriceField::new(Decimal::ZERO, 0);
4025        self.message.body.get_field(tag::TRIGGER_PRICE, &mut fld.0)?;
4026        Ok(fld.value())
4027    }
4028
4029
4030    /// Returns true if `TriggerPrice` is present, Tag 1102.
4031    pub fn has_trigger_price(&self) -> bool {
4032        self.message.body.has(tag::TRIGGER_PRICE)
4033    }
4034
4035
4036
4037
4038    /// Sets `TriggerPriceDirection`, Tag 1109.
4039    pub fn set_trigger_price_direction(&mut self, v: String) {
4040        self.message.body.set_field(tag::TRIGGER_PRICE_DIRECTION, FIXString::from(v));
4041    }
4042
4043    /// Gets `TriggerPriceDirection`, Tag 1109.
4044    pub fn get_trigger_price_direction(&self) -> Result<String, MessageRejectErrorEnum> {
4045        let mut fld = field::TriggerPriceDirectionField::new(String::new());
4046        self.message.body.get_field(tag::TRIGGER_PRICE_DIRECTION, &mut fld.0)?;
4047        Ok(fld.value().to_string())
4048    }
4049
4050
4051    /// Returns true if `TriggerPriceDirection` is present, Tag 1109.
4052    pub fn has_trigger_price_direction(&self) -> bool {
4053        self.message.body.has(tag::TRIGGER_PRICE_DIRECTION)
4054    }
4055
4056
4057
4058
4059    /// Sets `TriggerPriceType`, Tag 1107.
4060    pub fn set_trigger_price_type(&mut self, v: String) {
4061        self.message.body.set_field(tag::TRIGGER_PRICE_TYPE, FIXString::from(v));
4062    }
4063
4064    /// Gets `TriggerPriceType`, Tag 1107.
4065    pub fn get_trigger_price_type(&self) -> Result<String, MessageRejectErrorEnum> {
4066        let mut fld = field::TriggerPriceTypeField::new(String::new());
4067        self.message.body.get_field(tag::TRIGGER_PRICE_TYPE, &mut fld.0)?;
4068        Ok(fld.value().to_string())
4069    }
4070
4071
4072    /// Returns true if `TriggerPriceType` is present, Tag 1107.
4073    pub fn has_trigger_price_type(&self) -> bool {
4074        self.message.body.has(tag::TRIGGER_PRICE_TYPE)
4075    }
4076
4077
4078
4079
4080    /// Sets `TriggerPriceTypeScope`, Tag 1108.
4081    pub fn set_trigger_price_type_scope(&mut self, v: String) {
4082        self.message.body.set_field(tag::TRIGGER_PRICE_TYPE_SCOPE, FIXString::from(v));
4083    }
4084
4085    /// Gets `TriggerPriceTypeScope`, Tag 1108.
4086    pub fn get_trigger_price_type_scope(&self) -> Result<String, MessageRejectErrorEnum> {
4087        let mut fld = field::TriggerPriceTypeScopeField::new(String::new());
4088        self.message.body.get_field(tag::TRIGGER_PRICE_TYPE_SCOPE, &mut fld.0)?;
4089        Ok(fld.value().to_string())
4090    }
4091
4092
4093    /// Returns true if `TriggerPriceTypeScope` is present, Tag 1108.
4094    pub fn has_trigger_price_type_scope(&self) -> bool {
4095        self.message.body.has(tag::TRIGGER_PRICE_TYPE_SCOPE)
4096    }
4097
4098
4099
4100
4101    /// Sets `TriggerSecurityDesc`, Tag 1106.
4102    pub fn set_trigger_security_desc(&mut self, v: String) {
4103        self.message.body.set_field(tag::TRIGGER_SECURITY_DESC, FIXString::from(v));
4104    }
4105
4106    /// Gets `TriggerSecurityDesc`, Tag 1106.
4107    pub fn get_trigger_security_desc(&self) -> Result<String, MessageRejectErrorEnum> {
4108        let mut fld = field::TriggerSecurityDescField::new(String::new());
4109        self.message.body.get_field(tag::TRIGGER_SECURITY_DESC, &mut fld.0)?;
4110        Ok(fld.value().to_string())
4111    }
4112
4113
4114    /// Returns true if `TriggerSecurityDesc` is present, Tag 1106.
4115    pub fn has_trigger_security_desc(&self) -> bool {
4116        self.message.body.has(tag::TRIGGER_SECURITY_DESC)
4117    }
4118
4119
4120
4121
4122    /// Sets `TriggerSecurityID`, Tag 1104.
4123    pub fn set_trigger_security_id(&mut self, v: String) {
4124        self.message.body.set_field(tag::TRIGGER_SECURITY_ID, FIXString::from(v));
4125    }
4126
4127    /// Gets `TriggerSecurityID`, Tag 1104.
4128    pub fn get_trigger_security_id(&self) -> Result<String, MessageRejectErrorEnum> {
4129        let mut fld = field::TriggerSecurityIDField::new(String::new());
4130        self.message.body.get_field(tag::TRIGGER_SECURITY_ID, &mut fld.0)?;
4131        Ok(fld.value().to_string())
4132    }
4133
4134
4135    /// Returns true if `TriggerSecurityID` is present, Tag 1104.
4136    pub fn has_trigger_security_id(&self) -> bool {
4137        self.message.body.has(tag::TRIGGER_SECURITY_ID)
4138    }
4139
4140
4141
4142
4143    /// Sets `TriggerSecurityIDSource`, Tag 1105.
4144    pub fn set_trigger_security_id_source(&mut self, v: String) {
4145        self.message.body.set_field(tag::TRIGGER_SECURITY_ID_SOURCE, FIXString::from(v));
4146    }
4147
4148    /// Gets `TriggerSecurityIDSource`, Tag 1105.
4149    pub fn get_trigger_security_id_source(&self) -> Result<String, MessageRejectErrorEnum> {
4150        let mut fld = field::TriggerSecurityIDSourceField::new(String::new());
4151        self.message.body.get_field(tag::TRIGGER_SECURITY_ID_SOURCE, &mut fld.0)?;
4152        Ok(fld.value().to_string())
4153    }
4154
4155
4156    /// Returns true if `TriggerSecurityIDSource` is present, Tag 1105.
4157    pub fn has_trigger_security_id_source(&self) -> bool {
4158        self.message.body.has(tag::TRIGGER_SECURITY_ID_SOURCE)
4159    }
4160
4161
4162
4163
4164    /// Sets `TriggerSymbol`, Tag 1103.
4165    pub fn set_trigger_symbol(&mut self, v: String) {
4166        self.message.body.set_field(tag::TRIGGER_SYMBOL, FIXString::from(v));
4167    }
4168
4169    /// Gets `TriggerSymbol`, Tag 1103.
4170    pub fn get_trigger_symbol(&self) -> Result<String, MessageRejectErrorEnum> {
4171        let mut fld = field::TriggerSymbolField::new(String::new());
4172        self.message.body.get_field(tag::TRIGGER_SYMBOL, &mut fld.0)?;
4173        Ok(fld.value().to_string())
4174    }
4175
4176
4177    /// Returns true if `TriggerSymbol` is present, Tag 1103.
4178    pub fn has_trigger_symbol(&self) -> bool {
4179        self.message.body.has(tag::TRIGGER_SYMBOL)
4180    }
4181
4182
4183
4184
4185    /// Sets `TriggerTradingSessionID`, Tag 1113.
4186    pub fn set_trigger_trading_session_id(&mut self, v: String) {
4187        self.message.body.set_field(tag::TRIGGER_TRADING_SESSION_ID, FIXString::from(v));
4188    }
4189
4190    /// Gets `TriggerTradingSessionID`, Tag 1113.
4191    pub fn get_trigger_trading_session_id(&self) -> Result<String, MessageRejectErrorEnum> {
4192        let mut fld = field::TriggerTradingSessionIDField::new(String::new());
4193        self.message.body.get_field(tag::TRIGGER_TRADING_SESSION_ID, &mut fld.0)?;
4194        Ok(fld.value().to_string())
4195    }
4196
4197
4198    /// Returns true if `TriggerTradingSessionID` is present, Tag 1113.
4199    pub fn has_trigger_trading_session_id(&self) -> bool {
4200        self.message.body.has(tag::TRIGGER_TRADING_SESSION_ID)
4201    }
4202
4203
4204
4205
4206    /// Sets `TriggerTradingSessionSubID`, Tag 1114.
4207    pub fn set_trigger_trading_session_sub_id(&mut self, v: String) {
4208        self.message.body.set_field(tag::TRIGGER_TRADING_SESSION_SUB_ID, FIXString::from(v));
4209    }
4210
4211    /// Gets `TriggerTradingSessionSubID`, Tag 1114.
4212    pub fn get_trigger_trading_session_sub_id(&self) -> Result<String, MessageRejectErrorEnum> {
4213        let mut fld = field::TriggerTradingSessionSubIDField::new(String::new());
4214        self.message.body.get_field(tag::TRIGGER_TRADING_SESSION_SUB_ID, &mut fld.0)?;
4215        Ok(fld.value().to_string())
4216    }
4217
4218
4219    /// Returns true if `TriggerTradingSessionSubID` is present, Tag 1114.
4220    pub fn has_trigger_trading_session_sub_id(&self) -> bool {
4221        self.message.body.has(tag::TRIGGER_TRADING_SESSION_SUB_ID)
4222    }
4223
4224
4225
4226
4227    /// Sets `TriggerType`, Tag 1100.
4228    pub fn set_trigger_type(&mut self, v: String) {
4229        self.message.body.set_field(tag::TRIGGER_TYPE, FIXString::from(v));
4230    }
4231
4232    /// Gets `TriggerType`, Tag 1100.
4233    pub fn get_trigger_type(&self) -> Result<String, MessageRejectErrorEnum> {
4234        let mut fld = field::TriggerTypeField::new(String::new());
4235        self.message.body.get_field(tag::TRIGGER_TYPE, &mut fld.0)?;
4236        Ok(fld.value().to_string())
4237    }
4238
4239
4240    /// Returns true if `TriggerType` is present, Tag 1100.
4241    pub fn has_trigger_type(&self) -> bool {
4242        self.message.body.has(tag::TRIGGER_TYPE)
4243    }
4244
4245
4246
4247
4248    /// Sets `UnitOfMeasure`, Tag 996.
4249    pub fn set_unit_of_measure(&mut self, v: String) {
4250        self.message.body.set_field(tag::UNIT_OF_MEASURE, FIXString::from(v));
4251    }
4252
4253    /// Gets `UnitOfMeasure`, Tag 996.
4254    pub fn get_unit_of_measure(&self) -> Result<String, MessageRejectErrorEnum> {
4255        let mut fld = field::UnitOfMeasureField::new(String::new());
4256        self.message.body.get_field(tag::UNIT_OF_MEASURE, &mut fld.0)?;
4257        Ok(fld.value().to_string())
4258    }
4259
4260
4261    /// Returns true if `UnitOfMeasure` is present, Tag 996.
4262    pub fn has_unit_of_measure(&self) -> bool {
4263        self.message.body.has(tag::UNIT_OF_MEASURE)
4264    }
4265
4266
4267
4268
4269    /// Sets `Yield`, Tag 236.
4270    pub fn set_yield(&mut self, val: Decimal, scale: i32) {
4271        self.message.body.set_field(tag::YIELD, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
4272    }
4273
4274    /// Gets `Yield`, Tag 236.
4275    pub fn get_yield(&self) -> Result<Decimal, MessageRejectErrorEnum> {
4276        let mut fld = field::YieldField::new(Decimal::ZERO, 0);
4277        self.message.body.get_field(tag::YIELD, &mut fld.0)?;
4278        Ok(fld.value())
4279    }
4280
4281
4282    /// Returns true if `Yield` is present, Tag 236.
4283    pub fn has_yield(&self) -> bool {
4284        self.message.body.has(tag::YIELD)
4285    }
4286
4287
4288
4289
4290    /// Sets `YieldCalcDate`, Tag 701.
4291    pub fn set_yield_calc_date(&mut self, v: String) {
4292        self.message.body.set_field(tag::YIELD_CALC_DATE, FIXString::from(v));
4293    }
4294
4295    /// Gets `YieldCalcDate`, Tag 701.
4296    pub fn get_yield_calc_date(&self) -> Result<String, MessageRejectErrorEnum> {
4297        let mut fld = field::YieldCalcDateField::new(String::new());
4298        self.message.body.get_field(tag::YIELD_CALC_DATE, &mut fld.0)?;
4299        Ok(fld.value().to_string())
4300    }
4301
4302
4303    /// Returns true if `YieldCalcDate` is present, Tag 701.
4304    pub fn has_yield_calc_date(&self) -> bool {
4305        self.message.body.has(tag::YIELD_CALC_DATE)
4306    }
4307
4308
4309
4310
4311    /// Sets `YieldRedemptionDate`, Tag 696.
4312    pub fn set_yield_redemption_date(&mut self, v: String) {
4313        self.message.body.set_field(tag::YIELD_REDEMPTION_DATE, FIXString::from(v));
4314    }
4315
4316    /// Gets `YieldRedemptionDate`, Tag 696.
4317    pub fn get_yield_redemption_date(&self) -> Result<String, MessageRejectErrorEnum> {
4318        let mut fld = field::YieldRedemptionDateField::new(String::new());
4319        self.message.body.get_field(tag::YIELD_REDEMPTION_DATE, &mut fld.0)?;
4320        Ok(fld.value().to_string())
4321    }
4322
4323
4324    /// Returns true if `YieldRedemptionDate` is present, Tag 696.
4325    pub fn has_yield_redemption_date(&self) -> bool {
4326        self.message.body.has(tag::YIELD_REDEMPTION_DATE)
4327    }
4328
4329
4330
4331
4332    /// Sets `YieldRedemptionPrice`, Tag 697.
4333    pub fn set_yield_redemption_price(&mut self, val: Decimal, scale: i32) {
4334        self.message.body.set_field(tag::YIELD_REDEMPTION_PRICE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
4335    }
4336
4337    /// Gets `YieldRedemptionPrice`, Tag 697.
4338    pub fn get_yield_redemption_price(&self) -> Result<Decimal, MessageRejectErrorEnum> {
4339        let mut fld = field::YieldRedemptionPriceField::new(Decimal::ZERO, 0);
4340        self.message.body.get_field(tag::YIELD_REDEMPTION_PRICE, &mut fld.0)?;
4341        Ok(fld.value())
4342    }
4343
4344
4345    /// Returns true if `YieldRedemptionPrice` is present, Tag 697.
4346    pub fn has_yield_redemption_price(&self) -> bool {
4347        self.message.body.has(tag::YIELD_REDEMPTION_PRICE)
4348    }
4349
4350
4351
4352
4353    /// Sets `YieldRedemptionPriceType`, Tag 698.
4354    pub fn set_yield_redemption_price_type(&mut self, v: isize) {
4355        self.message.body.set_field(tag::YIELD_REDEMPTION_PRICE_TYPE, fixer::fix_int::FIXInt::from(v));
4356    }
4357
4358    /// Gets `YieldRedemptionPriceType`, Tag 698.
4359    pub fn get_yield_redemption_price_type(&self) -> Result<isize, MessageRejectErrorEnum> {
4360        let mut fld = field::YieldRedemptionPriceTypeField::new(0);
4361        self.message.body.get_field(tag::YIELD_REDEMPTION_PRICE_TYPE, &mut fld.0)?;
4362        Ok(fld.value())
4363    }
4364
4365
4366    /// Returns true if `YieldRedemptionPriceType` is present, Tag 698.
4367    pub fn has_yield_redemption_price_type(&self) -> bool {
4368        self.message.body.has(tag::YIELD_REDEMPTION_PRICE_TYPE)
4369    }
4370
4371
4372
4373
4374    /// Sets `YieldType`, Tag 235.
4375    pub fn set_yield_type(&mut self, v: String) {
4376        self.message.body.set_field(tag::YIELD_TYPE, FIXString::from(v));
4377    }
4378
4379    /// Gets `YieldType`, Tag 235.
4380    pub fn get_yield_type(&self) -> Result<String, MessageRejectErrorEnum> {
4381        let mut fld = field::YieldTypeField::new(String::new());
4382        self.message.body.get_field(tag::YIELD_TYPE, &mut fld.0)?;
4383        Ok(fld.value().to_string())
4384    }
4385
4386
4387    /// Returns true if `YieldType` is present, Tag 235.
4388    pub fn has_yield_type(&self) -> bool {
4389        self.message.body.has(tag::YIELD_TYPE)
4390    }
4391
4392
4393}
4394
4395/// `RouteOut` is the callback type for routing `OrderCancelReplaceRequest` messages.
4396pub type RouteOut = fn(msg: OrderCancelReplaceRequest, session_id: SessionID) -> Result<(), MessageRejectErrorEnum>;
4397
4398/// Route type returned by the `route` function.
4399pub type Route = (&'static str, &'static str, Box<dyn Fn(&Message, SessionID) -> Result<(), MessageRejectErrorEnum> + Send>);
4400
4401/// Returns the begin string, message type, and route function for `OrderCancelReplaceRequest`.
4402pub fn route(router: RouteOut) -> Route {
4403    let r = move |msg: &Message, session_id: SessionID| -> Result<(), MessageRejectErrorEnum> {
4404        router(OrderCancelReplaceRequest::from_message(msg.clone()), session_id)
4405    };
4406    ("7", "G", Box::new(r))
4407}
fixer_fix/fix50/order_cancel_replace_request.rs

fixer_fix/fix50/
order_cancel_replace_request.rs
