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
12use rust_decimal::Decimal;
13
14
15use crate::field;
16use crate::tag;
17
18pub struct QuoteStatusRequest {
20 pub message: Message,
21}
22
23impl QuoteStatusRequest {
24 pub fn new() -> Self {
26 let mut msg = Message::new();
27 msg.header.set_field(tag::MSG_TYPE, FIXString::from("a".to_string()));
28
29 Self { message: msg }
30 }
31
32 pub fn from_message(msg: Message) -> Self {
34 Self { message: msg }
35 }
36
37 pub fn to_message(self) -> Message {
39 self.message
40 }
41
42
43
44
45 pub fn set_account(&mut self, v: String) {
47 self.message.body.set_field(tag::ACCOUNT, FIXString::from(v));
48 }
49
50 pub fn get_account(&self) -> Result<String, MessageRejectErrorEnum> {
52 let mut fld = field::AccountField::new(String::new());
53 self.message.body.get_field(tag::ACCOUNT, &mut fld.0)?;
54 Ok(fld.value().to_string())
55 }
56
57
58 pub fn has_account(&self) -> bool {
60 self.message.body.has(tag::ACCOUNT)
61 }
62
63
64
65
66 pub fn set_account_type(&mut self, v: isize) {
68 self.message.body.set_field(tag::ACCOUNT_TYPE, fixer::fix_int::FIXInt::from(v));
69 }
70
71 pub fn get_account_type(&self) -> Result<isize, MessageRejectErrorEnum> {
73 let mut fld = field::AccountTypeField::new(0);
74 self.message.body.get_field(tag::ACCOUNT_TYPE, &mut fld.0)?;
75 Ok(fld.value())
76 }
77
78
79 pub fn has_account_type(&self) -> bool {
81 self.message.body.has(tag::ACCOUNT_TYPE)
82 }
83
84
85
86
87 pub fn set_cfi_code(&mut self, v: String) {
89 self.message.body.set_field(tag::CFI_CODE, FIXString::from(v));
90 }
91
92 pub fn get_cfi_code(&self) -> Result<String, MessageRejectErrorEnum> {
94 let mut fld = field::CFICodeField::new(String::new());
95 self.message.body.get_field(tag::CFI_CODE, &mut fld.0)?;
96 Ok(fld.value().to_string())
97 }
98
99
100 pub fn has_cfi_code(&self) -> bool {
102 self.message.body.has(tag::CFI_CODE)
103 }
104
105
106
107
108 pub fn set_contract_multiplier(&mut self, val: Decimal, scale: i32) {
110 self.message.body.set_field(tag::CONTRACT_MULTIPLIER, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
111 }
112
113 pub fn get_contract_multiplier(&self) -> Result<Decimal, MessageRejectErrorEnum> {
115 let mut fld = field::ContractMultiplierField::new(Decimal::ZERO, 0);
116 self.message.body.get_field(tag::CONTRACT_MULTIPLIER, &mut fld.0)?;
117 Ok(fld.value())
118 }
119
120
121 pub fn has_contract_multiplier(&self) -> bool {
123 self.message.body.has(tag::CONTRACT_MULTIPLIER)
124 }
125
126
127
128
129 pub fn set_country_of_issue(&mut self, v: String) {
131 self.message.body.set_field(tag::COUNTRY_OF_ISSUE, FIXString::from(v));
132 }
133
134 pub fn get_country_of_issue(&self) -> Result<String, MessageRejectErrorEnum> {
136 let mut fld = field::CountryOfIssueField::new(String::new());
137 self.message.body.get_field(tag::COUNTRY_OF_ISSUE, &mut fld.0)?;
138 Ok(fld.value().to_string())
139 }
140
141
142 pub fn has_country_of_issue(&self) -> bool {
144 self.message.body.has(tag::COUNTRY_OF_ISSUE)
145 }
146
147
148
149
150 pub fn set_coupon_payment_date(&mut self, v: String) {
152 self.message.body.set_field(tag::COUPON_PAYMENT_DATE, FIXString::from(v));
153 }
154
155 pub fn get_coupon_payment_date(&self) -> Result<String, MessageRejectErrorEnum> {
157 let mut fld = field::CouponPaymentDateField::new(String::new());
158 self.message.body.get_field(tag::COUPON_PAYMENT_DATE, &mut fld.0)?;
159 Ok(fld.value().to_string())
160 }
161
162
163 pub fn has_coupon_payment_date(&self) -> bool {
165 self.message.body.has(tag::COUPON_PAYMENT_DATE)
166 }
167
168
169
170
171 pub fn set_coupon_rate(&mut self, val: Decimal, scale: i32) {
173 self.message.body.set_field(tag::COUPON_RATE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
174 }
175
176 pub fn get_coupon_rate(&self) -> Result<Decimal, MessageRejectErrorEnum> {
178 let mut fld = field::CouponRateField::new(Decimal::ZERO, 0);
179 self.message.body.get_field(tag::COUPON_RATE, &mut fld.0)?;
180 Ok(fld.value())
181 }
182
183
184 pub fn has_coupon_rate(&self) -> bool {
186 self.message.body.has(tag::COUPON_RATE)
187 }
188
189
190
191
192 pub fn set_credit_rating(&mut self, v: String) {
194 self.message.body.set_field(tag::CREDIT_RATING, FIXString::from(v));
195 }
196
197 pub fn get_credit_rating(&self) -> Result<String, MessageRejectErrorEnum> {
199 let mut fld = field::CreditRatingField::new(String::new());
200 self.message.body.get_field(tag::CREDIT_RATING, &mut fld.0)?;
201 Ok(fld.value().to_string())
202 }
203
204
205 pub fn has_credit_rating(&self) -> bool {
207 self.message.body.has(tag::CREDIT_RATING)
208 }
209
210
211
212
213 pub fn set_encoded_issuer(&mut self, v: String) {
215 self.message.body.set_field(tag::ENCODED_ISSUER, FIXString::from(v));
216 }
217
218 pub fn get_encoded_issuer(&self) -> Result<String, MessageRejectErrorEnum> {
220 let mut fld = field::EncodedIssuerField::new(String::new());
221 self.message.body.get_field(tag::ENCODED_ISSUER, &mut fld.0)?;
222 Ok(fld.value().to_string())
223 }
224
225
226 pub fn has_encoded_issuer(&self) -> bool {
228 self.message.body.has(tag::ENCODED_ISSUER)
229 }
230
231
232
233
234 pub fn set_encoded_issuer_len(&mut self, v: isize) {
236 self.message.body.set_field(tag::ENCODED_ISSUER_LEN, fixer::fix_int::FIXInt::from(v));
237 }
238
239 pub fn get_encoded_issuer_len(&self) -> Result<isize, MessageRejectErrorEnum> {
241 let mut fld = field::EncodedIssuerLenField::new(0);
242 self.message.body.get_field(tag::ENCODED_ISSUER_LEN, &mut fld.0)?;
243 Ok(fld.value())
244 }
245
246
247 pub fn has_encoded_issuer_len(&self) -> bool {
249 self.message.body.has(tag::ENCODED_ISSUER_LEN)
250 }
251
252
253
254
255 pub fn set_encoded_security_desc(&mut self, v: String) {
257 self.message.body.set_field(tag::ENCODED_SECURITY_DESC, FIXString::from(v));
258 }
259
260 pub fn get_encoded_security_desc(&self) -> Result<String, MessageRejectErrorEnum> {
262 let mut fld = field::EncodedSecurityDescField::new(String::new());
263 self.message.body.get_field(tag::ENCODED_SECURITY_DESC, &mut fld.0)?;
264 Ok(fld.value().to_string())
265 }
266
267
268 pub fn has_encoded_security_desc(&self) -> bool {
270 self.message.body.has(tag::ENCODED_SECURITY_DESC)
271 }
272
273
274
275
276 pub fn set_encoded_security_desc_len(&mut self, v: isize) {
278 self.message.body.set_field(tag::ENCODED_SECURITY_DESC_LEN, fixer::fix_int::FIXInt::from(v));
279 }
280
281 pub fn get_encoded_security_desc_len(&self) -> Result<isize, MessageRejectErrorEnum> {
283 let mut fld = field::EncodedSecurityDescLenField::new(0);
284 self.message.body.get_field(tag::ENCODED_SECURITY_DESC_LEN, &mut fld.0)?;
285 Ok(fld.value())
286 }
287
288
289 pub fn has_encoded_security_desc_len(&self) -> bool {
291 self.message.body.has(tag::ENCODED_SECURITY_DESC_LEN)
292 }
293
294
295
296
297 pub fn set_factor(&mut self, val: Decimal, scale: i32) {
299 self.message.body.set_field(tag::FACTOR, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
300 }
301
302 pub fn get_factor(&self) -> Result<Decimal, MessageRejectErrorEnum> {
304 let mut fld = field::FactorField::new(Decimal::ZERO, 0);
305 self.message.body.get_field(tag::FACTOR, &mut fld.0)?;
306 Ok(fld.value())
307 }
308
309
310 pub fn has_factor(&self) -> bool {
312 self.message.body.has(tag::FACTOR)
313 }
314
315
316
317
318 pub fn set_instr_registry(&mut self, v: String) {
320 self.message.body.set_field(tag::INSTR_REGISTRY, FIXString::from(v));
321 }
322
323 pub fn get_instr_registry(&self) -> Result<String, MessageRejectErrorEnum> {
325 let mut fld = field::InstrRegistryField::new(String::new());
326 self.message.body.get_field(tag::INSTR_REGISTRY, &mut fld.0)?;
327 Ok(fld.value().to_string())
328 }
329
330
331 pub fn has_instr_registry(&self) -> bool {
333 self.message.body.has(tag::INSTR_REGISTRY)
334 }
335
336
337
338
339 pub fn set_issue_date(&mut self, v: String) {
341 self.message.body.set_field(tag::ISSUE_DATE, FIXString::from(v));
342 }
343
344 pub fn get_issue_date(&self) -> Result<String, MessageRejectErrorEnum> {
346 let mut fld = field::IssueDateField::new(String::new());
347 self.message.body.get_field(tag::ISSUE_DATE, &mut fld.0)?;
348 Ok(fld.value().to_string())
349 }
350
351
352 pub fn has_issue_date(&self) -> bool {
354 self.message.body.has(tag::ISSUE_DATE)
355 }
356
357
358
359
360 pub fn set_issuer(&mut self, v: String) {
362 self.message.body.set_field(tag::ISSUER, FIXString::from(v));
363 }
364
365 pub fn get_issuer(&self) -> Result<String, MessageRejectErrorEnum> {
367 let mut fld = field::IssuerField::new(String::new());
368 self.message.body.get_field(tag::ISSUER, &mut fld.0)?;
369 Ok(fld.value().to_string())
370 }
371
372
373 pub fn has_issuer(&self) -> bool {
375 self.message.body.has(tag::ISSUER)
376 }
377
378
379
380
381 pub fn set_locale_of_issue(&mut self, v: String) {
383 self.message.body.set_field(tag::LOCALE_OF_ISSUE, FIXString::from(v));
384 }
385
386 pub fn get_locale_of_issue(&self) -> Result<String, MessageRejectErrorEnum> {
388 let mut fld = field::LocaleOfIssueField::new(String::new());
389 self.message.body.get_field(tag::LOCALE_OF_ISSUE, &mut fld.0)?;
390 Ok(fld.value().to_string())
391 }
392
393
394 pub fn has_locale_of_issue(&self) -> bool {
396 self.message.body.has(tag::LOCALE_OF_ISSUE)
397 }
398
399
400
401
402 pub fn set_maturity_date(&mut self, v: String) {
404 self.message.body.set_field(tag::MATURITY_DATE, FIXString::from(v));
405 }
406
407 pub fn get_maturity_date(&self) -> Result<String, MessageRejectErrorEnum> {
409 let mut fld = field::MaturityDateField::new(String::new());
410 self.message.body.get_field(tag::MATURITY_DATE, &mut fld.0)?;
411 Ok(fld.value().to_string())
412 }
413
414
415 pub fn has_maturity_date(&self) -> bool {
417 self.message.body.has(tag::MATURITY_DATE)
418 }
419
420
421
422
423 pub fn set_maturity_month_year(&mut self, v: String) {
425 self.message.body.set_field(tag::MATURITY_MONTH_YEAR, FIXString::from(v));
426 }
427
428 pub fn get_maturity_month_year(&self) -> Result<String, MessageRejectErrorEnum> {
430 let mut fld = field::MaturityMonthYearField::new(String::new());
431 self.message.body.get_field(tag::MATURITY_MONTH_YEAR, &mut fld.0)?;
432 Ok(fld.value().to_string())
433 }
434
435
436 pub fn has_maturity_month_year(&self) -> bool {
438 self.message.body.has(tag::MATURITY_MONTH_YEAR)
439 }
440
441
442
443
444 pub fn set_no_party_i_ds(&mut self, v: isize) {
446 self.message.body.set_field(tag::NO_PARTY_I_DS, fixer::fix_int::FIXInt::from(v));
447 }
448
449 pub fn get_no_party_i_ds(&self) -> Result<isize, MessageRejectErrorEnum> {
451 let mut fld = field::NoPartyIDsField::new(0);
452 self.message.body.get_field(tag::NO_PARTY_I_DS, &mut fld.0)?;
453 Ok(fld.value())
454 }
455
456
457 pub fn has_no_party_i_ds(&self) -> bool {
459 self.message.body.has(tag::NO_PARTY_I_DS)
460 }
461
462
463
464
465 pub fn set_no_security_alt_id(&mut self, v: isize) {
467 self.message.body.set_field(tag::NO_SECURITY_ALT_ID, fixer::fix_int::FIXInt::from(v));
468 }
469
470 pub fn get_no_security_alt_id(&self) -> Result<isize, MessageRejectErrorEnum> {
472 let mut fld = field::NoSecurityAltIDField::new(0);
473 self.message.body.get_field(tag::NO_SECURITY_ALT_ID, &mut fld.0)?;
474 Ok(fld.value())
475 }
476
477
478 pub fn has_no_security_alt_id(&self) -> bool {
480 self.message.body.has(tag::NO_SECURITY_ALT_ID)
481 }
482
483
484
485
486 pub fn set_opt_attribute(&mut self, v: String) {
488 self.message.body.set_field(tag::OPT_ATTRIBUTE, FIXString::from(v));
489 }
490
491 pub fn get_opt_attribute(&self) -> Result<String, MessageRejectErrorEnum> {
493 let mut fld = field::OptAttributeField::new(String::new());
494 self.message.body.get_field(tag::OPT_ATTRIBUTE, &mut fld.0)?;
495 Ok(fld.value().to_string())
496 }
497
498
499 pub fn has_opt_attribute(&self) -> bool {
501 self.message.body.has(tag::OPT_ATTRIBUTE)
502 }
503
504
505
506
507 pub fn set_product(&mut self, v: isize) {
509 self.message.body.set_field(tag::PRODUCT, fixer::fix_int::FIXInt::from(v));
510 }
511
512 pub fn get_product(&self) -> Result<isize, MessageRejectErrorEnum> {
514 let mut fld = field::ProductField::new(0);
515 self.message.body.get_field(tag::PRODUCT, &mut fld.0)?;
516 Ok(fld.value())
517 }
518
519
520 pub fn has_product(&self) -> bool {
522 self.message.body.has(tag::PRODUCT)
523 }
524
525
526
527
528 pub fn set_quote_id(&mut self, v: String) {
530 self.message.body.set_field(tag::QUOTE_ID, FIXString::from(v));
531 }
532
533 pub fn get_quote_id(&self) -> Result<String, MessageRejectErrorEnum> {
535 let mut fld = field::QuoteIDField::new(String::new());
536 self.message.body.get_field(tag::QUOTE_ID, &mut fld.0)?;
537 Ok(fld.value().to_string())
538 }
539
540
541 pub fn has_quote_id(&self) -> bool {
543 self.message.body.has(tag::QUOTE_ID)
544 }
545
546
547
548
549 pub fn set_quote_status_req_id(&mut self, v: String) {
551 self.message.body.set_field(tag::QUOTE_STATUS_REQ_ID, FIXString::from(v));
552 }
553
554 pub fn get_quote_status_req_id(&self) -> Result<String, MessageRejectErrorEnum> {
556 let mut fld = field::QuoteStatusReqIDField::new(String::new());
557 self.message.body.get_field(tag::QUOTE_STATUS_REQ_ID, &mut fld.0)?;
558 Ok(fld.value().to_string())
559 }
560
561
562 pub fn has_quote_status_req_id(&self) -> bool {
564 self.message.body.has(tag::QUOTE_STATUS_REQ_ID)
565 }
566
567
568
569
570 pub fn set_redemption_date(&mut self, v: String) {
572 self.message.body.set_field(tag::REDEMPTION_DATE, FIXString::from(v));
573 }
574
575 pub fn get_redemption_date(&self) -> Result<String, MessageRejectErrorEnum> {
577 let mut fld = field::RedemptionDateField::new(String::new());
578 self.message.body.get_field(tag::REDEMPTION_DATE, &mut fld.0)?;
579 Ok(fld.value().to_string())
580 }
581
582
583 pub fn has_redemption_date(&self) -> bool {
585 self.message.body.has(tag::REDEMPTION_DATE)
586 }
587
588
589
590
591 pub fn set_repo_collateral_security_type(&mut self, v: isize) {
593 self.message.body.set_field(tag::REPO_COLLATERAL_SECURITY_TYPE, fixer::fix_int::FIXInt::from(v));
594 }
595
596 pub fn get_repo_collateral_security_type(&self) -> Result<isize, MessageRejectErrorEnum> {
598 let mut fld = field::RepoCollateralSecurityTypeField::new(0);
599 self.message.body.get_field(tag::REPO_COLLATERAL_SECURITY_TYPE, &mut fld.0)?;
600 Ok(fld.value())
601 }
602
603
604 pub fn has_repo_collateral_security_type(&self) -> bool {
606 self.message.body.has(tag::REPO_COLLATERAL_SECURITY_TYPE)
607 }
608
609
610
611
612 pub fn set_repurchase_rate(&mut self, val: Decimal, scale: i32) {
614 self.message.body.set_field(tag::REPURCHASE_RATE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
615 }
616
617 pub fn get_repurchase_rate(&self) -> Result<Decimal, MessageRejectErrorEnum> {
619 let mut fld = field::RepurchaseRateField::new(Decimal::ZERO, 0);
620 self.message.body.get_field(tag::REPURCHASE_RATE, &mut fld.0)?;
621 Ok(fld.value())
622 }
623
624
625 pub fn has_repurchase_rate(&self) -> bool {
627 self.message.body.has(tag::REPURCHASE_RATE)
628 }
629
630
631
632
633 pub fn set_repurchase_term(&mut self, v: isize) {
635 self.message.body.set_field(tag::REPURCHASE_TERM, fixer::fix_int::FIXInt::from(v));
636 }
637
638 pub fn get_repurchase_term(&self) -> Result<isize, MessageRejectErrorEnum> {
640 let mut fld = field::RepurchaseTermField::new(0);
641 self.message.body.get_field(tag::REPURCHASE_TERM, &mut fld.0)?;
642 Ok(fld.value())
643 }
644
645
646 pub fn has_repurchase_term(&self) -> bool {
648 self.message.body.has(tag::REPURCHASE_TERM)
649 }
650
651
652
653
654 pub fn set_security_desc(&mut self, v: String) {
656 self.message.body.set_field(tag::SECURITY_DESC, FIXString::from(v));
657 }
658
659 pub fn get_security_desc(&self) -> Result<String, MessageRejectErrorEnum> {
661 let mut fld = field::SecurityDescField::new(String::new());
662 self.message.body.get_field(tag::SECURITY_DESC, &mut fld.0)?;
663 Ok(fld.value().to_string())
664 }
665
666
667 pub fn has_security_desc(&self) -> bool {
669 self.message.body.has(tag::SECURITY_DESC)
670 }
671
672
673
674
675 pub fn set_security_exchange(&mut self, v: String) {
677 self.message.body.set_field(tag::SECURITY_EXCHANGE, FIXString::from(v));
678 }
679
680 pub fn get_security_exchange(&self) -> Result<String, MessageRejectErrorEnum> {
682 let mut fld = field::SecurityExchangeField::new(String::new());
683 self.message.body.get_field(tag::SECURITY_EXCHANGE, &mut fld.0)?;
684 Ok(fld.value().to_string())
685 }
686
687
688 pub fn has_security_exchange(&self) -> bool {
690 self.message.body.has(tag::SECURITY_EXCHANGE)
691 }
692
693
694
695
696 pub fn set_security_id(&mut self, v: String) {
698 self.message.body.set_field(tag::SECURITY_ID, FIXString::from(v));
699 }
700
701 pub fn get_security_id(&self) -> Result<String, MessageRejectErrorEnum> {
703 let mut fld = field::SecurityIDField::new(String::new());
704 self.message.body.get_field(tag::SECURITY_ID, &mut fld.0)?;
705 Ok(fld.value().to_string())
706 }
707
708
709 pub fn has_security_id(&self) -> bool {
711 self.message.body.has(tag::SECURITY_ID)
712 }
713
714
715
716
717 pub fn set_security_id_source(&mut self, v: String) {
719 self.message.body.set_field(tag::SECURITY_ID_SOURCE, FIXString::from(v));
720 }
721
722 pub fn get_security_id_source(&self) -> Result<String, MessageRejectErrorEnum> {
724 let mut fld = field::SecurityIDSourceField::new(String::new());
725 self.message.body.get_field(tag::SECURITY_ID_SOURCE, &mut fld.0)?;
726 Ok(fld.value().to_string())
727 }
728
729
730 pub fn has_security_id_source(&self) -> bool {
732 self.message.body.has(tag::SECURITY_ID_SOURCE)
733 }
734
735
736
737
738 pub fn set_security_type(&mut self, v: String) {
740 self.message.body.set_field(tag::SECURITY_TYPE, FIXString::from(v));
741 }
742
743 pub fn get_security_type(&self) -> Result<String, MessageRejectErrorEnum> {
745 let mut fld = field::SecurityTypeField::new(String::new());
746 self.message.body.get_field(tag::SECURITY_TYPE, &mut fld.0)?;
747 Ok(fld.value().to_string())
748 }
749
750
751 pub fn has_security_type(&self) -> bool {
753 self.message.body.has(tag::SECURITY_TYPE)
754 }
755
756
757
758
759 pub fn set_state_or_province_of_issue(&mut self, v: String) {
761 self.message.body.set_field(tag::STATE_OR_PROVINCE_OF_ISSUE, FIXString::from(v));
762 }
763
764 pub fn get_state_or_province_of_issue(&self) -> Result<String, MessageRejectErrorEnum> {
766 let mut fld = field::StateOrProvinceOfIssueField::new(String::new());
767 self.message.body.get_field(tag::STATE_OR_PROVINCE_OF_ISSUE, &mut fld.0)?;
768 Ok(fld.value().to_string())
769 }
770
771
772 pub fn has_state_or_province_of_issue(&self) -> bool {
774 self.message.body.has(tag::STATE_OR_PROVINCE_OF_ISSUE)
775 }
776
777
778
779
780 pub fn set_strike_price(&mut self, val: Decimal, scale: i32) {
782 self.message.body.set_field(tag::STRIKE_PRICE, fixer::fix_decimal::FIXDecimal { decimal: val, scale });
783 }
784
785 pub fn get_strike_price(&self) -> Result<Decimal, MessageRejectErrorEnum> {
787 let mut fld = field::StrikePriceField::new(Decimal::ZERO, 0);
788 self.message.body.get_field(tag::STRIKE_PRICE, &mut fld.0)?;
789 Ok(fld.value())
790 }
791
792
793 pub fn has_strike_price(&self) -> bool {
795 self.message.body.has(tag::STRIKE_PRICE)
796 }
797
798
799
800
801 pub fn set_subscription_request_type(&mut self, v: String) {
803 self.message.body.set_field(tag::SUBSCRIPTION_REQUEST_TYPE, FIXString::from(v));
804 }
805
806 pub fn get_subscription_request_type(&self) -> Result<String, MessageRejectErrorEnum> {
808 let mut fld = field::SubscriptionRequestTypeField::new(String::new());
809 self.message.body.get_field(tag::SUBSCRIPTION_REQUEST_TYPE, &mut fld.0)?;
810 Ok(fld.value().to_string())
811 }
812
813
814 pub fn has_subscription_request_type(&self) -> bool {
816 self.message.body.has(tag::SUBSCRIPTION_REQUEST_TYPE)
817 }
818
819
820
821
822 pub fn set_symbol(&mut self, v: String) {
824 self.message.body.set_field(tag::SYMBOL, FIXString::from(v));
825 }
826
827 pub fn get_symbol(&self) -> Result<String, MessageRejectErrorEnum> {
829 let mut fld = field::SymbolField::new(String::new());
830 self.message.body.get_field(tag::SYMBOL, &mut fld.0)?;
831 Ok(fld.value().to_string())
832 }
833
834
835 pub fn has_symbol(&self) -> bool {
837 self.message.body.has(tag::SYMBOL)
838 }
839
840
841
842
843 pub fn set_symbol_sfx(&mut self, v: String) {
845 self.message.body.set_field(tag::SYMBOL_SFX, FIXString::from(v));
846 }
847
848 pub fn get_symbol_sfx(&self) -> Result<String, MessageRejectErrorEnum> {
850 let mut fld = field::SymbolSfxField::new(String::new());
851 self.message.body.get_field(tag::SYMBOL_SFX, &mut fld.0)?;
852 Ok(fld.value().to_string())
853 }
854
855
856 pub fn has_symbol_sfx(&self) -> bool {
858 self.message.body.has(tag::SYMBOL_SFX)
859 }
860
861
862
863
864 pub fn set_trading_session_id(&mut self, v: String) {
866 self.message.body.set_field(tag::TRADING_SESSION_ID, FIXString::from(v));
867 }
868
869 pub fn get_trading_session_id(&self) -> Result<String, MessageRejectErrorEnum> {
871 let mut fld = field::TradingSessionIDField::new(String::new());
872 self.message.body.get_field(tag::TRADING_SESSION_ID, &mut fld.0)?;
873 Ok(fld.value().to_string())
874 }
875
876
877 pub fn has_trading_session_id(&self) -> bool {
879 self.message.body.has(tag::TRADING_SESSION_ID)
880 }
881
882
883
884
885 pub fn set_trading_session_sub_id(&mut self, v: String) {
887 self.message.body.set_field(tag::TRADING_SESSION_SUB_ID, FIXString::from(v));
888 }
889
890 pub fn get_trading_session_sub_id(&self) -> Result<String, MessageRejectErrorEnum> {
892 let mut fld = field::TradingSessionSubIDField::new(String::new());
893 self.message.body.get_field(tag::TRADING_SESSION_SUB_ID, &mut fld.0)?;
894 Ok(fld.value().to_string())
895 }
896
897
898 pub fn has_trading_session_sub_id(&self) -> bool {
900 self.message.body.has(tag::TRADING_SESSION_SUB_ID)
901 }
902
903
904}
905
906pub type RouteOut = fn(msg: QuoteStatusRequest, session_id: SessionID) -> Result<(), MessageRejectErrorEnum>;
908
909pub type Route = (&'static str, &'static str, Box<dyn Fn(&Message, SessionID) -> Result<(), MessageRejectErrorEnum> + Send>);
911
912pub fn route(router: RouteOut) -> Route {
914 let r = move |msg: &Message, session_id: SessionID| -> Result<(), MessageRejectErrorEnum> {
915 router(QuoteStatusRequest::from_message(msg.clone()), session_id)
916 };
917 ("FIX.4.3", "a", Box::new(r))
918}