fixer_fix/fix50sp1/
security_list.rs1#![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 crate::field;
14use crate::tag;
15
16pub struct SecurityList {
18 pub message: Message,
19}
20
21impl SecurityList {
22 pub fn new() -> Self {
24 let mut msg = Message::new();
25 msg.header.set_field(tag::MSG_TYPE, FIXString::from("y".to_string()));
26
27 Self { message: msg }
28 }
29
30 pub fn from_message(msg: Message) -> Self {
32 Self { message: msg }
33 }
34
35 pub fn to_message(self) -> Message {
37 self.message
38 }
39
40
41
42
43 pub fn set_appl_id(&mut self, v: String) {
45 self.message.body.set_field(tag::APPL_ID, FIXString::from(v));
46 }
47
48 pub fn get_appl_id(&self) -> Result<String, MessageRejectErrorEnum> {
50 let mut fld = field::ApplIDField::new(String::new());
51 self.message.body.get_field(tag::APPL_ID, &mut fld.0)?;
52 Ok(fld.value().to_string())
53 }
54
55
56 pub fn has_appl_id(&self) -> bool {
58 self.message.body.has(tag::APPL_ID)
59 }
60
61
62
63
64 pub fn set_appl_last_seq_num(&mut self, v: isize) {
66 self.message.body.set_field(tag::APPL_LAST_SEQ_NUM, fixer::fix_int::FIXInt::from(v));
67 }
68
69 pub fn get_appl_last_seq_num(&self) -> Result<isize, MessageRejectErrorEnum> {
71 let mut fld = field::ApplLastSeqNumField::new(0);
72 self.message.body.get_field(tag::APPL_LAST_SEQ_NUM, &mut fld.0)?;
73 Ok(fld.value())
74 }
75
76
77 pub fn has_appl_last_seq_num(&self) -> bool {
79 self.message.body.has(tag::APPL_LAST_SEQ_NUM)
80 }
81
82
83
84
85 pub fn set_appl_resend_flag(&mut self, v: bool) {
87 self.message.body.set_field(tag::APPL_RESEND_FLAG, fixer::fix_boolean::FIXBoolean::from(v));
88 }
89
90 pub fn get_appl_resend_flag(&self) -> Result<bool, MessageRejectErrorEnum> {
92 let mut fld = field::ApplResendFlagField::new(false);
93 self.message.body.get_field(tag::APPL_RESEND_FLAG, &mut fld.0)?;
94 Ok(fld.value())
95 }
96
97
98 pub fn has_appl_resend_flag(&self) -> bool {
100 self.message.body.has(tag::APPL_RESEND_FLAG)
101 }
102
103
104
105
106 pub fn set_appl_seq_num(&mut self, v: isize) {
108 self.message.body.set_field(tag::APPL_SEQ_NUM, fixer::fix_int::FIXInt::from(v));
109 }
110
111 pub fn get_appl_seq_num(&self) -> Result<isize, MessageRejectErrorEnum> {
113 let mut fld = field::ApplSeqNumField::new(0);
114 self.message.body.get_field(tag::APPL_SEQ_NUM, &mut fld.0)?;
115 Ok(fld.value())
116 }
117
118
119 pub fn has_appl_seq_num(&self) -> bool {
121 self.message.body.has(tag::APPL_SEQ_NUM)
122 }
123
124
125
126
127 pub fn set_clearing_business_date(&mut self, v: String) {
129 self.message.body.set_field(tag::CLEARING_BUSINESS_DATE, FIXString::from(v));
130 }
131
132 pub fn get_clearing_business_date(&self) -> Result<String, MessageRejectErrorEnum> {
134 let mut fld = field::ClearingBusinessDateField::new(String::new());
135 self.message.body.get_field(tag::CLEARING_BUSINESS_DATE, &mut fld.0)?;
136 Ok(fld.value().to_string())
137 }
138
139
140 pub fn has_clearing_business_date(&self) -> bool {
142 self.message.body.has(tag::CLEARING_BUSINESS_DATE)
143 }
144
145
146
147
148 pub fn set_last_fragment(&mut self, v: bool) {
150 self.message.body.set_field(tag::LAST_FRAGMENT, fixer::fix_boolean::FIXBoolean::from(v));
151 }
152
153 pub fn get_last_fragment(&self) -> Result<bool, MessageRejectErrorEnum> {
155 let mut fld = field::LastFragmentField::new(false);
156 self.message.body.get_field(tag::LAST_FRAGMENT, &mut fld.0)?;
157 Ok(fld.value())
158 }
159
160
161 pub fn has_last_fragment(&self) -> bool {
163 self.message.body.has(tag::LAST_FRAGMENT)
164 }
165
166
167
168
169 pub fn set_market_id(&mut self, v: String) {
171 self.message.body.set_field(tag::MARKET_ID, FIXString::from(v));
172 }
173
174 pub fn get_market_id(&self) -> Result<String, MessageRejectErrorEnum> {
176 let mut fld = field::MarketIDField::new(String::new());
177 self.message.body.get_field(tag::MARKET_ID, &mut fld.0)?;
178 Ok(fld.value().to_string())
179 }
180
181
182 pub fn has_market_id(&self) -> bool {
184 self.message.body.has(tag::MARKET_ID)
185 }
186
187
188
189
190 pub fn set_market_segment_id(&mut self, v: String) {
192 self.message.body.set_field(tag::MARKET_SEGMENT_ID, FIXString::from(v));
193 }
194
195 pub fn get_market_segment_id(&self) -> Result<String, MessageRejectErrorEnum> {
197 let mut fld = field::MarketSegmentIDField::new(String::new());
198 self.message.body.get_field(tag::MARKET_SEGMENT_ID, &mut fld.0)?;
199 Ok(fld.value().to_string())
200 }
201
202
203 pub fn has_market_segment_id(&self) -> bool {
205 self.message.body.has(tag::MARKET_SEGMENT_ID)
206 }
207
208
209
210
211 pub fn set_no_related_sym(&mut self, v: isize) {
213 self.message.body.set_field(tag::NO_RELATED_SYM, fixer::fix_int::FIXInt::from(v));
214 }
215
216 pub fn get_no_related_sym(&self) -> Result<isize, MessageRejectErrorEnum> {
218 let mut fld = field::NoRelatedSymField::new(0);
219 self.message.body.get_field(tag::NO_RELATED_SYM, &mut fld.0)?;
220 Ok(fld.value())
221 }
222
223
224 pub fn has_no_related_sym(&self) -> bool {
226 self.message.body.has(tag::NO_RELATED_SYM)
227 }
228
229
230
231
232 pub fn set_security_report_id(&mut self, v: isize) {
234 self.message.body.set_field(tag::SECURITY_REPORT_ID, fixer::fix_int::FIXInt::from(v));
235 }
236
237 pub fn get_security_report_id(&self) -> Result<isize, MessageRejectErrorEnum> {
239 let mut fld = field::SecurityReportIDField::new(0);
240 self.message.body.get_field(tag::SECURITY_REPORT_ID, &mut fld.0)?;
241 Ok(fld.value())
242 }
243
244
245 pub fn has_security_report_id(&self) -> bool {
247 self.message.body.has(tag::SECURITY_REPORT_ID)
248 }
249
250
251
252
253 pub fn set_security_req_id(&mut self, v: String) {
255 self.message.body.set_field(tag::SECURITY_REQ_ID, FIXString::from(v));
256 }
257
258 pub fn get_security_req_id(&self) -> Result<String, MessageRejectErrorEnum> {
260 let mut fld = field::SecurityReqIDField::new(String::new());
261 self.message.body.get_field(tag::SECURITY_REQ_ID, &mut fld.0)?;
262 Ok(fld.value().to_string())
263 }
264
265
266 pub fn has_security_req_id(&self) -> bool {
268 self.message.body.has(tag::SECURITY_REQ_ID)
269 }
270
271
272
273
274 pub fn set_security_request_result(&mut self, v: isize) {
276 self.message.body.set_field(tag::SECURITY_REQUEST_RESULT, fixer::fix_int::FIXInt::from(v));
277 }
278
279 pub fn get_security_request_result(&self) -> Result<isize, MessageRejectErrorEnum> {
281 let mut fld = field::SecurityRequestResultField::new(0);
282 self.message.body.get_field(tag::SECURITY_REQUEST_RESULT, &mut fld.0)?;
283 Ok(fld.value())
284 }
285
286
287 pub fn has_security_request_result(&self) -> bool {
289 self.message.body.has(tag::SECURITY_REQUEST_RESULT)
290 }
291
292
293
294
295 pub fn set_security_response_id(&mut self, v: String) {
297 self.message.body.set_field(tag::SECURITY_RESPONSE_ID, FIXString::from(v));
298 }
299
300 pub fn get_security_response_id(&self) -> Result<String, MessageRejectErrorEnum> {
302 let mut fld = field::SecurityResponseIDField::new(String::new());
303 self.message.body.get_field(tag::SECURITY_RESPONSE_ID, &mut fld.0)?;
304 Ok(fld.value().to_string())
305 }
306
307
308 pub fn has_security_response_id(&self) -> bool {
310 self.message.body.has(tag::SECURITY_RESPONSE_ID)
311 }
312
313
314
315
316 pub fn set_tot_no_related_sym(&mut self, v: isize) {
318 self.message.body.set_field(tag::TOT_NO_RELATED_SYM, fixer::fix_int::FIXInt::from(v));
319 }
320
321 pub fn get_tot_no_related_sym(&self) -> Result<isize, MessageRejectErrorEnum> {
323 let mut fld = field::TotNoRelatedSymField::new(0);
324 self.message.body.get_field(tag::TOT_NO_RELATED_SYM, &mut fld.0)?;
325 Ok(fld.value())
326 }
327
328
329 pub fn has_tot_no_related_sym(&self) -> bool {
331 self.message.body.has(tag::TOT_NO_RELATED_SYM)
332 }
333
334
335}
336
337pub type RouteOut = fn(msg: SecurityList, session_id: SessionID) -> Result<(), MessageRejectErrorEnum>;
339
340pub type Route = (&'static str, &'static str, Box<dyn Fn(&Message, SessionID) -> Result<(), MessageRejectErrorEnum> + Send>);
342
343pub fn route(router: RouteOut) -> Route {
345 let r = move |msg: &Message, session_id: SessionID| -> Result<(), MessageRejectErrorEnum> {
346 router(SecurityList::from_message(msg.clone()), session_id)
347 };
348 ("8", "y", Box::new(r))
349}