1#![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
12
13use jiff::Timestamp;
14
15use crate::field;
16use crate::tag;
17
18pub struct SettlementInstructions {
20 pub message: Message,
21}
22
23impl SettlementInstructions {
24 pub fn new(settl_inst_id: field::SettlInstIDField, settl_inst_trans_type: field::SettlInstTransTypeField, settl_inst_ref_id: field::SettlInstRefIDField, settl_inst_mode: field::SettlInstModeField, settl_inst_source: field::SettlInstSourceField, alloc_account: field::AllocAccountField, transact_time: field::TransactTimeField) -> Self {
26 let mut msg = Message::new();
27 msg.header.set_field(tag::MSG_TYPE, FIXString::from("T".to_string()));
28
29 msg.body.set_field(tag::SETTL_INST_ID, settl_inst_id.0);
30
31 msg.body.set_field(tag::SETTL_INST_TRANS_TYPE, settl_inst_trans_type.0);
32
33 msg.body.set_field(tag::SETTL_INST_REF_ID, settl_inst_ref_id.0);
34
35 msg.body.set_field(tag::SETTL_INST_MODE, settl_inst_mode.0);
36
37 msg.body.set_field(tag::SETTL_INST_SOURCE, settl_inst_source.0);
38
39 msg.body.set_field(tag::ALLOC_ACCOUNT, alloc_account.0);
40
41 msg.body.set_field(tag::TRANSACT_TIME, transact_time.0);
42
43 Self { message: msg }
44 }
45
46 pub fn from_message(msg: Message) -> Self {
48 Self { message: msg }
49 }
50
51 pub fn to_message(self) -> Message {
53 self.message
54 }
55
56
57
58
59 pub fn set_alloc_account(&mut self, v: String) {
61 self.message.body.set_field(tag::ALLOC_ACCOUNT, FIXString::from(v));
62 }
63
64 pub fn get_alloc_account(&self) -> Result<String, MessageRejectErrorEnum> {
66 let mut fld = field::AllocAccountField::new(String::new());
67 self.message.body.get_field(tag::ALLOC_ACCOUNT, &mut fld.0)?;
68 Ok(fld.value().to_string())
69 }
70
71
72 pub fn has_alloc_account(&self) -> bool {
74 self.message.body.has(tag::ALLOC_ACCOUNT)
75 }
76
77
78
79
80 pub fn set_alloc_id(&mut self, v: String) {
82 self.message.body.set_field(tag::ALLOC_ID, FIXString::from(v));
83 }
84
85 pub fn get_alloc_id(&self) -> Result<String, MessageRejectErrorEnum> {
87 let mut fld = field::AllocIDField::new(String::new());
88 self.message.body.get_field(tag::ALLOC_ID, &mut fld.0)?;
89 Ok(fld.value().to_string())
90 }
91
92
93 pub fn has_alloc_id(&self) -> bool {
95 self.message.body.has(tag::ALLOC_ID)
96 }
97
98
99
100
101 pub fn set_cash_settl_agent_acct_name(&mut self, v: String) {
103 self.message.body.set_field(tag::CASH_SETTL_AGENT_ACCT_NAME, FIXString::from(v));
104 }
105
106 pub fn get_cash_settl_agent_acct_name(&self) -> Result<String, MessageRejectErrorEnum> {
108 let mut fld = field::CashSettlAgentAcctNameField::new(String::new());
109 self.message.body.get_field(tag::CASH_SETTL_AGENT_ACCT_NAME, &mut fld.0)?;
110 Ok(fld.value().to_string())
111 }
112
113
114 pub fn has_cash_settl_agent_acct_name(&self) -> bool {
116 self.message.body.has(tag::CASH_SETTL_AGENT_ACCT_NAME)
117 }
118
119
120
121
122 pub fn set_cash_settl_agent_acct_num(&mut self, v: String) {
124 self.message.body.set_field(tag::CASH_SETTL_AGENT_ACCT_NUM, FIXString::from(v));
125 }
126
127 pub fn get_cash_settl_agent_acct_num(&self) -> Result<String, MessageRejectErrorEnum> {
129 let mut fld = field::CashSettlAgentAcctNumField::new(String::new());
130 self.message.body.get_field(tag::CASH_SETTL_AGENT_ACCT_NUM, &mut fld.0)?;
131 Ok(fld.value().to_string())
132 }
133
134
135 pub fn has_cash_settl_agent_acct_num(&self) -> bool {
137 self.message.body.has(tag::CASH_SETTL_AGENT_ACCT_NUM)
138 }
139
140
141
142
143 pub fn set_cash_settl_agent_code(&mut self, v: String) {
145 self.message.body.set_field(tag::CASH_SETTL_AGENT_CODE, FIXString::from(v));
146 }
147
148 pub fn get_cash_settl_agent_code(&self) -> Result<String, MessageRejectErrorEnum> {
150 let mut fld = field::CashSettlAgentCodeField::new(String::new());
151 self.message.body.get_field(tag::CASH_SETTL_AGENT_CODE, &mut fld.0)?;
152 Ok(fld.value().to_string())
153 }
154
155
156 pub fn has_cash_settl_agent_code(&self) -> bool {
158 self.message.body.has(tag::CASH_SETTL_AGENT_CODE)
159 }
160
161
162
163
164 pub fn set_cash_settl_agent_contact_name(&mut self, v: String) {
166 self.message.body.set_field(tag::CASH_SETTL_AGENT_CONTACT_NAME, FIXString::from(v));
167 }
168
169 pub fn get_cash_settl_agent_contact_name(&self) -> Result<String, MessageRejectErrorEnum> {
171 let mut fld = field::CashSettlAgentContactNameField::new(String::new());
172 self.message.body.get_field(tag::CASH_SETTL_AGENT_CONTACT_NAME, &mut fld.0)?;
173 Ok(fld.value().to_string())
174 }
175
176
177 pub fn has_cash_settl_agent_contact_name(&self) -> bool {
179 self.message.body.has(tag::CASH_SETTL_AGENT_CONTACT_NAME)
180 }
181
182
183
184
185 pub fn set_cash_settl_agent_contact_phone(&mut self, v: String) {
187 self.message.body.set_field(tag::CASH_SETTL_AGENT_CONTACT_PHONE, FIXString::from(v));
188 }
189
190 pub fn get_cash_settl_agent_contact_phone(&self) -> Result<String, MessageRejectErrorEnum> {
192 let mut fld = field::CashSettlAgentContactPhoneField::new(String::new());
193 self.message.body.get_field(tag::CASH_SETTL_AGENT_CONTACT_PHONE, &mut fld.0)?;
194 Ok(fld.value().to_string())
195 }
196
197
198 pub fn has_cash_settl_agent_contact_phone(&self) -> bool {
200 self.message.body.has(tag::CASH_SETTL_AGENT_CONTACT_PHONE)
201 }
202
203
204
205
206 pub fn set_cash_settl_agent_name(&mut self, v: String) {
208 self.message.body.set_field(tag::CASH_SETTL_AGENT_NAME, FIXString::from(v));
209 }
210
211 pub fn get_cash_settl_agent_name(&self) -> Result<String, MessageRejectErrorEnum> {
213 let mut fld = field::CashSettlAgentNameField::new(String::new());
214 self.message.body.get_field(tag::CASH_SETTL_AGENT_NAME, &mut fld.0)?;
215 Ok(fld.value().to_string())
216 }
217
218
219 pub fn has_cash_settl_agent_name(&self) -> bool {
221 self.message.body.has(tag::CASH_SETTL_AGENT_NAME)
222 }
223
224
225
226
227 pub fn set_client_id(&mut self, v: String) {
229 self.message.body.set_field(tag::CLIENT_ID, FIXString::from(v));
230 }
231
232 pub fn get_client_id(&self) -> Result<String, MessageRejectErrorEnum> {
234 let mut fld = field::ClientIDField::new(String::new());
235 self.message.body.get_field(tag::CLIENT_ID, &mut fld.0)?;
236 Ok(fld.value().to_string())
237 }
238
239
240 pub fn has_client_id(&self) -> bool {
242 self.message.body.has(tag::CLIENT_ID)
243 }
244
245
246
247
248 pub fn set_effective_time(&mut self, v: Timestamp) {
250 self.message.body.set_field(tag::EFFECTIVE_TIME, fixer::fix_utc_timestamp::FIXUTCTimestamp {
251 time: v,
252 precision: fixer::fix_utc_timestamp::TimestampPrecision::Millis,
253 });
254 }
255
256 pub fn get_effective_time(&self) -> Result<Timestamp, MessageRejectErrorEnum> {
258 let mut fld = field::EffectiveTimeField::new(Timestamp::UNIX_EPOCH);
259 self.message.body.get_field(tag::EFFECTIVE_TIME, &mut fld.0)?;
260 Ok(fld.value())
261 }
262
263
264 pub fn has_effective_time(&self) -> bool {
266 self.message.body.has(tag::EFFECTIVE_TIME)
267 }
268
269
270
271
272 pub fn set_exec_broker(&mut self, v: String) {
274 self.message.body.set_field(tag::EXEC_BROKER, FIXString::from(v));
275 }
276
277 pub fn get_exec_broker(&self) -> Result<String, MessageRejectErrorEnum> {
279 let mut fld = field::ExecBrokerField::new(String::new());
280 self.message.body.get_field(tag::EXEC_BROKER, &mut fld.0)?;
281 Ok(fld.value().to_string())
282 }
283
284
285 pub fn has_exec_broker(&self) -> bool {
287 self.message.body.has(tag::EXEC_BROKER)
288 }
289
290
291
292
293 pub fn set_last_mkt(&mut self, v: String) {
295 self.message.body.set_field(tag::LAST_MKT, FIXString::from(v));
296 }
297
298 pub fn get_last_mkt(&self) -> Result<String, MessageRejectErrorEnum> {
300 let mut fld = field::LastMktField::new(String::new());
301 self.message.body.get_field(tag::LAST_MKT, &mut fld.0)?;
302 Ok(fld.value().to_string())
303 }
304
305
306 pub fn has_last_mkt(&self) -> bool {
308 self.message.body.has(tag::LAST_MKT)
309 }
310
311
312
313
314 pub fn set_security_settl_agent_acct_name(&mut self, v: String) {
316 self.message.body.set_field(tag::SECURITY_SETTL_AGENT_ACCT_NAME, FIXString::from(v));
317 }
318
319 pub fn get_security_settl_agent_acct_name(&self) -> Result<String, MessageRejectErrorEnum> {
321 let mut fld = field::SecuritySettlAgentAcctNameField::new(String::new());
322 self.message.body.get_field(tag::SECURITY_SETTL_AGENT_ACCT_NAME, &mut fld.0)?;
323 Ok(fld.value().to_string())
324 }
325
326
327 pub fn has_security_settl_agent_acct_name(&self) -> bool {
329 self.message.body.has(tag::SECURITY_SETTL_AGENT_ACCT_NAME)
330 }
331
332
333
334
335 pub fn set_security_settl_agent_acct_num(&mut self, v: String) {
337 self.message.body.set_field(tag::SECURITY_SETTL_AGENT_ACCT_NUM, FIXString::from(v));
338 }
339
340 pub fn get_security_settl_agent_acct_num(&self) -> Result<String, MessageRejectErrorEnum> {
342 let mut fld = field::SecuritySettlAgentAcctNumField::new(String::new());
343 self.message.body.get_field(tag::SECURITY_SETTL_AGENT_ACCT_NUM, &mut fld.0)?;
344 Ok(fld.value().to_string())
345 }
346
347
348 pub fn has_security_settl_agent_acct_num(&self) -> bool {
350 self.message.body.has(tag::SECURITY_SETTL_AGENT_ACCT_NUM)
351 }
352
353
354
355
356 pub fn set_security_settl_agent_code(&mut self, v: String) {
358 self.message.body.set_field(tag::SECURITY_SETTL_AGENT_CODE, FIXString::from(v));
359 }
360
361 pub fn get_security_settl_agent_code(&self) -> Result<String, MessageRejectErrorEnum> {
363 let mut fld = field::SecuritySettlAgentCodeField::new(String::new());
364 self.message.body.get_field(tag::SECURITY_SETTL_AGENT_CODE, &mut fld.0)?;
365 Ok(fld.value().to_string())
366 }
367
368
369 pub fn has_security_settl_agent_code(&self) -> bool {
371 self.message.body.has(tag::SECURITY_SETTL_AGENT_CODE)
372 }
373
374
375
376
377 pub fn set_security_settl_agent_contact_name(&mut self, v: String) {
379 self.message.body.set_field(tag::SECURITY_SETTL_AGENT_CONTACT_NAME, FIXString::from(v));
380 }
381
382 pub fn get_security_settl_agent_contact_name(&self) -> Result<String, MessageRejectErrorEnum> {
384 let mut fld = field::SecuritySettlAgentContactNameField::new(String::new());
385 self.message.body.get_field(tag::SECURITY_SETTL_AGENT_CONTACT_NAME, &mut fld.0)?;
386 Ok(fld.value().to_string())
387 }
388
389
390 pub fn has_security_settl_agent_contact_name(&self) -> bool {
392 self.message.body.has(tag::SECURITY_SETTL_AGENT_CONTACT_NAME)
393 }
394
395
396
397
398 pub fn set_security_settl_agent_contact_phone(&mut self, v: String) {
400 self.message.body.set_field(tag::SECURITY_SETTL_AGENT_CONTACT_PHONE, FIXString::from(v));
401 }
402
403 pub fn get_security_settl_agent_contact_phone(&self) -> Result<String, MessageRejectErrorEnum> {
405 let mut fld = field::SecuritySettlAgentContactPhoneField::new(String::new());
406 self.message.body.get_field(tag::SECURITY_SETTL_AGENT_CONTACT_PHONE, &mut fld.0)?;
407 Ok(fld.value().to_string())
408 }
409
410
411 pub fn has_security_settl_agent_contact_phone(&self) -> bool {
413 self.message.body.has(tag::SECURITY_SETTL_AGENT_CONTACT_PHONE)
414 }
415
416
417
418
419 pub fn set_security_settl_agent_name(&mut self, v: String) {
421 self.message.body.set_field(tag::SECURITY_SETTL_AGENT_NAME, FIXString::from(v));
422 }
423
424 pub fn get_security_settl_agent_name(&self) -> Result<String, MessageRejectErrorEnum> {
426 let mut fld = field::SecuritySettlAgentNameField::new(String::new());
427 self.message.body.get_field(tag::SECURITY_SETTL_AGENT_NAME, &mut fld.0)?;
428 Ok(fld.value().to_string())
429 }
430
431
432 pub fn has_security_settl_agent_name(&self) -> bool {
434 self.message.body.has(tag::SECURITY_SETTL_AGENT_NAME)
435 }
436
437
438
439
440 pub fn set_security_type(&mut self, v: String) {
442 self.message.body.set_field(tag::SECURITY_TYPE, FIXString::from(v));
443 }
444
445 pub fn get_security_type(&self) -> Result<String, MessageRejectErrorEnum> {
447 let mut fld = field::SecurityTypeField::new(String::new());
448 self.message.body.get_field(tag::SECURITY_TYPE, &mut fld.0)?;
449 Ok(fld.value().to_string())
450 }
451
452
453 pub fn has_security_type(&self) -> bool {
455 self.message.body.has(tag::SECURITY_TYPE)
456 }
457
458
459
460
461 pub fn set_settl_brkr_code(&mut self, v: String) {
463 self.message.body.set_field(tag::SETTL_BRKR_CODE, FIXString::from(v));
464 }
465
466 pub fn get_settl_brkr_code(&self) -> Result<String, MessageRejectErrorEnum> {
468 let mut fld = field::SettlBrkrCodeField::new(String::new());
469 self.message.body.get_field(tag::SETTL_BRKR_CODE, &mut fld.0)?;
470 Ok(fld.value().to_string())
471 }
472
473
474 pub fn has_settl_brkr_code(&self) -> bool {
476 self.message.body.has(tag::SETTL_BRKR_CODE)
477 }
478
479
480
481
482 pub fn set_settl_delivery_type(&mut self, v: isize) {
484 self.message.body.set_field(tag::SETTL_DELIVERY_TYPE, fixer::fix_int::FIXInt::from(v));
485 }
486
487 pub fn get_settl_delivery_type(&self) -> Result<isize, MessageRejectErrorEnum> {
489 let mut fld = field::SettlDeliveryTypeField::new(0);
490 self.message.body.get_field(tag::SETTL_DELIVERY_TYPE, &mut fld.0)?;
491 Ok(fld.value())
492 }
493
494
495 pub fn has_settl_delivery_type(&self) -> bool {
497 self.message.body.has(tag::SETTL_DELIVERY_TYPE)
498 }
499
500
501
502
503 pub fn set_settl_depository_code(&mut self, v: String) {
505 self.message.body.set_field(tag::SETTL_DEPOSITORY_CODE, FIXString::from(v));
506 }
507
508 pub fn get_settl_depository_code(&self) -> Result<String, MessageRejectErrorEnum> {
510 let mut fld = field::SettlDepositoryCodeField::new(String::new());
511 self.message.body.get_field(tag::SETTL_DEPOSITORY_CODE, &mut fld.0)?;
512 Ok(fld.value().to_string())
513 }
514
515
516 pub fn has_settl_depository_code(&self) -> bool {
518 self.message.body.has(tag::SETTL_DEPOSITORY_CODE)
519 }
520
521
522
523
524 pub fn set_settl_inst_code(&mut self, v: String) {
526 self.message.body.set_field(tag::SETTL_INST_CODE, FIXString::from(v));
527 }
528
529 pub fn get_settl_inst_code(&self) -> Result<String, MessageRejectErrorEnum> {
531 let mut fld = field::SettlInstCodeField::new(String::new());
532 self.message.body.get_field(tag::SETTL_INST_CODE, &mut fld.0)?;
533 Ok(fld.value().to_string())
534 }
535
536
537 pub fn has_settl_inst_code(&self) -> bool {
539 self.message.body.has(tag::SETTL_INST_CODE)
540 }
541
542
543
544
545 pub fn set_settl_inst_id(&mut self, v: String) {
547 self.message.body.set_field(tag::SETTL_INST_ID, FIXString::from(v));
548 }
549
550 pub fn get_settl_inst_id(&self) -> Result<String, MessageRejectErrorEnum> {
552 let mut fld = field::SettlInstIDField::new(String::new());
553 self.message.body.get_field(tag::SETTL_INST_ID, &mut fld.0)?;
554 Ok(fld.value().to_string())
555 }
556
557
558 pub fn has_settl_inst_id(&self) -> bool {
560 self.message.body.has(tag::SETTL_INST_ID)
561 }
562
563
564
565
566 pub fn set_settl_inst_mode(&mut self, v: String) {
568 self.message.body.set_field(tag::SETTL_INST_MODE, FIXString::from(v));
569 }
570
571 pub fn get_settl_inst_mode(&self) -> Result<String, MessageRejectErrorEnum> {
573 let mut fld = field::SettlInstModeField::new(String::new());
574 self.message.body.get_field(tag::SETTL_INST_MODE, &mut fld.0)?;
575 Ok(fld.value().to_string())
576 }
577
578
579 pub fn has_settl_inst_mode(&self) -> bool {
581 self.message.body.has(tag::SETTL_INST_MODE)
582 }
583
584
585
586
587 pub fn set_settl_inst_ref_id(&mut self, v: String) {
589 self.message.body.set_field(tag::SETTL_INST_REF_ID, FIXString::from(v));
590 }
591
592 pub fn get_settl_inst_ref_id(&self) -> Result<String, MessageRejectErrorEnum> {
594 let mut fld = field::SettlInstRefIDField::new(String::new());
595 self.message.body.get_field(tag::SETTL_INST_REF_ID, &mut fld.0)?;
596 Ok(fld.value().to_string())
597 }
598
599
600 pub fn has_settl_inst_ref_id(&self) -> bool {
602 self.message.body.has(tag::SETTL_INST_REF_ID)
603 }
604
605
606
607
608 pub fn set_settl_inst_source(&mut self, v: String) {
610 self.message.body.set_field(tag::SETTL_INST_SOURCE, FIXString::from(v));
611 }
612
613 pub fn get_settl_inst_source(&self) -> Result<String, MessageRejectErrorEnum> {
615 let mut fld = field::SettlInstSourceField::new(String::new());
616 self.message.body.get_field(tag::SETTL_INST_SOURCE, &mut fld.0)?;
617 Ok(fld.value().to_string())
618 }
619
620
621 pub fn has_settl_inst_source(&self) -> bool {
623 self.message.body.has(tag::SETTL_INST_SOURCE)
624 }
625
626
627
628
629 pub fn set_settl_inst_trans_type(&mut self, v: String) {
631 self.message.body.set_field(tag::SETTL_INST_TRANS_TYPE, FIXString::from(v));
632 }
633
634 pub fn get_settl_inst_trans_type(&self) -> Result<String, MessageRejectErrorEnum> {
636 let mut fld = field::SettlInstTransTypeField::new(String::new());
637 self.message.body.get_field(tag::SETTL_INST_TRANS_TYPE, &mut fld.0)?;
638 Ok(fld.value().to_string())
639 }
640
641
642 pub fn has_settl_inst_trans_type(&self) -> bool {
644 self.message.body.has(tag::SETTL_INST_TRANS_TYPE)
645 }
646
647
648
649
650 pub fn set_settl_location(&mut self, v: String) {
652 self.message.body.set_field(tag::SETTL_LOCATION, FIXString::from(v));
653 }
654
655 pub fn get_settl_location(&self) -> Result<String, MessageRejectErrorEnum> {
657 let mut fld = field::SettlLocationField::new(String::new());
658 self.message.body.get_field(tag::SETTL_LOCATION, &mut fld.0)?;
659 Ok(fld.value().to_string())
660 }
661
662
663 pub fn has_settl_location(&self) -> bool {
665 self.message.body.has(tag::SETTL_LOCATION)
666 }
667
668
669
670
671 pub fn set_side(&mut self, v: String) {
673 self.message.body.set_field(tag::SIDE, FIXString::from(v));
674 }
675
676 pub fn get_side(&self) -> Result<String, MessageRejectErrorEnum> {
678 let mut fld = field::SideField::new(String::new());
679 self.message.body.get_field(tag::SIDE, &mut fld.0)?;
680 Ok(fld.value().to_string())
681 }
682
683
684 pub fn has_side(&self) -> bool {
686 self.message.body.has(tag::SIDE)
687 }
688
689
690
691
692 pub fn set_stand_inst_db_id(&mut self, v: String) {
694 self.message.body.set_field(tag::STAND_INST_DB_ID, FIXString::from(v));
695 }
696
697 pub fn get_stand_inst_db_id(&self) -> Result<String, MessageRejectErrorEnum> {
699 let mut fld = field::StandInstDbIDField::new(String::new());
700 self.message.body.get_field(tag::STAND_INST_DB_ID, &mut fld.0)?;
701 Ok(fld.value().to_string())
702 }
703
704
705 pub fn has_stand_inst_db_id(&self) -> bool {
707 self.message.body.has(tag::STAND_INST_DB_ID)
708 }
709
710
711
712
713 pub fn set_stand_inst_db_name(&mut self, v: String) {
715 self.message.body.set_field(tag::STAND_INST_DB_NAME, FIXString::from(v));
716 }
717
718 pub fn get_stand_inst_db_name(&self) -> Result<String, MessageRejectErrorEnum> {
720 let mut fld = field::StandInstDbNameField::new(String::new());
721 self.message.body.get_field(tag::STAND_INST_DB_NAME, &mut fld.0)?;
722 Ok(fld.value().to_string())
723 }
724
725
726 pub fn has_stand_inst_db_name(&self) -> bool {
728 self.message.body.has(tag::STAND_INST_DB_NAME)
729 }
730
731
732
733
734 pub fn set_stand_inst_db_type(&mut self, v: isize) {
736 self.message.body.set_field(tag::STAND_INST_DB_TYPE, fixer::fix_int::FIXInt::from(v));
737 }
738
739 pub fn get_stand_inst_db_type(&self) -> Result<isize, MessageRejectErrorEnum> {
741 let mut fld = field::StandInstDbTypeField::new(0);
742 self.message.body.get_field(tag::STAND_INST_DB_TYPE, &mut fld.0)?;
743 Ok(fld.value())
744 }
745
746
747 pub fn has_stand_inst_db_type(&self) -> bool {
749 self.message.body.has(tag::STAND_INST_DB_TYPE)
750 }
751
752
753
754
755 pub fn set_trade_date(&mut self, v: String) {
757 self.message.body.set_field(tag::TRADE_DATE, FIXString::from(v));
758 }
759
760 pub fn get_trade_date(&self) -> Result<String, MessageRejectErrorEnum> {
762 let mut fld = field::TradeDateField::new(String::new());
763 self.message.body.get_field(tag::TRADE_DATE, &mut fld.0)?;
764 Ok(fld.value().to_string())
765 }
766
767
768 pub fn has_trade_date(&self) -> bool {
770 self.message.body.has(tag::TRADE_DATE)
771 }
772
773
774
775
776 pub fn set_trading_session_id(&mut self, v: String) {
778 self.message.body.set_field(tag::TRADING_SESSION_ID, FIXString::from(v));
779 }
780
781 pub fn get_trading_session_id(&self) -> Result<String, MessageRejectErrorEnum> {
783 let mut fld = field::TradingSessionIDField::new(String::new());
784 self.message.body.get_field(tag::TRADING_SESSION_ID, &mut fld.0)?;
785 Ok(fld.value().to_string())
786 }
787
788
789 pub fn has_trading_session_id(&self) -> bool {
791 self.message.body.has(tag::TRADING_SESSION_ID)
792 }
793
794
795
796
797 pub fn set_transact_time(&mut self, v: Timestamp) {
799 self.message.body.set_field(tag::TRANSACT_TIME, fixer::fix_utc_timestamp::FIXUTCTimestamp {
800 time: v,
801 precision: fixer::fix_utc_timestamp::TimestampPrecision::Millis,
802 });
803 }
804
805 pub fn get_transact_time(&self) -> Result<Timestamp, MessageRejectErrorEnum> {
807 let mut fld = field::TransactTimeField::new(Timestamp::UNIX_EPOCH);
808 self.message.body.get_field(tag::TRANSACT_TIME, &mut fld.0)?;
809 Ok(fld.value())
810 }
811
812
813 pub fn has_transact_time(&self) -> bool {
815 self.message.body.has(tag::TRANSACT_TIME)
816 }
817
818
819}
820
821pub type RouteOut = fn(msg: SettlementInstructions, session_id: SessionID) -> Result<(), MessageRejectErrorEnum>;
823
824pub type Route = (&'static str, &'static str, Box<dyn Fn(&Message, SessionID) -> Result<(), MessageRejectErrorEnum> + Send>);
826
827pub fn route(router: RouteOut) -> Route {
829 let r = move |msg: &Message, session_id: SessionID| -> Result<(), MessageRejectErrorEnum> {
830 router(SettlementInstructions::from_message(msg.clone()), session_id)
831 };
832 ("FIX.4.2", "T", Box::new(r))
833}